Inline isClass

Author: nicolasstucki

compiler/src/dotty/tools/backend/jvm/BCodeAsmCommon.scala

@@ -19,13 +19,13 @@ final class BCodeAsmCommon[I <: DottyBackendInterface](val interface: I) {
    * null.
    */
   def isAnonymousOrLocalClass(classSym: Symbol): Boolean = {
-    assert(symHelper(classSym).isClass, s"not a class: $classSym")
+    assert(classSym.isClass, s"not a class: $classSym")
     // Here used to be an `assert(!classSym.isDelambdafyFunction)`: delambdafy lambda classes are
     // always top-level. However, SI-8900 shows an example where the weak name-based implementation
     // of isDelambdafyFunction failed (for a function declared in a package named "lambda").
     classSym.isAnonymousClass || {
       val originalOwnerLexicallyEnclosingClass = symHelper(classSym.originalOwner).originalLexicallyEnclosingClass
-      originalOwnerLexicallyEnclosingClass != NoSymbol && !symHelper(originalOwnerLexicallyEnclosingClass).isClass
+      originalOwnerLexicallyEnclosingClass != NoSymbol && !originalOwnerLexicallyEnclosingClass.isClass
     }
   }
 
@@ -53,9 +53,9 @@ final class BCodeAsmCommon[I <: DottyBackendInterface](val interface: I) {
    * This is a source-level property, so we need to use the originalOwner chain to reconstruct it.
    */
   private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = {
-    assert(symHelper(classSym).isClass, classSym)
+    assert(classSym.isClass, classSym)
     def enclosingMethod(sym: Symbol): Option[Symbol] = {
-      if (symHelper(sym).isClass || sym == NoSymbol) None
+      if (sym.isClass || sym == NoSymbol) None
       else if (sym.is(Flags.Method)) Some(sym)
       else enclosingMethod(symHelper(sym.originalOwner).originalLexicallyEnclosingClass)
     }
@@ -67,9 +67,9 @@ final class BCodeAsmCommon[I <: DottyBackendInterface](val interface: I) {
    * property, this method looks at the originalOwner chain. See doc in BTypes.
    */
   private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol): Symbol = {
-    assert(symHelper(classSym).isClass, classSym)
+    assert(classSym.isClass, classSym)
     def enclosingClass(sym: Symbol): Symbol = {
-      if (symHelper(sym).isClass) sym
+      if (sym.isClass) sym
       else enclosingClass(symHelper(sym.originalOwner).originalLexicallyEnclosingClass)
     }
     enclosingClass(symHelper(classSym.originalOwner).originalLexicallyEnclosingClass)

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -206,7 +206,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     }
 
     private def assertClassNotArray(sym: Symbol): Unit = {
-      assert(symHelper(sym).isClass, sym)
+      assert(sym.isClass, sym)
       assert(sym != defn.ArrayClass || isCompilingArray, sym)
     }
 

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -48,7 +48,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
    */
   final def classBTypeFromSymbol(classSym: Symbol): ClassBType = {
     assert(classSym != NoSymbol, "Cannot create ClassBType from NoSymbol")
-    assert(symHelper(classSym).isClass, s"Cannot create ClassBType from non-class symbol $classSym")
+    assert(classSym.isClass, s"Cannot create ClassBType from non-class symbol $classSym")
     assert(
       (!primitiveTypeMap.contains(classSym) || isCompilingPrimitive) &&
       (classSym != defn.NothingClass && classSym != defn.NullClass),
@@ -160,7 +160,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
 
 
   private def buildNestedInfo(innerClassSym: Symbol): Option[NestedInfo] = {
-    assert(symHelper(innerClassSym).isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym")
+    assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym")
 
     val isNested = !symHelper(innerClassSym.originalOwner).originalLexicallyEnclosingClass.is(Flags.PackageClass)
     if (!isNested) None
@@ -170,7 +170,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
 
       // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
       val enclosingClassSym = {
-        if (symHelper(innerClassSym).isClass) {
+        if (innerClassSym.isClass) {
           val ct = ctx.withPhase(ctx.flattenPhase.prev)
           toDenot(innerClassSym)(ct).owner.enclosingClass(ct)
         }
@@ -247,7 +247,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
       if (symHelper(sym).isStaticMember) ACC_STATIC else 0,
       if (sym.is(Flags.Bridge)) ACC_BRIDGE | ACC_SYNTHETIC else 0,
       if (sym.is(Flags.Artifact)) ACC_SYNTHETIC else 0,
-      if (symHelper(sym).isClass && !symHelper(sym).isInterface) ACC_SUPER else 0,
+      if (sym.isClass && !symHelper(sym).isInterface) ACC_SUPER else 0,
       if (sym.isAllOf(Flags.JavaEnumTrait)) ACC_ENUM else 0,
       if (sym.is(Flags.JavaVarargs)) ACC_VARARGS else 0,
       if (sym.is(Flags.Synchronized)) ACC_SYNCHRONIZED else 0,

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -394,7 +394,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
   class SymbolHelper(sym: Symbol) {
 
     // tests
-    def isClass: Boolean = sym.isClass
     def isPublic: Boolean = !sym.flags.isOneOf(Flags.Private | Flags.Protected)
     def isInterface: Boolean = (sym.is(Flags.PureInterface)) || sym.is(Flags.Trait)