Move runId, phaseId back to Context

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -85,7 +85,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   /** The context created for this run */
   given runContext[Dummy_so_its_a_def] as Context = myCtx
-  assert(currentRunId(using runContext) <= Periods.MaxPossibleRunId)
+  assert(runContext.runId <= Periods.MaxPossibleRunId)
 
   private var myUnits: List[CompilationUnit] = _
   private var myUnitsCached: List[CompilationUnit] = _

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

@@ -59,7 +59,7 @@ object Annotations {
         case symFn: (Context ?=> Symbol) @unchecked =>
           mySym = null
           mySym = atPhaseNoLater(picklerPhase)(symFn)
-        case sym: Symbol if sym.defRunId != currentRunId(using parentCtx) =>
+        case sym: Symbol if sym.defRunId != parentCtx.runId =>
           mySym = sym.denot.current.symbol
         case _ =>
       }

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

@@ -369,6 +369,9 @@ object Contexts {
     /** The current reporter */
     def reporter: Reporter = typerState.reporter
 
+    final def runId = period.runId
+    final def phaseId = period.phaseId
+
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =
       owner.isClass && (owner ne outer.owner)

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

@@ -1356,9 +1356,9 @@ class Definitions {
     private var current: RunId = NoRunId
     private var cached: T = _
     def apply()(using Context): T = {
-      if (current != currentRunId) {
+      if (current != ctx.runId) {
         cached = generate
-        current = currentRunId
+        current = ctx.runId
       }
       cached
     }

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

@@ -24,7 +24,7 @@ object DenotTransformers {
 
     /** The validity period of the transformed denotations in the given context */
     def validFor(using Context): Period =
-      Period(currentRunId, id + 1, lastPhaseId)
+      Period(ctx.runId, id + 1, lastPhaseId)
 
     /** The transformation method */
     def transform(ref: SingleDenotation)(using Context): SingleDenotation

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

@@ -686,11 +686,11 @@ object Denotations {
 
     private def updateValidity()(using Context): this.type = {
       assert(
-        currentRunId >= validFor.runId
+        ctx.runId >= validFor.runId
         || ctx.settings.YtestPickler.value // mixing test pickler with debug printing can travel back in time
         || ctx.mode.is(Mode.Printing)  // no use to be picky when printing error messages
         || symbol.isOneOf(ValidForeverFlags),
-        s"denotation $this invalid in run ${currentRunId}. ValidFor: $validFor")
+        s"denotation $this invalid in run ${ctx.runId}. ValidFor: $validFor")
       var d: SingleDenotation = this
       while ({
         d.validFor = Period(currentPeriod.runId, d.validFor.firstPhaseId, d.validFor.lastPhaseId)
@@ -720,7 +720,7 @@ object Denotations {
         case _ =>
       }
       if (!symbol.exists) return updateValidity()
-      if (!coveredInterval.containsPhaseId(currentPhaseId)) return NoDenotation
+      if (!coveredInterval.containsPhaseId(ctx.phaseId)) return NoDenotation
       if (ctx.debug) traceInvalid(this)
       staleSymbolError
     }
@@ -842,7 +842,7 @@ object Denotations {
     }
 
     private def demandOutsideDefinedMsg(using Context): String =
-      s"demanding denotation of $this at phase ${currentPhase}(${currentPhaseId}) outside defined interval: defined periods are${definedPeriodsString}"
+      s"demanding denotation of $this at phase ${currentPhase}(${ctx.phaseId}) outside defined interval: defined periods are${definedPeriodsString}"
 
     /** Install this denotation to be the result of the given denotation transformer.
      *  This is the implementation of the same-named method in SymDenotations.
@@ -851,16 +851,16 @@ object Denotations {
      */
     protected def installAfter(phase: DenotTransformer)(using Context): Unit = {
       val targetId = phase.next.id
-      if (currentPhaseId != targetId) atPhase(phase.next)(installAfter(phase))
+      if (ctx.phaseId != targetId) atPhase(phase.next)(installAfter(phase))
       else {
         val current = symbol.current
         // println(s"installing $this after $phase/${phase.id}, valid = ${current.validFor}")
         // printPeriods(current)
-        this.validFor = Period(currentRunId, targetId, current.validFor.lastPhaseId)
+        this.validFor = Period(ctx.runId, targetId, current.validFor.lastPhaseId)
         if (current.validFor.firstPhaseId >= targetId)
           current.replaceWith(this)
         else {
-          current.validFor = Period(currentRunId, current.validFor.firstPhaseId, targetId - 1)
+          current.validFor = Period(ctx.runId, current.validFor.firstPhaseId, targetId - 1)
           insertAfter(current)
         }
       }
@@ -1071,7 +1071,7 @@ object Denotations {
   class ErrorDenotation(using Context) extends NonSymSingleDenotation(NoSymbol, NoType, NoType) {
     override def exists: Boolean = false
     override def hasUniqueSym: Boolean = false
-    validFor = Period.allInRun(currentRunId)
+    validFor = Period.allInRun(ctx.runId)
     protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
       this
   }

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

@@ -11,11 +11,11 @@ object Periods {
    *  we take the next transformer id following the current phase.
    */
   def currentStablePeriod(using Context): Period =
-    var first = currentPhaseId
+    var first = ctx.phaseId
     val nxTrans = ctx.base.nextDenotTransformerId(first)
     while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans))
       first -= 1
-    Period(currentRunId, first, nxTrans)
+    Period(ctx.runId, first, nxTrans)
 
   /** Are all base types in the current period guaranteed to be the same as in period `p`? */
   def currentHasSameBaseTypesAs(p: Period)(using Context): Boolean =

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

@@ -265,7 +265,7 @@ object Scopes {
 
     /** enter a symbol in this scope. */
     final def enter[T <: Symbol](sym: T)(using Context): T = {
-      if (sym.isType && currentPhaseId <= typerPhase.id)
+      if (sym.isType && ctx.phaseId <= typerPhase.id)
         assert(lookup(sym.name) == NoSymbol,
           s"duplicate ${sym.debugString}; previous was ${lookup(sym.name).debugString}") // !!! DEBUG
       newScopeEntry(sym)

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

@@ -2104,7 +2104,7 @@ object SymDenotations {
      *  `phase.next`, install a new denotation with a cloned scope in `phase.next`.
      */
     def ensureFreshScopeAfter(phase: DenotTransformer)(using Context): Unit =
-      if (currentPhaseId != phase.next.id) atPhase(phase.next)(ensureFreshScopeAfter(phase))
+      if (ctx.phaseId != phase.next.id) atPhase(phase.next)(ensureFreshScopeAfter(phase))
       else {
         val prevClassInfo = atPhase(phase) {
           current.asInstanceOf[ClassDenotation].classInfo
@@ -2154,8 +2154,8 @@ object SymDenotations {
 
     /** The package objects in this class */
     def packageObjs(using Context): List[ClassDenotation] = {
-      if (packageObjsRunId != currentRunId) {
-        packageObjsRunId = currentRunId
+      if (packageObjsRunId != ctx.runId) {
+        packageObjsRunId = ctx.runId
         packageObjsCache = Nil // break cycle in case we are looking for package object itself
         packageObjsCache = {
           val pkgObjBuf = new mutable.ListBuffer[ClassDenotation]
@@ -2296,7 +2296,7 @@ object SymDenotations {
       for (sym <- scope.toList.iterator)
         // We need to be careful to not force the denotation of `sym` here,
         // otherwise it will be brought forward to the current run.
-        if (sym.defRunId != currentRunId && sym.isClass && sym.asClass.assocFile == file)
+        if (sym.defRunId != ctx.runId && sym.isClass && sym.asClass.assocFile == file)
           scope.unlink(sym, sym.lastKnownDenotation.name)
     }
   }
@@ -2348,7 +2348,7 @@ object SymDenotations {
     else {
       val initial = denot.initial
       val firstPhaseId = initial.validFor.firstPhaseId.max(typerPhase.id)
-      if ((initial ne denot) || currentPhaseId != firstPhaseId)
+      if ((initial ne denot) || ctx.phaseId != firstPhaseId)
         atPhase(firstPhaseId)(stillValidInOwner(initial))
       else
         stillValidInOwner(denot)
@@ -2381,7 +2381,7 @@ object SymDenotations {
         if (denot.isOneOf(ValidForeverFlags) || denot.isRefinementClass) true
         else
           val initial = denot.initial
-          if ((initial ne denot) || currentPhaseId != initial.validFor.firstPhaseId)
+          if ((initial ne denot) || ctx.phaseId != initial.validFor.firstPhaseId)
             atPhase(initial.validFor.firstPhaseId)(traceInvalid(initial))
           else try {
             val owner = denot.owner.denot
@@ -2576,7 +2576,7 @@ object SymDenotations {
 
     def isValidAt(phase: Phase)(using Context) =
       checkedPeriod == currentPeriod ||
-        createdAt.runId == currentRunId &&
+        createdAt.runId == ctx.runId &&
         createdAt.phaseId < unfusedPhases.length &&
         sameGroup(unfusedPhases(createdAt.phaseId), phase) &&
         { checkedPeriod = currentPeriod; true }

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

@@ -134,24 +134,24 @@ object Symbols {
 
     /** Does this symbol come from a currently compiled source file? */
     final def isDefinedInCurrentRun(using Context): Boolean =
-      span.exists && defRunId == currentRunId && {
+      span.exists && defRunId == ctx.runId && {
         val file = associatedFile
         file != null && ctx.run.files.contains(file)
       }
 
     /** Is symbol valid in current run? */
     final def isValidInCurrentRun(using Context): Boolean =
-      (lastDenot.validFor.runId == currentRunId || stillValid(lastDenot)) &&
+      (lastDenot.validFor.runId == ctx.runId || stillValid(lastDenot)) &&
       (lastDenot.symbol eq this)
         // the last condition is needed because under ctx.staleOK overwritten
         // members keep denotations pointing to the new symbol, so the validity
         // periods check out OK. But once a package member is overridden it is not longer
         // valid. If the option would be removed, the check would be no longer needed.
 
     final def isTerm(using Context): Boolean =
-      (if (defRunId == currentRunId) lastDenot else denot).isTerm
+      (if (defRunId == ctx.runId) lastDenot else denot).isTerm
     final def isType(using Context): Boolean =
-      (if (defRunId == currentRunId) lastDenot else denot).isType
+      (if (defRunId == ctx.runId) lastDenot else denot).isType
     final def asTerm(using Context): TermSymbol = {
       assert(isTerm, s"asTerm called on not-a-Term $this" );
       asInstanceOf[TermSymbol]
@@ -204,7 +204,7 @@ object Symbols {
      *  @pre  Symbol is a class member
      */
     def enteredAfter(phase: DenotTransformer)(using Context): this.type =
-      if currentPhaseId != phase.next.id then
+      if ctx.phaseId != phase.next.id then
         atPhase(phase.next)(enteredAfter(phase))
       else this.owner match {
         case owner: ClassSymbol =>
@@ -229,7 +229,7 @@ object Symbols {
      *  @pre  Symbol is a class member
      */
     def dropAfter(phase: DenotTransformer)(using Context): Unit =
-      if currentPhaseId != phase.next.id then
+      if ctx.phaseId != phase.next.id then
         atPhase(phase.next)(dropAfter(phase))
       else {
         assert (!this.owner.is(Package))

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

@@ -677,7 +677,7 @@ object Types {
         }
         else
           val joint = pdenot.meet(
-            new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(currentRunId), pre),
+            new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId), pre),
             pre,
             safeIntersection = ctx.base.pendingMemberSearches.contains(name))
           joint match
@@ -1914,7 +1914,7 @@ object Types {
      *  some symbols change their signature at erasure.
      */
     private def currentSignature(using Context): Signature =
-      if currentRunId == mySignatureRunId then mySignature
+      if ctx.runId == mySignatureRunId then mySignature
       else
         val lastd = lastDenotation
         if lastd != null then sigFromDenot(lastd)
@@ -1948,7 +1948,7 @@ object Types {
      *  current run.
      */
     def denotationIsCurrent(using Context): Boolean =
-      lastDenotation != null && lastDenotation.validFor.runId == currentRunId
+      lastDenotation != null && lastDenotation.validFor.runId == ctx.runId
 
     /** If the reference is symbolic or the denotation is current, its symbol, otherwise NoDenotation.
      *
@@ -1969,7 +1969,7 @@ object Types {
      *  Used to get the class underlying a ThisType.
      */
     private[Types] def stableInRunSymbol(using Context): Symbol =
-      if (checkedPeriod.runId == currentRunId) lastSymbol
+      if (checkedPeriod.runId == ctx.runId) lastSymbol
       else symbol
 
     def info(using Context): Type = denot.info
@@ -2008,7 +2008,7 @@ object Types {
           finish(memberDenot(name, allowPrivate))
         case sym: Symbol =>
           val symd = sym.lastKnownDenotation
-          if (symd.validFor.runId != currentRunId && !stillValid(symd))
+          if (symd.validFor.runId != ctx.runId && !stillValid(symd))
             finish(memberDenot(symd.initial.name, allowPrivate = false))
           else if (prefix.isArgPrefixOf(symd))
             finish(argDenot(sym.asType))
@@ -2021,7 +2021,7 @@ object Types {
       lastDenotation match {
         case lastd0: SingleDenotation =>
           val lastd = lastd0.skipRemoved
-          if (lastd.validFor.runId == currentRunId && (checkedPeriod != Nowhere)) finish(lastd.current)
+          if (lastd.validFor.runId == ctx.runId && (checkedPeriod != Nowhere)) finish(lastd.current)
           else lastd match {
             case lastd: SymDenotation =>
               if (stillValid(lastd) && (checkedPeriod != Nowhere)) finish(lastd.current)
@@ -2053,9 +2053,9 @@ object Types {
       if (!d.exists && !allowPrivate && ctx.mode.is(Mode.Interactive))
         // In the IDE we might change a public symbol to private, and would still expect to find it.
         d = memberDenot(prefix, name, true)
-      if (!d.exists && currentPhaseId > FirstPhaseId && lastDenotation.isInstanceOf[SymDenotation])
+      if (!d.exists && ctx.phaseId > FirstPhaseId && lastDenotation.isInstanceOf[SymDenotation])
         // name has changed; try load in earlier phase and make current
-        d = atPhase(currentPhaseId - 1)(memberDenot(name, allowPrivate)).current
+        d = atPhase(ctx.phaseId - 1)(memberDenot(name, allowPrivate)).current
       if (d.isOverloaded)
         d = disambiguate(d)
       d
@@ -2155,7 +2155,7 @@ object Types {
         s"""data race? overwriting $lastSymbol with $sym in type $this,
            |last sym id = ${lastSymbol.id}, new sym id = ${sym.id},
            |last owner = ${lastSymbol.owner}, new owner = ${sym.owner},
-           |period = ${currentPhase} at run ${currentRunId}""")
+           |period = ${currentPhase} at run ${ctx.runId}""")
     }
 
     /** A reference with the initial symbol in `symd` has an info that
@@ -2980,12 +2980,12 @@ object Types {
     private var myWidened: Type = _
 
     private def ensureAtomsComputed()(using Context): Unit =
-      if atomsRunId != currentRunId then
+      if atomsRunId != ctx.runId then
         myAtoms = tp1.atoms | tp2.atoms
         val tp1w = tp1.widenSingletons
         val tp2w = tp2.widenSingletons
         myWidened = if ((tp1 eq tp1w) && (tp2 eq tp2w)) this else tp1w | tp2w
-        atomsRunId = currentRunId
+        atomsRunId = ctx.runId
 
     override def atoms(using Context): Atoms =
       ensureAtomsComputed()
@@ -3070,9 +3070,9 @@ object Types {
     protected[dotc] def computeSignature(using Context): Signature
 
     final override def signature(using Context): Signature = {
-      if (currentRunId != mySignatureRunId) {
+      if (ctx.runId != mySignatureRunId) {
         mySignature = computeSignature
-        if (!mySignature.isUnderDefined) mySignatureRunId = currentRunId
+        if (!mySignature.isUnderDefined) mySignatureRunId = ctx.runId
       }
       mySignature
     }
@@ -4994,11 +4994,11 @@ object Types {
         case tp: LazyRef =>
           LazyRef {
             val ref1 = tp.ref
-            if currentRunId == currentRunId(using mapCtx) then this(ref1)
+            if ctx.runId == mapCtx.runId then this(ref1)
             else // splice in new run into map context
               val saved = mapCtx
               mapCtx = mapCtx.fresh
-                .setPeriod(Period(currentRunId, currentPhaseId(using mapCtx)))
+                .setPeriod(Period(ctx.runId, mapCtx.phaseId))
                 .setRun(ctx.run)
               try this(ref1) finally mapCtx = saved
           }

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -47,7 +47,7 @@ class Pickler extends Phase {
 
   override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
-    pickling.println(i"unpickling in run ${currentRunId}")
+    pickling.println(i"unpickling in run ${ctx.runId}")
 
     for {
       cls <- dropCompanionModuleClasses(topLevelClasses(unit.tpdTree))
@@ -92,7 +92,7 @@ class Pickler extends Phase {
     if (ctx.settings.YtestPickler.value)
       testUnpickler(
         using ctx.fresh
-            .setPeriod(Period(currentRunId + 1, FirstPhaseId))
+            .setPeriod(Period(ctx.runId + 1, FirstPhaseId))
             .setReporter(new ThrowingReporter(ctx.reporter))
             .addMode(Mode.ReadPositions)
             .addMode(Mode.ReadComments)
@@ -101,7 +101,7 @@ class Pickler extends Phase {
   }
 
   private def testUnpickler(using Context): Unit = {
-    pickling.println(i"testing unpickler at run ${currentRunId}")
+    pickling.println(i"testing unpickler at run ${ctx.runId}")
     ctx.initialize()
     val unpicklers =
       for ((cls, pickler) <- picklers) yield {

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -89,7 +89,7 @@ class TreeChecker extends Phase with SymTransformer {
 
     // Signatures are used to disambiguate overloads and need to stay stable
     // until erasure, see the comment above `Compiler#phases`.
-    if (currentPhaseId <= erasurePhase.id) {
+    if (ctx.phaseId <= erasurePhase.id) {
       val cur = symd.info
       val initial = symd.initial.info
       val curSig = cur match {

compiler/src/dotty/tools/dotc/transform/ValueClasses.scala

@@ -25,7 +25,7 @@ object ValueClasses {
   def isMethodWithExtension(sym: Symbol)(using Context): Boolean =
     atPhaseNoLater(extensionMethodsPhase) {
       val d = sym.denot
-      d.validFor.containsPhaseId(currentPhaseId) &&
+      d.validFor.containsPhaseId(ctx.phaseId) &&
       d.isRealMethod &&
       isDerivedValueClass(d.owner) &&
       !d.isConstructor &&