scala
diff --git a/‎compiler/src/dotty/tools/backend/ScalaPrimitives.scala‎
Lines changed: 3 additions & 2 deletions b/‎compiler/src/dotty/tools/backend/ScalaPrimitives.scala‎
Lines changed: 3 additions & 2 deletions
diff --git a/‎compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala‎
Lines changed: 10 additions & 9 deletions b/‎compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala‎
Lines changed: 10 additions & 9 deletions
diff --git a/‎compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala‎
Lines changed: 6 additions & 6 deletions b/‎compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎compiler/src/dotty/tools/dotc/ast/TreeInfo.scala‎
Lines changed: 3 additions & 1 deletion b/‎compiler/src/dotty/tools/dotc/ast/TreeInfo.scala‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎compiler/src/dotty/tools/dotc/ast/Trees.scala‎
Lines changed: 4 additions & 2 deletions b/‎compiler/src/dotty/tools/dotc/ast/Trees.scala‎
Lines changed: 4 additions & 2 deletions
diff --git a/‎compiler/src/dotty/tools/dotc/ast/tpd.scala‎
Lines changed: 12 additions & 3 deletions b/‎compiler/src/dotty/tools/dotc/ast/tpd.scala‎
Lines changed: 12 additions & 3 deletions
diff --git a/‎compiler/src/dotty/tools/dotc/core/Annotations.scala‎
Lines changed: 2 additions & 1 deletion b/‎compiler/src/dotty/tools/dotc/core/Annotations.scala‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎compiler/src/dotty/tools/dotc/core/TypeEval.scala‎
Lines changed: 1 addition & 1 deletion b/‎compiler/src/dotty/tools/dotc/core/TypeEval.scala‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala‎
Lines changed: 13 additions & 14 deletions b/‎compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala‎
Lines changed: 13 additions & 14 deletions
diff --git a/‎compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala‎
Lines changed: 15 additions & 14 deletions b/‎compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala‎
Lines changed: 15 additions & 14 deletions
@@ -397,8 +397,9 @@ class ScalaPrimitives(using @constructorOnly initCtx: Context) {
     primitives.contains(sym)
 
   def isPrimitive(fun: Tree)(using Context): Boolean =
-    primitives.contains(fun.symbol)
-    || (fun.symbol == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}
+    val sym = fun.symbol
+    primitives.contains(sym)
+    || (sym == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}
         && {
           fun match
             case Select(_, nme.clone_) => false // but array.clone is NOT a primitive op.
 
@@ -397,10 +397,11 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives, val bTypes: KnownBTypes)
           generatedType = genApply(app, expectedType)
 
         case This(qual) =>
-          val symIsModuleClass = tree.symbol.is(ModuleClass)
-          assert(tree.symbol == claszSymbol || symIsModuleClass,
-                 s"Trying to access the this of another class: tree.symbol = ${tree.symbol}, class symbol = $claszSymbol compilation unit: ${ctx.compilationUnit}")
-          if (symIsModuleClass && tree.symbol != claszSymbol) {
+          val sym = tree.symbol
+          val symIsModuleClass = sym.is(ModuleClass)
+          assert(sym == claszSymbol || symIsModuleClass,
+                 s"Trying to access the this of another class: tree.symbol = $sym, class symbol = $claszSymbol compilation unit: ${ctx.compilationUnit}")
+          if (symIsModuleClass && sym != claszSymbol) {
             generatedType = genLoadModule(tree)
           }
           else {
@@ -409,7 +410,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives, val bTypes: KnownBTypes)
             // is `[Object` (computed by typeToBType, the type of This(Array) is `Array[T]`). If we would set
             // the generatedType to `Array` below, the call to adapt at the end would fail. The situation is
             // similar for primitives (`I` vs `Int`).
-            if (tree.symbol != defn.ArrayClass && !tree.symbol.isPrimitiveValueClass) {
+            if (sym != defn.ArrayClass && !sym.isPrimitiveValueClass) {
               generatedType = bTypeLoader.classBTypeFromSymbol(claszSymbol)
             }
           }
@@ -1278,13 +1279,13 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives, val bTypes: KnownBTypes)
     end genLoadArguments
 
     def genLoadModule(tree: Tree)(using Context): BType = {
-      val module = (
-        if (!tree.symbol.is(PackageClass)) tree.symbol
-        else tree.symbol.info.member(nme.PACKAGE).symbol match {
+      val sym = tree.symbol
+      val module =
+        if !sym.is(PackageClass) then sym
+        else sym.info.member(nme.PACKAGE).symbol match {
           case NoSymbol => throw new AssertionError(s"SI-5604: Cannot use package as value: $tree")
           case s        => throw new AssertionError(s"SI-5604: found package class where package object expected: $tree")
         }
-      )
       lineNumber(tree)
       genLoadModule(module)
       symInfoTK(module)
 
@@ -646,8 +646,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     }
 
     // on entering a method
-    def resetMethodBookkeeping(dd: DefDef)(using Context) = {
-      val rhs = dd.rhs
+    def resetMethodBookkeeping()(using Context) = {
       locals.reset(isStaticMethod = methSymbol.isStaticMember)
       jumpDest = immutable.Map.empty
 
@@ -813,14 +812,15 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     private def genDefDef(dd: DefDef)(using Context): Unit = {
       val rhs = dd.rhs
       val vparamss = dd.termParamss
-      // the only method whose implementation is not emitted: getClass()
-      if (dd.symbol eq defn.Any_getClass) { return }
       assert(mnode == null, "GenBCode detected nested method.")
 
       methSymbol  = dd.symbol
+      // the only method whose implementation is not emitted: getClass()
+      if (methSymbol eq defn.Any_getClass) { return }
+
       returnType  = bTypeLoader.methodBTypeFromSymbol(methSymbol).returnType
 
-      resetMethodBookkeeping(dd)
+      resetMethodBookkeeping()
 
       // add method-local vars for params
 
@@ -903,7 +903,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
             )
           else
             // The JVM doesn't support `synchronized` methods on interfaces so we must implement that ourselves
-            if dd.symbol.is(Synchronized) && dd.symbol.owner.is(Trait) then
+            if methSymbol.is(Synchronized) && methSymbol.owner.is(Trait) then
               bc.aloadThis()
               val generatedType = genSynchronized(trimmedRhs, trimmedRhs :: Nil, returnType)
               genAdaptAndSendToDest(generatedType, returnType, LoadDestination.Return)
 
@@ -1013,7 +1013,9 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     else
       val locals = new mutable.ListBuffer[Symbol]
       for stat <- stats do
-        if stat.isDef && stat.symbol.exists then locals += stat.symbol
+        if stat.isDef then
+          val sym = stat.symbol
+          if sym.exists then locals += sym
       locals.toList
 
   /** If `tree` is a DefTree, the symbol defined by it, otherwise NoSymbol */
 
@@ -370,8 +370,10 @@ object Trees {
 
     protected def srcName(using Context): Name =
       if name == nme.CONSTRUCTOR then nme.this_
-      else if symbol.isPackageObject then symbol.owner.name
-      else name
+      else
+        val sym = this.symbol
+        if sym.isPackageObject then sym.owner.name
+        else name
 
     /** The position of the name defined by this definition.
      *  This is a point position if the definition is synthetic, or a range position
 
@@ -1200,6 +1200,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       tree
     }
 
+    /** Same as above, but when you already have `tree.symbol` */
+    def setDefTree(sym: Symbol)(using Context): ThisTree = {
+      if (sym.exists) sym.defTree = tree
+      tree
+    }
+
     /** Make sure tree has given symbol. This is called when typing or unpickling
      *  a ValDef or DefDef. It turns out that under very rare circumstances the symbol
      *  computed for a tree is not correct. The only known test case is i21755.scala.
@@ -1209,11 +1215,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      *  corresponding symbol in the superclass. It is not known what are the precise
      *  conditions where this happens, but my guess would be that it's connected to the
      *  recursion in the self type.
+     *  As an optimization, returns the symbol.
      */
-    def ensureHasSym(sym: Symbol)(using Context): Unit =
-      if sym.exists && sym != tree.symbol then
-        typr.println(i"correcting definition symbol from ${tree.symbol.showLocated} to ${sym.showLocated}")
+    def ensureHasSym(sym: Symbol)(using Context): Symbol =
+      val treeSym = tree.symbol
+      if sym.exists && sym != treeSym then
+        typr.println(i"correcting definition symbol from ${treeSym.showLocated} to ${sym.showLocated}")
         tree.overwriteType(NamedType(sym.owner.thisType, sym.name, sym.denot))
+      treeSym
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
 
@@ -16,7 +16,8 @@ import scala.annotation.internal.sharable
 object Annotations {
 
   def annotClass(tree: Tree)(using Context) =
-    if (tree.symbol.isConstructor) tree.symbol.owner
+    val sym = tree.symbol
+    if (sym.isConstructor) sym.owner
     else tree.tpe.typeSymbol
 
   abstract class Annotation extends Showable {
 
@@ -55,7 +55,7 @@ object TypeEval:
         case ConstantType(_) => Some(true)
         // constant if the term is constant
         case t: TermRef =>
-          if t.denot.symbol.flagsUNSAFE.is(Flags.Param) then
+          if t.symbol.flagsUNSAFE.is(Flags.Param) then
             // might be substituted later
             None
           else
 
@@ -80,11 +80,9 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
   def addrOfSym(sym: Symbol): Option[Addr] =
     symRefs.get(sym)
 
-  def preRegister(tree: Tree)(using Context): Unit = tree match {
-    case tree: MemberDef =>
-      if (!symRefs.contains(tree.symbol)) symRefs(tree.symbol) = NoAddr
-    case _ =>
-  }
+  def preRegister(tree: Tree)(using Context): Unit = tree match
+    case tree: MemberDef => symRefs.getOrElseUpdate(tree.symbol, NoAddr)
+    case _ => ()
 
   def registerDef(sym: Symbol): Unit =
     symRefs(sym) = currentAddr
@@ -474,17 +472,18 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
                 pickleType(tp)
               }
             case _ =>
+              val sym = tree.symbol
+              val ename = sym.targetName
               if passesConditionForErroringBestEffortCode(tree.hasType) then
                 // #19951 The signature of a constructor of a Java annotation is irrelevant
                 val sig =
-                  if name == nme.CONSTRUCTOR && tree.symbol.exists && tree.symbol.owner.is(JavaAnnotation) then Signature.NotAMethod
+                  if name == nme.CONSTRUCTOR && sym.exists && sym.owner.is(JavaAnnotation) then Signature.NotAMethod
                   else tree.tpe.signature
-                var ename = tree.symbol.targetName
                 val selectFromQualifier =
                   name.isTypeName
                   || qual.isInstanceOf[Hole] // holes have no symbol
                   || sig == Signature.NotAMethod // no overload resolution necessary
-                  || !tree.denot.symbol.exists // polymorphic function type
+                  || !sym.exists // polymorphic function type
                   || tree.denot.asSingleDenotation.isRefinedMethod // refined methods have no defining class symbol
                 if selectFromQualifier then
                   writeByte(if name.isTypeName then SELECTtpt else SELECT)
@@ -493,22 +492,22 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
                 else // select from owner
                   writeByte(SELECTin)
                   withLength {
-                    pickleNameAndSig(name, tree.symbol.signature, ename)
+                    pickleNameAndSig(name, sym.signature, ename)
                     pickleTree(qual)
-                    pickleType(tree.symbol.owner.typeRef)
+                    pickleType(sym.owner.typeRef)
                   }
               else
                 writeByte(if name.isTypeName then SELECTtpt else SELECT)
-                val ename = tree.symbol.targetName
                 pickleNameAndSig(name, Signature.NotAMethod, ename)
                 pickleTree(qual)
           }
         case Apply(fun, args) =>
-          if (fun.symbol eq defn.throwMethod) {
+          val funSym = fun.symbol
+          if (funSym eq defn.throwMethod) {
             writeByte(THROW)
             pickleTree(args.head)
           }
-          else if fun.symbol.originalSignaturePolymorphic.exists then
+          else if funSym.originalSignaturePolymorphic.exists then
             writeByte(APPLYsigpoly)
             withLength {
               pickleTree(fun)
@@ -520,7 +519,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
             withLength {
               pickleTree(fun)
               // #19951 Do not pickle default arguments to Java annotation constructors
-              if fun.symbol.isClassConstructor && fun.symbol.owner.is(JavaAnnotation) then
+              if funSym.isClassConstructor && funSym.owner.is(JavaAnnotation) then
                 for arg <- args do
                   arg match
                     case NamedArg(_, Ident(nme.WILDCARD)) => ()
 
@@ -927,8 +927,8 @@ class TreeUnpickler(reader: TastyReader,
       def ValDef(tpt: Tree) =
         ta.assignType(untpd.ValDef(sym.name.asTermName, tpt, readRhs(using localCtx)), sym)
 
-      def DefDef(paramss: List[ParamClause], tpt: Tree) =
-        sym.setParamssFromDefs(paramss)
+      def DefDef(paramss: List[ParamClause], paramsSyms: List[List[Symbol]], tpt: Tree) =
+        sym.setParamss(paramsSyms)
         ta.assignType(
           untpd.DefDef(sym.name.asTermName, paramss, tpt, readRhs(using localCtx)),
           sym)
@@ -950,18 +950,18 @@ class TreeUnpickler(reader: TastyReader,
         case DEFDEF =>
           val paramDefss = readParamss()(using localCtx)
           val tpt = readTpt()(using localCtx)
-          val paramss = normalizeIfConstructor(
-              paramDefss.nestedMap(_.symbol), name == nme.CONSTRUCTOR)
+          val paramss = paramDefss.nestedMap(_.symbol)
+          val normalizedParamss = normalizeIfConstructor(paramss, name == nme.CONSTRUCTOR)
           val resType =
             if name == nme.CONSTRUCTOR then
-              effectiveResultType(sym, paramss)
+              effectiveResultType(sym, normalizedParamss)
             else if sym.isAllOf(Given | Method) && Feature.enabled(Feature.modularity) then
-              addParamRefinements(tpt.tpe, paramss)
+              addParamRefinements(tpt.tpe, normalizedParamss)
             else
               tpt.tpe
-          sym.info = methodType(paramss, resType)
+          sym.info = methodType(normalizedParamss, resType)
           nullify(sym)
-          DefDef(paramDefss, tpt)
+          DefDef(paramDefss, paramss, tpt)
         case VALDEF =>
           val tpt = readTpt()(using localCtx)
           sym.info = tpt.tpe.suppressIntoIfParam(sym)
@@ -1036,8 +1036,8 @@ class TreeUnpickler(reader: TastyReader,
         }
       }
 
-      tree.ensureHasSym(sym)
-      tree.setDefTree
+      val sym1 = tree.ensureHasSym(sym)
+      tree.setDefTree(sym1)
     }
 
     /** Read enough of parent to determine its type, without reading arguments
@@ -1530,11 +1530,12 @@ class TreeUnpickler(reader: TastyReader,
               tpd.Super(qual, mixId, mixTpe.typeSymbol)
             case APPLY =>
               val fn = readTree()
+              val sym = fn.symbol
               val args = until(end)(readTree())
-              if fn.symbol.isConstructor then constructorApply(fn, args)
-              else if fn.symbol == defn.QuotedRuntime_exprQuote then quotedExpr(fn, args) // decode pre 3.5.0 encoding
-              else if fn.symbol == defn.QuotedRuntime_exprSplice then splicedExpr(fn, args) // decode pre 3.5.0 encoding
-              else if fn.symbol == defn.QuotedRuntime_exprNestedSplice then nestedSpliceExpr(fn, args) // decode pre 3.5.0 encoding
+              if sym.isConstructor then constructorApply(fn, args)
+              else if sym == defn.QuotedRuntime_exprQuote then quotedExpr(fn, args) // decode pre 3.5.0 encoding
+              else if sym == defn.QuotedRuntime_exprSplice then splicedExpr(fn, args) // decode pre 3.5.0 encoding
+              else if sym == defn.QuotedRuntime_exprNestedSplice then nestedSpliceExpr(fn, args) // decode pre 3.5.0 encoding
               else if isSpuriousApply(fn, args) then fn
               else tpd.Apply(fn, args)
             case TYPEAPPLY =>