SI-7678 Don't cache member symbols of TypeTags in Definitions.

It we can only safely use vals in Definitions for top-level symbols.
Otherwise, when the IDE switches to loading the symbol from source,
we can hold on to a stale symbol, which in turn impedes implicit
materialization of TypeTags.

This commit moves (most) of the accessors for member symbols
into RunDefinitions, and changes calling code accordingly.
This is a win for presentation compiler correctness, and
might even shave of a few cycles.

In a few cases, I have had to leave a `def` to a member symbol
in Definitions so we can get to it from the SymbolTable cake,
which doesn't see RunDefinitions.

The macro FastTrack facility now correctly recreates the mapping
from Symbol to macro implementation each run, using a new facility
in perRunCaches to create a run-indexed cache.

The enclosed test recreates the situation reported in the ticket,
in which TypeTags.scala is loaded from source.

Author: retronym

src/compiler/scala/reflect/macros/compiler/Errors.scala

@@ -12,6 +12,8 @@ trait Errors extends Traces {
   import definitions._
   import typer.TyperErrorGen._
   import typer.infer.InferErrorGen._
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions._
   def globalSettings = global.settings
 
   // sanity check errors

src/compiler/scala/reflect/macros/compiler/Resolvers.scala

@@ -12,6 +12,8 @@ trait Resolvers {
   import definitions.{EmptyPackageClass => _, _}
   import treeInfo._
   import gen._
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions.{Predef_???, _}
 
   /** Determines the type of context implied by the macro def.
    */

src/compiler/scala/reflect/macros/compiler/Validators.scala

@@ -11,6 +11,8 @@ trait Validators {
   import global._
   import analyzer._
   import definitions._
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions.{Predef_???, _}
 
   def validateMacroImplRef() = {
     sanityCheck()

src/compiler/scala/reflect/macros/util/Helpers.scala

@@ -23,6 +23,9 @@ trait Helpers {
    *  or to streamline creation of the list of macro arguments.
    */
   def transformTypeTagEvidenceParams(macroImplRef: Tree, transform: (Symbol, Symbol) => Symbol): List[List[Symbol]] = {
+    val runDefinitions = currentRun.runDefinitions
+    import runDefinitions._
+
     val MacroContextUniverse = definitions.MacroContextUniverse
     val treeInfo.MacroImplReference(isBundle, _, macroImpl, _) = macroImplRef
     val paramss = macroImpl.paramss
@@ -51,15 +54,25 @@ trait Helpers {
    *
    *  @see Metalevels.scala for more information and examples about metalevels
    */
-  def increaseMetalevel(pre: Type, tp: Type): Type = transparentShallowTransform(RepeatedParamClass, tp) {
-    case tp => typeRef(pre, MacroContextExprClass, List(tp))
+  def increaseMetalevel(pre: Type, tp: Type): Type = {
+    val runDefinitions = currentRun.runDefinitions
+    import runDefinitions._
+
+    transparentShallowTransform(RepeatedParamClass, tp) {
+      case tp => typeRef(pre, MacroContextExprClass, List(tp))
+    }
   }
 
   /** Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.
    */
-  def untypeMetalevel(tp: Type): Type = transparentShallowTransform(RepeatedParamClass, tp) {
-    case ExprClassOf(_) => typeRef(tp.prefix, TreesTreeType, Nil)
-    case tp => tp
+  def untypeMetalevel(tp: Type): Type = {
+    val runDefinitions = currentRun.runDefinitions
+    import runDefinitions._
+
+    transparentShallowTransform(RepeatedParamClass, tp) {
+      case ExprClassOf(_) => typeRef(tp.prefix, TreesTreeType, Nil)
+      case tp => tp
+    }
   }
 
   /** Decreases metalevel of the type, i.e. transforms:
@@ -68,8 +81,12 @@ trait Helpers {
    *
    *  @see Metalevels.scala for more information and examples about metalevels
    */
-  def decreaseMetalevel(tp: Type): Type = transparentShallowTransform(RepeatedParamClass, tp) {
-    case ExprClassOf(runtimeType) => runtimeType
-    case _ => AnyTpe // so that macro impls with rhs = ??? don't screw up our inference
+  def decreaseMetalevel(tp: Type): Type = {
+    val runDefinitions = currentRun.runDefinitions
+    import runDefinitions._
+    transparentShallowTransform(RepeatedParamClass, tp) {
+      case ExprClassOf(runtimeType) => runtimeType
+      case _ => AnyTpe // so that macro impls with rhs = ??? don't screw up our inference
+    }
   }
-}
+}

src/compiler/scala/reflect/reify/Reifier.scala

@@ -20,6 +20,8 @@ abstract class Reifier extends States
   val global: Global
   import global._
   import definitions._
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions._
 
   val typer: global.analyzer.Typer
   val universe: Tree
@@ -110,7 +112,7 @@ abstract class Reifier extends States
       // maybe try `resetLocalAttrs` once the dust settles
       var importantSymbols = Set[Symbol](
         NothingClass, AnyClass, SingletonClass, PredefModule, ScalaRunTimeModule, TypeCreatorClass, TreeCreatorClass, MirrorClass,
-        ApiUniverseClass, JavaUniverseClass, ReflectRuntimePackage, ReflectRuntimeCurrentMirror)
+        ApiUniverseClass, JavaUniverseClass, ReflectRuntimePackage, runDefinitions.ReflectRuntimeCurrentMirror)
       importantSymbols ++= importantSymbols map (_.companionSymbol)
       importantSymbols ++= importantSymbols map (_.moduleClass)
       importantSymbols ++= importantSymbols map (_.linkedClassOfClass)

src/compiler/scala/reflect/reify/Taggers.scala

@@ -8,6 +8,8 @@ abstract class Taggers {
 
   import c.universe._
   import definitions._
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions._
 
   val coreTags = Map(
     ByteTpe -> nme.Byte,

src/compiler/scala/reflect/reify/codegen/GenTypes.scala

@@ -6,6 +6,8 @@ trait GenTypes {
 
   import global._
   import definitions._
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions.{ReflectRuntimeUniverse, ReflectRuntimeCurrentMirror, _}
 
   /**
    *  Reify a type.

src/compiler/scala/reflect/reify/package.scala

@@ -63,11 +63,11 @@ package object reify {
     tpe.dealiasWiden match {
       case TypeRef(_, ArrayClass, componentTpe :: Nil) =>
         val componentErasure = reifyRuntimeClass(global)(typer0, componentTpe, concrete)
-        gen.mkMethodCall(arrayClassMethod, List(componentErasure))
+        gen.mkMethodCall(currentRun.runDefinitions.arrayClassMethod, List(componentErasure))
       case _ =>
         var erasure = tpe.erasure
         if (tpe.typeSymbol.isDerivedValueClass && global.phase.id < global.currentRun.erasurePhase.id) erasure = tpe
-        gen.mkNullaryCall(Predef_classOf, List(erasure))
+        gen.mkNullaryCall(currentRun.runDefinitions.Predef_classOf, List(erasure))
     }
   }
 

src/compiler/scala/reflect/reify/phases/Reshape.scala

@@ -9,6 +9,8 @@ trait Reshape {
   import global._
   import definitions._
   import treeInfo.Unapplied
+  private val runDefinitions = currentRun.runDefinitions
+  import runDefinitions._
 
   /**
    *  Rolls back certain changes that were introduced during typechecking of the reifee.

src/compiler/scala/tools/nsc/backend/icode/GenICode.scala

@@ -702,7 +702,7 @@ abstract class GenICode extends SubComponent  {
           }
           genLoadApply3
 
-        case Apply(fun @ _, List(expr)) if (definitions.isBox(fun.symbol)) =>
+        case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isBox(fun.symbol) =>
           def genLoadApply4 = {
             debuglog("BOX : " + fun.symbol.fullName)
             val ctx1 = genLoad(expr, ctx, toTypeKind(expr.tpe))
@@ -721,7 +721,7 @@ abstract class GenICode extends SubComponent  {
           }
           genLoadApply4
 
-        case Apply(fun @ _, List(expr)) if (definitions.isUnbox(fun.symbol)) =>
+        case Apply(fun @ _, List(expr)) if (currentRun.runDefinitions.isUnbox(fun.symbol)) =>
           debuglog("UNBOX : " + fun.symbol.fullName)
           val ctx1 = genLoad(expr, ctx, toTypeKind(expr.tpe))
           val boxType = toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe)