Optimization experiment: Drop Symbol class

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

@@ -521,20 +521,20 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     /*
      * must-single-thread
      */
-    def fieldLoad( field: Symbol, hostClass: Symbol = null): Unit = fieldOp(field, isLoad = true,  hostClass)
+    def fieldLoad( field: Symbol, hostClass: Symbol | Null = null): Unit = fieldOp(field, isLoad = true,  hostClass)
 
     /*
      * must-single-thread
      */
-    def fieldStore(field: Symbol, hostClass: Symbol = null): Unit = fieldOp(field, isLoad = false, hostClass)
+    def fieldStore(field: Symbol, hostClass: Symbol | Null = null): Unit = fieldOp(field, isLoad = false, hostClass)
 
     /*
      * must-single-thread
      */
-    private def fieldOp(field: Symbol, isLoad: Boolean, specificReceiver: Symbol): Unit = {
+    private def fieldOp(field: Symbol, isLoad: Boolean, specificReceiver: Symbol | Null): Unit = {
       val useSpecificReceiver = specificReceiver != null && !field.isScalaStatic
 
-      val owner      = internalName(if (useSpecificReceiver) specificReceiver else field.owner)
+      val owner      = internalName(if (useSpecificReceiver) specificReceiver.nn else field.owner)
       val fieldJName = field.javaSimpleName
       val fieldDescr = symInfoTK(field).descriptor
       val isStatic   = field.isStaticMember
@@ -629,7 +629,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
               if (earlyReturnVar == null) {
                 earlyReturnVar = locals.makeLocal(returnType, "earlyReturnVar", expr.tpe, expr.span)
               }
-              locals.store(earlyReturnVar)
+              locals.store(earlyReturnVar.nn)
             }
             bc goTo nextCleanup
             shouldEmitCleanup = true
@@ -853,7 +853,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
               bc.invokevirtual(target, sym.javaSimpleName, methodBType.descriptor)
               generatedType = methodBType.returnType
             } else {
-              val receiverClass = if (!invokeStyle.isVirtual) null else {
+              val receiverClass: Symbol | Null = if (!invokeStyle.isVirtual) null else {
                 // receiverClass is used in the bytecode to as the method receiver. using sym.owner
                 // may lead to IllegalAccessErrors, see 9954eaf / aladdin bug 455.
                 val qualSym = qual.tpe.typeSymbol
@@ -1213,10 +1213,11 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     def genLoadModule(tree: Tree): BType = {
       val module = (
         if (!tree.symbol.is(PackageClass)) tree.symbol
-        else tree.symbol.info.member(nme.PACKAGE).symbol match {
-          case NoSymbol => abort(s"SI-5604: Cannot use package as value: $tree")
-          case s        => abort(s"SI-5604: found package class where package object expected: $tree")
-        }
+        else
+          val s = tree.symbol.info.member(nme.PACKAGE).symbol
+          if s.exists
+          then abort(s"SI-5604: found package class where package object expected: $tree")
+          else abort(s"SI-5604: Cannot use package as value: $tree")
       )
       lineNumber(tree)
       genLoadModule(module)
@@ -1388,16 +1389,16 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
      * invocation instruction, otherwise `method.owner`. A specific receiver class is needed to
      * prevent an IllegalAccessError, (aladdin bug 455).
      */
-    def genCallMethod(method: Symbol, style: InvokeStyle, pos: Span = NoSpan, specificReceiver: Symbol = null): BType = {
+    def genCallMethod(method: Symbol, style: InvokeStyle, pos: Span = NoSpan, specificReceiver: Symbol | Null = null): BType = {
       val methodOwner = method.owner
 
       // the class used in the invocation's method descriptor in the classfile
-      val receiverClass = {
+      val receiverClass: Symbol = {
         if (specificReceiver != null)
           assert(style.isVirtual || specificReceiver == methodOwner, s"specificReceiver can only be specified for virtual calls. $method - $specificReceiver")
 
-        val useSpecificReceiver = specificReceiver != null && !defn.isBottomClass(specificReceiver) && !method.isScalaStatic
-        val receiver = if (useSpecificReceiver) specificReceiver else methodOwner
+        val useSpecificReceiver = specificReceiver != null && !defn.isBottomClass(specificReceiver.nn) && !method.isScalaStatic
+        val receiver = if (useSpecificReceiver) specificReceiver.nn else methodOwner
 
         // workaround for a JVM bug: https://bugs.openjdk.java.net/browse/JDK-8154587
         // when an interface method overrides a member of Object (note that all interfaces implicitly
@@ -1431,7 +1432,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       val bmType   = asmMethodType(method)
       val mdescr   = bmType.descriptor
 
-      val isInterface = isEmittedInterface(receiverClass)
+      val isInterface = isEmittedInterface(receiverClass.nn)
       import InvokeStyle._
       if (style == Super) {
         if (isInterface && !method.is(JavaDefined)) {

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

@@ -87,7 +87,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     var cnode: ClassNode1          = null
     var thisName: String           = null // the internal name of the class being emitted
 
-    var claszSymbol: Symbol        = null
+    var claszSymbol: Symbol        = _
     var isCZParcelable             = false
     var isCZStaticModule           = false
 
@@ -364,9 +364,9 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     var jMethodName: String        = null
     var isMethSymStaticCtor        = false
     var returnType: BType          = null
-    var methSymbol: Symbol         = null
+    var methSymbol: Symbol         = _
     // used by genLoadTry() and genSynchronized()
-    var earlyReturnVar: Symbol     = null
+    var earlyReturnVar: Symbol | Null = null
     var shouldEmitCleanup          = false
     // stack tracking
     var stackHeight                = 0

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

@@ -36,7 +36,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
       // if the synchronized block returns a result, store it in a local variable.
       // Just leaving it on the stack is not valid in MSIL (stack is cleaned when leaving try-blocks).
       val hasResult = (expectedType != UNIT)
-      val monitorResult: Symbol = if (hasResult) locals.makeLocal(tpeTK(args.head), "monitorResult", defn.ObjectType, tree.span) else null
+      val monitorResult: Symbol | Null = if (hasResult) locals.makeLocal(tpeTK(args.head), "monitorResult", defn.ObjectType, tree.span) else null
 
       /* ------ (1) pushing and entering the monitor, also keeping a reference to it in a local var. ------ */
       genLoadQualifier(fun)
@@ -55,7 +55,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
       registerCleanup(monCleanup)
       genLoad(args.head, expectedType /* toTypeKind(tree.tpe.resultType) */)
       unregisterCleanup(monCleanup)
-      if (hasResult) { locals.store(monitorResult) }
+      if (hasResult) { locals.store(monitorResult.nn) }
       nopIfNeeded(startProtected)
       val endProtected = currProgramPoint()
 
@@ -66,7 +66,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
        */
       locals.load(monitor)
       emit(asm.Opcodes.MONITOREXIT)
-      if (hasResult) { locals.load(monitorResult) }
+      if (hasResult) { locals.load(monitorResult.uncheckedNN) }
       val postHandler = new asm.Label
       bc goTo postHandler
 
@@ -214,7 +214,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
        * please notice `tmp` has type tree.tpe, while `earlyReturnVar` has the method return type.
        * Because those two types can be different, dedicated vars are needed.
        */
-      val tmp          = if (guardResult) locals.makeLocal(tpeTK(tree), "tmp", tree.tpe, tree.span) else null
+      val tmp: Symbol | Null = if (guardResult) locals.makeLocal(tpeTK(tree), "tmp", tree.tpe, tree.span) else null
 
       /*
        * upon early return from the try-body or one of its EHs (but not the EH-version of the finally-clause)
@@ -375,8 +375,8 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
       cleanups match {
         case Nil =>
           if (earlyReturnVar != null) {
-            locals.load(earlyReturnVar)
-            bc.emitRETURN(locals(earlyReturnVar).tk)
+            locals.load(earlyReturnVar.uncheckedNN)
+            bc.emitRETURN(locals(earlyReturnVar.uncheckedNN).tk)
           } else {
             bc emitRETURN UNIT
           }
@@ -396,15 +396,15 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
     }
 
     /* `tmp` (if non-null) is the symbol of the local-var used to preserve the result of the try-body, see `guardResult` */
-    def emitFinalizer(finalizer: Tree, tmp: Symbol, isDuplicate: Boolean): Unit = {
+    def emitFinalizer(finalizer: Tree, tmp: Symbol | Null, isDuplicate: Boolean): Unit = {
       var saved: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null
       if (isDuplicate) {
         saved = jumpDest
       }
       // when duplicating, the above guarantees new asm.Labels are used for LabelDefs contained in the finalizer (their vars are reused, that's ok)
-      if (tmp != null) { locals.store(tmp) }
+      if (tmp != null) { locals.store(tmp.uncheckedNN) }
       genLoad(finalizer, UNIT)
-      if (tmp != null) { locals.load(tmp)  }
+      if (tmp != null) { locals.load(tmp.uncheckedNN)  }
       if (isDuplicate) {
         jumpDest = saved
       }

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -72,8 +72,8 @@ class JSCodeGen()(using genCtx: Context) {
   private val generatedClasses = mutable.ListBuffer.empty[js.ClassDef]
   private val generatedStaticForwarderClasses = mutable.ListBuffer.empty[(Symbol, js.ClassDef)]
 
-  val currentClassSym = new ScopedVar[Symbol]
-  private val currentMethodSym = new ScopedVar[Symbol]
+  val currentClassSym = new ScopedVar[Symbol | Null]
+  private val currentMethodSym = new ScopedVar[Symbol | Null]
   private val localNames = new ScopedVar[LocalNameGenerator]
   private val thisLocalVarIdent = new ScopedVar[Option[js.LocalIdent]]
   private val isModuleInitialized = new ScopedVar[ScopedVar.VarBox[Boolean]]
@@ -126,7 +126,7 @@ class JSCodeGen()(using genCtx: Context) {
   implicit def implicitLocalNames: LocalNameGenerator = localNames.get
 
   def currentThisType: jstpe.Type = {
-    encodeClassType(currentClassSym) match {
+    encodeClassType(currentClassSym.get.nn) match {
       case tpe @ jstpe.ClassType(cls) =>
         jstpe.BoxedClassToPrimType.getOrElse(cls, tpe)
       case tpe =>
@@ -856,7 +856,7 @@ class JSCodeGen()(using genCtx: Context) {
   /** Gen definitions for the fields of a class. */
   private def genClassFields(td: TypeDef): List[js.MemberDef] = {
     val classSym = td.symbol.asClass
-    assert(currentClassSym.get == classSym,
+    assert(currentClassSym.get eq classSym,
         "genClassFields called with a ClassDef other than the current one")
 
     val isJSClass = classSym.isNonNativeJSClass
@@ -1493,7 +1493,7 @@ class JSCodeGen()(using genCtx: Context) {
 
       if (primitives.isPrimitive(sym)) {
         None
-      } else if (sym.is(Deferred) && currentClassSym.isNonNativeJSClass) {
+      } else if (sym.is(Deferred) && currentClassSym.get.nn.isNonNativeJSClass) {
         // scala-js/#4409: Do not emit abstract methods in non-native JS classes
         None
       } else if (sym.is(Deferred)) {
@@ -1503,7 +1503,7 @@ class JSCodeGen()(using genCtx: Context) {
       } else if (isIgnorableDefaultParam) {
         // #11592
         None
-      } else if (sym.is(Bridge) && sym.name.is(DefaultGetterName) && currentClassSym.isNonNativeJSClass) {
+      } else if (sym.is(Bridge) && sym.name.is(DefaultGetterName) && currentClassSym.get.nn.isNonNativeJSClass) {
         /* #12572 Bridges for default accessors in non-native JS classes must not be emitted,
          * because they call another default accessor, making their entire body an
          * <undefined-param> that cannot be eliminated.
@@ -1582,7 +1582,7 @@ class JSCodeGen()(using genCtx: Context) {
       else genExpr(tree)
     }
 
-    if (namespace.isStatic || !currentClassSym.isNonNativeJSClass) {
+    if (namespace.isStatic || !currentClassSym.get.nn.isNonNativeJSClass) {
       val flags = js.MemberFlags.empty.withNamespace(namespace)
       js.MethodDef(flags, methodName, originalName, jsParams, resultIRType, Some(genBody()))(
             optimizerHints, None)
@@ -1688,7 +1688,7 @@ class JSCodeGen()(using genCtx: Context) {
     tree match {
       case _: This =>
         val sym = tree.symbol
-        if (sym != currentClassSym.get && sym.is(Module))
+        if ((sym ne currentClassSym.get) && sym.is(Module))
           genLoadModuleOrGlobalScope(sym)
         else
           MaybeGlobalScope.NotGlobalScope(genExpr(tree))
@@ -1784,7 +1784,7 @@ class JSCodeGen()(using genCtx: Context) {
         genApplyDynamic(app)*/
 
       case tree: This =>
-        val currentClass = currentClassSym.get
+        val currentClass = currentClassSym.get.nn
         val symIsModuleClass = tree.symbol.is(ModuleClass)
         assert(tree.symbol == currentClass || symIsModuleClass,
             s"Trying to access the this of another class: tree.symbol = ${tree.symbol}, class symbol = $currentClass")
@@ -1886,8 +1886,8 @@ class JSCodeGen()(using genCtx: Context) {
             val qualifier = lhs.qualifier
 
             def ctorAssignment = (
-                currentMethodSym.get.name == nme.CONSTRUCTOR &&
-                currentMethodSym.get.owner == qualifier.symbol &&
+                currentMethodSym.get.nn.name == nme.CONSTRUCTOR &&
+                currentMethodSym.get.nn.owner == qualifier.symbol &&
                 qualifier.isInstanceOf[This]
             )
             // TODO This fails for OFFSET$x fields. Re-enable when we can.
@@ -2178,7 +2178,7 @@ class JSCodeGen()(using genCtx: Context) {
     if (sym == defn.Any_getClass) {
       // The only primitive that is also callable as super call
       js.GetClass(genThis())
-    } else if (currentClassSym.isNonNativeJSClass) {
+    } else if (currentClassSym.get.nn.isNonNativeJSClass) {
       genJSSuperCall(tree, isStat)
     } else {
       /* #3013 `qual` can be `this.$outer()` in some cases since Scala 2.12,
@@ -2188,10 +2188,10 @@ class JSCodeGen()(using genCtx: Context) {
           genExpr(qual), sym, genActualArgs(sym, args))
 
       // Initialize the module instance just after the super constructor call.
-      if (isStaticModule(currentClassSym) && !isModuleInitialized.get.value &&
-          currentMethodSym.get.isClassConstructor) {
+      if (isStaticModule(currentClassSym.get.nn) && !isModuleInitialized.get.value &&
+          currentMethodSym.get.nn.isClassConstructor) {
         isModuleInitialized.get.value = true
-        val className = encodeClassName(currentClassSym)
+        val className = encodeClassName(currentClassSym.get.nn)
         val thisType = jstpe.ClassType(className)
         val initModule = js.StoreModule(className, js.This()(thisType))
         js.Block(superCall, initModule)
@@ -3245,7 +3245,7 @@ class JSCodeGen()(using genCtx: Context) {
         genApplyJSClassMethod(genReceiver, sym, genScalaArgs)
       } else {
         val jsSuperClassValue = explicitJSSuperClassValue.orElse {
-          Some(genLoadJSConstructor(currentClassSym.get.asClass.superClass))
+          Some(genLoadJSConstructor(currentClassSym.get.nn.asClass.superClass))
         }
         genApplyJSMethodGeneric(sym, MaybeGlobalScope.NotGlobalScope(genReceiver),
             genJSArgs, isStat, jsSuperClassValue)(tree.sourcePos)
@@ -3873,7 +3873,7 @@ class JSCodeGen()(using genCtx: Context) {
 
       case JS_NEW_TARGET =>
         // js.new.target
-        val valid = currentMethodSym.get.isClassConstructor && currentClassSym.isNonNativeJSClass
+        val valid = currentMethodSym.get.nn.isClassConstructor && currentClassSym.get.nn.isNonNativeJSClass
         if (!valid) {
           report.error(
               "Illegal use of js.`new`.target.\n" +

compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala

@@ -585,7 +585,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
   }
 
   private def reportCannotDisambiguateError(jsName: JSName, alts: List[Symbol]): Unit = {
-    val currentClass = currentClassSym.get
+    val currentClass = currentClassSym.get.nn
 
     /* Find a position that is in the current class for decent error reporting.
      * If there are more than one, always use the "highest" one (i.e., the
@@ -623,7 +623,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
    */
   private def genApplyForSingleExported(formalArgsRegistry: FormalArgsRegistry,
       exported: Exported, static: Boolean): js.Tree = {
-    if (currentClassSym.isJSType && exported.sym.owner != currentClassSym.get) {
+    if (currentClassSym.get.nn.isJSType && exported.sym.owner != currentClassSym.get) {
       assert(!static, s"nonsensical JS super call in static export of ${exported.sym}")
       genApplyForSingleExportedJSSuperCall(formalArgsRegistry, exported)
     } else {
@@ -642,7 +642,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
     val allArgs = formalArgsRegistry.genAllArgsRefsForForwarder()
 
     val superClass = {
-      val superClassSym = currentClassSym.asClass.superClass
+      val superClassSym = currentClassSym.get.nn.asClass.superClass
       if (superClassSym.isNestedJSClass)
         js.VarRef(js.LocalIdent(JSSuperClassParamName))(jstpe.AnyType)
       else
@@ -806,7 +806,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
       implicit pos: SourcePosition): js.Tree = {
 
     val sym = exported.sym
-    val currentClass = currentClassSym.get
+    val currentClass = currentClassSym.get.nn
 
     def receiver =
       if (static) genLoadModule(sym.owner)

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -7,6 +7,7 @@ import Types._, Contexts._, Flags._
 import Symbols._, Annotations._, Trees._, Symbols._, Constants.Constant
 import Decorators._
 import dotty.tools.dotc.transform.SymUtils._
+import Symbols.TypeTests.given
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -10,6 +10,7 @@ import config.Printers.capt
 import util.Property.Key
 import tpd.*
 import config.Feature
+import Symbols.TypeTests.given
 
 private val Captures: Key[CaptureSet] = Key()
 private val BoxedType: Key[BoxedTypeCache] = Key()

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -12,6 +12,7 @@ import transform.Recheck.*
 import CaptureSet.IdentityCaptRefMap
 import Synthetics.isExcluded
 import util.Property
+import Symbols.TypeTests.given
 
 /** A tree traverser that prepares a compilation unit to be capture checked.
  *  It does the following:

compiler/src/dotty/tools/dotc/core/Annotations.scala

@@ -7,6 +7,7 @@ import ast.tpd, tpd.*
 import util.Spans.Span
 import printing.{Showable, Printer}
 import printing.Texts.Text
+import Symbols.TypeTests.given
 
 import scala.annotation.internal.sharable
 
@@ -194,7 +195,7 @@ object Annotations {
   object Annotation {
 
     def apply(tree: Tree): ConcreteAnnotation = ConcreteAnnotation(tree)
-    
+
     def apply(cls: ClassSymbol, span: Span)(using Context): Annotation =
       apply(cls, Nil, span)
 
@@ -206,7 +207,7 @@ object Annotations {
 
     def apply(atp: Type, arg: Tree, span: Span)(using Context): Annotation =
       apply(atp, arg :: Nil, span)
-    
+
     def apply(atp: Type, args: List[Tree], span: Span)(using Context): Annotation =
       apply(New(atp, args).withSpan(span))