Drop Periods and Phases mixins for contexts

Use `currentPhase`, `currentPeriod`, etc instead.

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(runContext.runId <= Periods.MaxPossibleRunId)
+  assert(currentRunId(using runContext) <= Periods.MaxPossibleRunId)
 
   private var myUnits: List[CompilationUnit] = _
   private var myUnitsCached: List[CompilationUnit] = _
@@ -236,7 +236,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   private def printTree(last: PrintedTree)(using Context): PrintedTree = {
     val unit = ctx.compilationUnit
-    val prevPhase = ctx.phase.prev // can be a mini-phase
+    val prevPhase = currentPhase.prev // can be a mini-phase
     val squashedPhase = ctx.base.squashed(prevPhase)
     val treeString = unit.tpdTree.show(using ctx.withProperty(XprintMode, Some(())))
 

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

@@ -828,7 +828,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      *  owner by `from` to `to`.
      */
     def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(using Context): ThisTree =
-      if (ctx.phase == trans.next) {
+      if (currentPhase == trans.next) {
         val traverser = new TreeTraverser {
           def traverse(tree: Tree)(using Context) = tree match {
             case tree: DefTree =>

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

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

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

@@ -70,10 +70,19 @@ object Contexts {
     atPhase(phase.id)(op)
 
   inline def atNextPhase[T](inline op: Context ?=> T)(using Context): T =
-    atPhase(ctx.phase.next)(op)
+    atPhase(currentPhase.next)(op)
 
   inline def atPhaseNotLaterThan[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
-    op(using if !limit.exists || ctx.phase <= limit then ctx else ctx.withPhase(limit))
+    op(using if !limit.exists || currentPhase <= limit then ctx else ctx.withPhase(limit))
+
+  inline def currentPeriod(using ctx: Context): Period = ctx.period
+
+  inline def currentPhase(using ctx: Context): Phase = ctx.base.phases(ctx.period.firstPhaseId)
+
+  inline def currentRunId(using ctx: Context): Int = ctx.period.runId
+
+  inline def currentPhaseId(using ctx: Context): Int = ctx.period.phaseId
+
 
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
@@ -95,9 +104,7 @@ object Contexts {
    *      classes (which should be short-lived).
    */
   abstract class Context(val base: ContextBase)
-    extends Periods
-       with Phases
-       with Printers
+    extends Printers
        with Reporting { thiscontext =>
 
     given Context = this
@@ -295,8 +302,8 @@ object Contexts {
      *  This method will always return a phase period equal to phaseId, thus will never return squashed phases
      */
     final def withPhase(phaseId: PhaseId): Context =
-      if (this.phaseId == phaseId) this
-      else if (phasedCtx.phaseId == phaseId) phasedCtx
+      if (this.period.phaseId == phaseId) this
+      else if (phasedCtx.period.phaseId == phaseId) phasedCtx
       else if (phasedCtxs != null && phasedCtxs(phaseId) != null) phasedCtxs(phaseId)
       else {
         val ctx1 = fresh.setPhase(phaseId)
@@ -312,10 +319,10 @@ object Contexts {
       withPhase(phase.id)
 
     final def withPhaseNoLater(phase: Phase): Context =
-      if (phase.exists && this.phase.id > phase.id) withPhase(phase) else this
+      if (phase.exists && period.phaseId > phase.id) withPhase(phase) else this
 
     final def withPhaseNoEarlier(phase: Phase): Context =
-      if (phase.exists && this.phase.id < phase.id) withPhase(phase) else this
+      if (phase.exists && period.phaseId < phase.id) withPhase(phase) else this
 
     // `creationTrace`-related code. To enable, uncomment the code below and the
     // call to `setCreationTrace()` in this file.
@@ -439,7 +446,7 @@ object Contexts {
     }
 
     /** Does current phase use an erased types interpretation? */
-    def erasedTypes: Boolean = phase.erasedTypes
+    def erasedTypes: Boolean = currentPhase(using this).erasedTypes
 
     /** Is the debug option set? */
     def debug: Boolean = base.settings.Ydebug.value
@@ -602,8 +609,8 @@ object Contexts {
     def updateStore[T](loc: Store.Location[T], value: T): this.type =
       setStore(store.updated(loc, value))
 
-    def setPhase(pid: PhaseId): this.type = setPeriod(Period(runId, pid))
-    def setPhase(phase: Phase): this.type = setPeriod(Period(runId, phase.start, phase.end))
+    def setPhase(pid: PhaseId): this.type = setPeriod(Period(period.runId, pid))
+    def setPhase(phase: Phase): this.type = setPeriod(Period(period.runId, phase.start, phase.end))
 
     def setSetting[T](setting: Setting[T], value: T): this.type =
       setSettings(setting.updateIn(settingsState, value))

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

@@ -867,7 +867,7 @@ class Definitions {
 
   def ClassType(arg: Type)(using Context): Type = {
     val ctype = ClassClass.typeRef
-    if (ctx.phase.erasedTypes) ctype else ctype.appliedTo(arg)
+    if (currentPhase.erasedTypes) ctype else ctype.appliedTo(arg)
   }
 
   /** The enumeration type, goven a value of the enumeration */
@@ -1041,13 +1041,13 @@ class Definitions {
       name.drop(prefix.length).forall(_.isDigit))
 
   def isBottomClass(cls: Symbol): Boolean =
-    if (ctx.explicitNulls && !ctx.phase.erasedTypes) cls == NothingClass
+    if (ctx.explicitNulls && !currentPhase.erasedTypes) cls == NothingClass
     else isBottomClassAfterErasure(cls)
 
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass
 
   def isBottomType(tp: Type): Boolean =
-    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
+    if (ctx.explicitNulls && !currentPhase.erasedTypes) tp.derivesFrom(NothingClass)
     else isBottomTypeAfterErasure(tp)
 
   def isBottomTypeAfterErasure(tp: Type): Boolean =
@@ -1357,9 +1357,9 @@ class Definitions {
     private var current: RunId = NoRunId
     private var cached: T = _
     def apply()(using Context): T = {
-      if (current != ctx.runId) {
+      if (current != currentRunId) {
         cached = generate(ctx)
-        current = ctx.runId
+        current = currentRunId
       }
       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(ctx.runId, id + 1, lastPhaseId)
+      Period(currentRunId, id + 1, lastPhaseId)
 
     /** The transformation method */
     def transform(ref: SingleDenotation)(using Context): SingleDenotation
@@ -43,7 +43,7 @@ object DenotTransformers {
         if (info1 eq ref.info) ref
         else ref match {
           case ref: SymDenotation =>
-            ref.copySymDenotation(info = info1).copyCaches(ref, ctx.phase.next)
+            ref.copySymDenotation(info = info1).copyCaches(ref, currentPhase.next)
           case _ =>
             ref.derivedSingleDenotation(ref.symbol, info1)
         }

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

@@ -131,10 +131,10 @@ object Denotations {
     /** The denotation with info(s) as seen from prefix type */
     final def asSeenFrom(pre: Type)(using Context): AsSeenFromResult =
       if (Config.cacheAsSeenFrom) {
-        if ((cachedPrefix ne pre) || ctx.period != validAsSeenFrom) {
+        if ((cachedPrefix ne pre) || currentPeriod != validAsSeenFrom) {
           cachedAsSeenFrom = computeAsSeenFrom(pre)
           cachedPrefix = pre
-          validAsSeenFrom = if (pre.isProvisional) Nowhere else ctx.period
+          validAsSeenFrom = if (pre.isProvisional) Nowhere else currentPeriod
         }
         cachedAsSeenFrom
       }
@@ -686,14 +686,14 @@ object Denotations {
 
     private def updateValidity()(using Context): this.type = {
       assert(
-        ctx.runId >= validFor.runId
+        currentRunId >= 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 ${ctx.runId}. ValidFor: $validFor")
+        s"denotation $this invalid in run ${currentRunId}. ValidFor: $validFor")
       var d: SingleDenotation = this
       while ({
-        d.validFor = Period(ctx.period.runId, d.validFor.firstPhaseId, d.validFor.lastPhaseId)
+        d.validFor = Period(currentPeriod.runId, d.validFor.firstPhaseId, d.validFor.lastPhaseId)
         d.invalidateInheritedInfo()
         d = d.nextInRun
         d ne this
@@ -720,7 +720,7 @@ object Denotations {
         case _ =>
       }
       if (!symbol.exists) return updateValidity()
-      if (!coveredInterval.containsPhaseId(ctx.phaseId)) return NoDenotation
+      if (!coveredInterval.containsPhaseId(currentPhaseId)) return NoDenotation
       if (ctx.debug) traceInvalid(this)
       staleSymbolError
     }
@@ -746,7 +746,7 @@ object Denotations {
       if (myValidFor.code <= 0) nextDefined else this
 
     /** Produce a denotation that is valid for the given context.
-     *  Usually called when !(validFor contains ctx.period)
+     *  Usually called when !(validFor contains currentPeriod)
      *  (even though this is not a precondition).
      *  If the runId of the context is the same as runId of this denotation,
      *  the right flock member is located, or, if it does not exist yet,
@@ -758,7 +758,7 @@ object Denotations {
      *  the symbol is stale, which constitutes an internal error.
      */
     def current(using Context): SingleDenotation = {
-      val currentPeriod = ctx.period
+      val currentPeriod = Contexts.currentPeriod
       val valid = myValidFor
       if (valid.code <= 0) {
         // can happen if we sit on a stale denotation which has been replaced
@@ -808,7 +808,7 @@ object Denotations {
               else {
                 next match {
                   case next: ClassDenotation =>
-                    assert(!next.is(Package), s"illegal transformation of package denotation by transformer ${ctx.withPhase(transformer).phase}")
+                    assert(!next.is(Package), s"illegal transformation of package denotation by transformer $transformer")
                   case _ =>
                 }
                 next.insertAfter(cur)
@@ -842,7 +842,7 @@ object Denotations {
     }
 
     private def demandOutsideDefinedMsg(using Context): String =
-      s"demanding denotation of $this at phase ${ctx.phase}(${ctx.phaseId}) outside defined interval: defined periods are${definedPeriodsString}"
+      s"demanding denotation of $this at phase ${currentPhase}(${currentPhaseId}) 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 (ctx.phaseId != targetId) atPhase(phase.next)(installAfter(phase))
+      if (currentPhaseId != 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(ctx.runId, targetId, current.validFor.lastPhaseId)
+        this.validFor = Period(currentRunId, targetId, current.validFor.lastPhaseId)
         if (current.validFor.firstPhaseId >= targetId)
           current.replaceWith(this)
         else {
-          current.validFor = Period(ctx.runId, current.validFor.firstPhaseId, targetId - 1)
+          current.validFor = Period(currentRunId, current.validFor.firstPhaseId, targetId - 1)
           insertAfter(current)
         }
       }
@@ -919,7 +919,7 @@ object Denotations {
         case denot: SymDenotation => s"in ${denot.owner}"
         case _ => ""
       }
-      s"stale symbol; $this#${symbol.id} $ownerMsg, defined in ${myValidFor}, is referred to in run ${ctx.period}"
+      s"stale symbol; $this#${symbol.id} $ownerMsg, defined in ${myValidFor}, is referred to in run ${currentPeriod}"
     }
 
     /** The period (interval of phases) for which there exists
@@ -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(ctx.runId)
+    validFor = Period.allInRun(currentRunId)
     protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
       this
   }

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

@@ -3,44 +3,27 @@ package dotty.tools.dotc.core
 import Contexts._
 import Phases.curPhases
 
-/** Periods are the central "clock" of the compiler
- *  A period consists of a run id and a phase id.
- *  run ids represent compiler runs
- *  phase ids represent compiler phases
- */
-abstract class Periods { thisCtx: Context =>
-  import Periods._
-
-  /** The current phase identifier */
-  def phaseId: Int = period.phaseId
-
-  /** The current run identifier */
-  def runId: Int = period.runId
+object Periods {
 
   /** The period containing the current period where denotations do not change.
    *  We compute this by taking as first phase the first phase less or equal to
    *  the current phase that has the same "nextTransformerId". As last phase
    *  we take the next transformer id following the current phase.
    */
-  def stablePeriod: Period = {
-    var first = phaseId
-    val nxTrans = thisCtx.base.nextDenotTransformerId(first)
-    while (first - 1 > NoPhaseId && (thisCtx.base.nextDenotTransformerId(first - 1) == nxTrans))
+  def currentStablePeriod(using Context): Period =
+    var first = currentPhaseId
+    val nxTrans = ctx.base.nextDenotTransformerId(first)
+    while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans))
       first -= 1
-    Period(runId, first, nxTrans)
-  }
+    Period(currentRunId, first, nxTrans)
 
   /** Are all base types in the current period guaranteed to be the same as in period `p`? */
-  def hasSameBaseTypesAs(p: Period): Boolean = {
-    val period = thisCtx.period
+  def currentHasSameBaseTypesAs(p: Period)(using Context): Boolean =
+    val period = currentPeriod
     period == p ||
     period.runId == p.runId &&
       curPhases(period.phaseId).sameBaseTypesStartId ==
       curPhases(p.phaseId).sameBaseTypesStartId
-  }
-}
-
-object Periods {
 
   /** A period is a contiguous sequence of phase ids in some run.
    *  It is coded as follows:

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

@@ -20,21 +20,15 @@ trait Phases {
   self: Context =>
 
   import Phases._
-
-  def phase: Phase = base.phases(period.firstPhaseId)
-
-  def phasesStack: List[Phase] =
-    if ((this eq NoContext) || !phase.exists) Nil
-    else {
-      val rest = outersIterator.dropWhile(_.phase == phase)
-      phase :: (if (rest.hasNext) rest.next().phasesStack else Nil)
-    }
-
-  def isAfterTyper: Boolean = base.isAfterTyper(phase)
 }
 
 object Phases {
 
+  inline def phaseOf(id: PhaseId)(using Context): Phase =
+    ctx.base.phases(id)
+
+  def currentlyAfterTyper(using Context): Boolean = ctx.base.isAfterTyper(currentPhase)
+
   trait PhasesBase {
     this: ContextBase =>
 
@@ -322,7 +316,7 @@ object Phases {
     /** Is this phase the standard typerphase? True for FrontEnd, but
      *  not for other first phases (such as FromTasty). The predicate
      *  is tested in some places that perform checks and corrections. It's
-     *  different from isAfterTyper (and cheaper to test).
+     *  different from currentlyAfterTyper (and cheaper to test).
      */
     def isTyper: Boolean = false
 

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

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