Move current... methods to Phases and Periods

Author: odersky

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

@@ -10,7 +10,7 @@ import Scopes._
 import typer.{ImportInfo, Typer}
 import Decorators._
 import io.{AbstractFile, PlainFile}
-import Phases.curPhases
+import Phases.{curPhases, currentPhase}
 
 import scala.io.Codec
 import util.{Set => _, _}

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

@@ -13,6 +13,7 @@ import Decorators.{given _}, DenotTransformers._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
+import Phases.currentPhase
 import typer.ConstFold
 
 import scala.annotation.tailrec

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

@@ -7,6 +7,7 @@ import StdNames._
 import dotty.tools.dotc.ast.tpd
 import scala.util.Try
 import util.Spans.Span
+import Periods.currentRunId
 
 object Annotations {
 

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

@@ -75,15 +75,6 @@ object Contexts {
   inline def atPhaseNotLaterThan[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
     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
    *  objects that turn into space leaks. To combat this risk, here are some

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

@@ -15,6 +15,7 @@ import Flags._
 import DenotTransformers._
 import Decorators._
 import Signature.MatchDegree._
+import Phases.currentPhase
 import printing.Texts._
 import printing.Printer
 import io.AbstractFile
@@ -758,7 +759,7 @@ object Denotations {
      *  the symbol is stale, which constitutes an internal error.
      */
     def current(using Context): SingleDenotation = {
-      val currentPeriod = Contexts.currentPeriod
+      val now = Periods.currentPeriod
       val valid = myValidFor
       if (valid.code <= 0) {
         // can happen if we sit on a stale denotation which has been replaced
@@ -769,29 +770,29 @@ object Denotations {
         assert(false, this)
       }
 
-      if (valid.runId != currentPeriod.runId)
+      if (valid.runId != now.runId)
         if (exists) initial.bringForward().current
         else this
       else {
         var cur = this
-        if (currentPeriod.code > valid.code) {
+        if (now.code > valid.code) {
           // search for containing period as long as nextInRun increases.
           var next = nextInRun
-          while (next.validFor.code > valid.code && !(next.validFor contains currentPeriod)) {
+          while (next.validFor.code > valid.code && !(next.validFor contains now)) {
             cur = next
             next = next.nextInRun
           }
           if (next.validFor.code > valid.code) {
-            // in this case, next.validFor contains currentPeriod
+            // in this case, next.validFor contains now
             cur = next
             cur
           }
           else {
-            //println(s"might need new denot for $cur, valid for ${cur.validFor} at $currentPeriod")
+            //println(s"might need new denot for $cur, valid for ${cur.validFor} at $now")
             // not found, cur points to highest existing variant
             val nextTransformerId = ctx.base.nextDenotTransformerId(cur.validFor.lastPhaseId)
-            if (currentPeriod.lastPhaseId <= nextTransformerId)
-              cur.validFor = Period(currentPeriod.runId, cur.validFor.firstPhaseId, nextTransformerId)
+            if (now.lastPhaseId <= nextTransformerId)
+              cur.validFor = Period(now.runId, cur.validFor.firstPhaseId, nextTransformerId)
             else {
               var startPid = nextTransformerId + 1
               val transformer = ctx.base.denotTransformers(nextTransformerId)
@@ -814,19 +815,19 @@ object Denotations {
                 next.insertAfter(cur)
                 cur = next
               }
-              cur.validFor = Period(currentPeriod.runId, startPid, transformer.lastPhaseId)
+              cur.validFor = Period(now.runId, startPid, transformer.lastPhaseId)
               //printPeriods(cur)
               //println(s"new denot: $cur, valid for ${cur.validFor}")
             }
             cur.current // multiple transformations could be required
           }
         }
         else {
-          // currentPeriod < end of valid; in this case a version must exist
+          // now < end of valid; in this case a version must exist
           // but to be defensive we check for infinite loop anyway
           var cnt = 0
-          while (!(cur.validFor contains currentPeriod)) {
-            //println(s"searching: $cur at $currentPeriod, valid for ${cur.validFor}")
+          while (!(cur.validFor contains now)) {
+            //println(s"searching: $cur at $now, valid for ${cur.validFor}")
             cur = cur.nextInRun
             // Note: One might be tempted to add a `prev` field to get to the new denotation
             // more directly here. I tried that, but it degrades rather than improves

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

@@ -5,6 +5,12 @@ import Phases.curPhases
 
 object Periods {
 
+  inline def currentPeriod(using ctx: Context): Period = ctx.period
+
+  inline def currentRunId(using ctx: Context): RunId = ctx.period.runId
+
+  inline def currentPhaseId(using ctx: Context): PhaseId = ctx.period.phaseId
+
   /** 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

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

@@ -24,6 +24,8 @@ trait Phases {
 
 object Phases {
 
+  inline def currentPhase(using ctx: Context): Phase = ctx.base.phases(ctx.period.firstPhaseId)
+
   inline def phaseOf(id: PhaseId)(using Context): Phase =
     ctx.base.phases(id)
 

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

@@ -15,6 +15,7 @@ import Contexts._
 import Phases._
 import Denotations._
 import SymDenotations._
+import Periods.currentPhaseId
 import printing.Texts._
 import printing.Printer
 import util.common._

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

@@ -10,6 +10,7 @@ import util.SourcePosition
 import NameKinds.DepParamName
 import Decorators._
 import StdNames._
+import Phases.currentPhase
 import collection.mutable
 import ast.tpd._
 import reporting.{trace, Message}

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -8,6 +8,7 @@ import core.Contexts._
 import core.TypeError
 import util.{SourcePosition, NoSourcePosition}
 import core.Decorators.PhaseListDecorator
+import core.Phases.currentPhase
 import collection.mutable
 import core.Mode
 import dotty.tools.dotc.core.Symbols.{Symbol, NoSymbol}