Move phase back to Context

Author: odersky

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

@@ -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 = currentPhase.prev // can be a mini-phase
+    val prevPhase = ctx.phase.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 (currentPhase == trans.next) {
+      if (ctx.phase == trans.next) {
         val traverser = new TreeTraverser {
           def traverse(tree: Tree)(using Context) = tree match {
             case tree: DefTree =>

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

@@ -72,26 +72,20 @@ object Contexts {
     atPhase(phase.id)(op)
 
   inline def atNextPhase[T](inline op: Context ?=> T)(using Context): T =
-    atPhase(currentPhase.next)(op)
+    atPhase(ctx.phase.next)(op)
 
   inline def atPhaseNoLater[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
-    op(using if !limit.exists || currentPhase <= limit then ctx else ctx.withPhase(limit))
+    op(using if !limit.exists || ctx.phase <= limit then ctx else ctx.withPhase(limit))
 
   inline def atPhaseNoEarlier[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
-    op(using if !limit.exists || limit <= currentPhase then ctx else ctx.withPhase(limit))
+    op(using if !limit.exists || limit <= ctx.phase 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
-
-  def currentlyAfterTyper(using Context): Boolean = ctx.base.isAfterTyper(currentPhase)
+  def currentlyAfterTyper(using Context): Boolean = ctx.base.isAfterTyper(ctx.phase)
 
   /** Does current phase use an erased types interpretation? */
-  def currentlyAfterErasure(using Context): Boolean = currentPhase.erasedTypes
+  def currentlyAfterErasure(using Context): Boolean = ctx.phase.erasedTypes
 
   inline def inMode[T](mode: Mode)(inline op: Context ?=> T)(using ctx: Context): T =
     op(using if mode != ctx.mode then ctx.fresh.setMode(mode) else ctx)
@@ -369,8 +363,11 @@ object Contexts {
     /** The current reporter */
     def reporter: Reporter = typerState.reporter
 
+    final def phase: Phase = base.phases(period.firstPhaseId)
     final def runId = period.runId
     final def phaseId = period.phaseId
+    final def erasedTypes = phase.erasedTypes
+    final def isAfterTyper = base.isAfterTyper(phase)
 
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =

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 (currentPhase.erasedTypes) ctype else ctype.appliedTo(arg)
+    if (ctx.phase.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 && !currentPhase.erasedTypes) cls == NothingClass
+    if (ctx.explicitNulls && !ctx.phase.erasedTypes) cls == NothingClass
     else isBottomClassAfterErasure(cls)
 
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass
 
   def isBottomType(tp: Type): Boolean =
-    if (ctx.explicitNulls && !currentPhase.erasedTypes) tp.derivesFrom(NothingClass)
+    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
     else isBottomTypeAfterErasure(tp)
 
   def isBottomTypeAfterErasure(tp: Type): Boolean =

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

@@ -43,7 +43,7 @@ object DenotTransformers {
         if (info1 eq ref.info) ref
         else ref match {
           case ref: SymDenotation =>
-            ref.copySymDenotation(info = info1).copyCaches(ref, currentPhase.next)
+            ref.copySymDenotation(info = info1).copyCaches(ref, ctx.phase.next)
           case _ =>
             ref.derivedSingleDenotation(ref.symbol, info1)
         }

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

@@ -842,7 +842,7 @@ object Denotations {
     }
 
     private def demandOutsideDefinedMsg(using Context): String =
-      s"demanding denotation of $this at phase ${currentPhase}(${ctx.phaseId}) outside defined interval: defined periods are${definedPeriodsString}"
+      s"demanding denotation of $this at phase ${ctx.phase}(${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.

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

@@ -762,7 +762,7 @@ object SymDenotations {
 
     /** Is this symbol a class of which `null` is a value? */
     final def isNullableClass(using Context): Boolean =
-      if (ctx.explicitNulls && !currentPhase.erasedTypes) symbol == defn.NullClass || symbol == defn.AnyClass
+      if (ctx.explicitNulls && !ctx.phase.erasedTypes) symbol == defn.NullClass || symbol == defn.AnyClass
       else isNullableClassAfterErasure
 
     /** Is this symbol a class of which `null` is a value after erasure?
@@ -849,7 +849,7 @@ object SymDenotations {
         || this.is(Protected) &&
              (  superAccess
              || pre.isInstanceOf[ThisType]
-             || currentPhase.erasedTypes
+             || ctx.phase.erasedTypes
              || isProtectedAccessOK
              )
         )
@@ -1325,7 +1325,7 @@ object SymDenotations {
     final def accessBoundary(base: Symbol)(using Context): Symbol =
       if (this.is(Private)) owner
       else if (this.isAllOf(StaticProtected)) defn.RootClass
-      else if (privateWithin.exists && !currentPhase.erasedTypes) privateWithin
+      else if (privateWithin.exists && !ctx.phase.erasedTypes) privateWithin
       else if (this.is(Protected)) base
       else defn.RootClass
 
@@ -1451,7 +1451,7 @@ object SymDenotations {
       val initFlags1 = (if (initFlags != UndefinedFlags) initFlags else this.flags)
       val info1 = if (info != null) info else this.info
       if (currentlyAfterTyper && changedClassParents(info, info1, completersMatter = false))
-        assert(currentPhase.changesParents, i"undeclared parent change at ${currentPhase} for $this, was: $info, now: $info1")
+        assert(ctx.phase.changesParents, i"undeclared parent change at ${ctx.phase} for $this, was: $info, now: $info1")
       val privateWithin1 = if (privateWithin != null) privateWithin else this.privateWithin
       val annotations1 = if (annotations != null) annotations else this.annotations
       val rawParamss1 = if rawParamss != null then rawParamss else this.rawParamss
@@ -2592,7 +2592,7 @@ object SymDenotations {
     private var cache: SimpleIdentityMap[NameFilter, Set[Name]] = SimpleIdentityMap.Empty
 
     final def isValid(using Context): Boolean =
-      cache != null && isValidAt(currentPhase)
+      cache != null && isValidAt(ctx.phase)
 
     private var locked = false
 
@@ -2634,7 +2634,7 @@ object SymDenotations {
     private var locked = false
     private var provisional = false
 
-    final def isValid(using Context): Boolean = valid && isValidAt(currentPhase)
+    final def isValid(using Context): Boolean = valid && isValidAt(ctx.phase)
 
     def invalidate(): Unit =
       if (valid && !locked) {

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

@@ -388,7 +388,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
         }
       case tp1: SkolemType =>
         tp2 match {
-          case tp2: SkolemType if !currentPhase.isTyper && recur(tp1.info, tp2.info) => true
+          case tp2: SkolemType if !ctx.phase.isTyper && recur(tp1.info, tp2.info) => true
           case _ => thirdTry
         }
       case tp1: TypeVar =>
@@ -808,7 +808,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
           case _ => tp2.isAnyRef
         }
         compareJavaArray
-      case tp1: ExprType if currentPhase.id > gettersPhase.id =>
+      case tp1: ExprType if ctx.phase.id > gettersPhase.id =>
         // getters might have converted T to => T, need to compensate.
         recur(tp1.widenExpr, tp2)
       case _ =>
@@ -1233,7 +1233,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
      *  for equality would give the wrong result, so we should not use the sets
      *  for comparisons.
      */
-    def canCompare(ts: Set[Type]) = currentPhase.isTyper || {
+    def canCompare(ts: Set[Type]) = ctx.phase.isTyper || {
       val hasSkolems = new ExistsAccumulator(_.isInstanceOf[SkolemType]) {
         override def stopAtStatic = true
       }

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

@@ -122,7 +122,7 @@ object TypeOps:
   }
 
   def isLegalPrefix(pre: Type)(using Context): Boolean =
-    pre.isStable || !currentPhase.isTyper
+    pre.isStable || !ctx.phase.isTyper
 
   /** Implementation of Types#simplified */
   def simplify(tp: Type, theMap: SimplifyMap)(using Context): Type = {

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

@@ -980,7 +980,7 @@ object Types {
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")
-      ctx.typeComparer.matchesType(this, that, relaxed = !currentPhase.erasedTypes)
+      ctx.typeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes)
     }
 
     /** This is the same as `matches` except that it also matches => T with T and
@@ -2094,7 +2094,7 @@ object Types {
       else {
         if (!ctx.reporter.errorsReported)
           throw new TypeError(
-            i"""bad parameter reference $this at ${currentPhase}
+            i"""bad parameter reference $this at ${ctx.phase}
                |the parameter is ${param.showLocated} but the prefix $prefix
                |does not define any corresponding arguments.""")
         NoDenotation
@@ -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 ${ctx.runId}""")
+           |period = ${ctx.phase} at run ${ctx.runId}""")
     }
 
     /** A reference with the initial symbol in `symd` has an info that
@@ -2489,7 +2489,7 @@ object Types {
 
   /** Assert current phase does not have erasure semantics */
   private def assertUnerased()(using Context) =
-    if (Config.checkUnerased) assert(!currentPhase.erasedTypes)
+    if (Config.checkUnerased) assert(!ctx.phase.erasedTypes)
 
   /** The designator to be used for a named type creation with given prefix, name, and denotation.
    *  This is the denotation's symbol, if it exists and the prefix is not the this type

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -309,7 +309,7 @@ class ClassfileParser(
 
   /** Map direct references to Object to references to Any */
   final def objToAny(tp: Type)(using Context): Type =
-    if (tp.isDirectRef(defn.ObjectClass) && !currentPhase.erasedTypes) defn.AnyType else tp
+    if (tp.isDirectRef(defn.ObjectClass) && !ctx.phase.erasedTypes) defn.AnyType else tp
 
   def constantTagToType(tag: Int)(using Context): Type =
     (tag: @switch) match {

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -986,7 +986,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   protected def deferredAnnot(end: Int)(using Context): Annotation = {
     val start = readIndex
     val atp = readTypeRef()
-    val phase = currentPhase
+    val phase = ctx.phase
     Annotation.deferred(atp.typeSymbol)(
         atReadPos(start, () => atPhase(phase)(readAnnotationContents(end))))
   }

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

@@ -92,8 +92,8 @@ object report:
    *  "contains" here.
    */
   def log(msg: => String, pos: SourcePosition = NoSourcePosition)(using Context): Unit =
-    if (ctx.settings.Ylog.value.containsPhase(currentPhase))
-      echo(s"[log $currentPhase] $msg", pos)
+    if (ctx.settings.Ylog.value.containsPhase(ctx.phase))
+      echo(s"[log $ctx.phase] $msg", pos)
 
   def debuglog(msg: => String)(using Context): Unit =
     if (ctx.debug) log(msg)

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

@@ -2011,7 +2011,7 @@ import ast.tpd
             case NoMatch =>
               // If the signatures don't match at all at the current phase, then
               // they might match after erasure.
-              if currentPhase.id <= elimErasedValueTypePhase.id then
+              if ctx.phase.id <= elimErasedValueTypePhase.id then
                 atPhase(elimErasedValueTypePhase.next)(details)
               else
                 "" // shouldn't be reachable

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

@@ -14,7 +14,7 @@ import util.SourcePosition
 class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   import ast.tpd._
 
-  assert(currentPhase == erasurePhase.next)
+  assert(ctx.phase == erasurePhase.next)
   private val preErasureCtx = ctx.withPhase(erasurePhase)
   private lazy val elimErasedCtx = ctx.withPhase(elimErasedValueTypePhase.next)
 

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

@@ -50,13 +50,13 @@ class Erasure extends Phase with DenotTransformer {
     case ref: SymDenotation =>
       def isCompacted(symd: SymDenotation) =
         symd.isAnonymousFunction && {
-          atPhase(currentPhase.next)(symd.info) match {
+          atPhase(ctx.phase.next)(symd.info) match {
             case MethodType(nme.ALLARGS :: Nil) => true
             case _                              => false
           }
         }
 
-      assert(currentPhase == this, s"transforming $ref at ${currentPhase}")
+      assert(ctx.phase == this, s"transforming $ref at ${ctx.phase}")
       if (ref.symbol eq defn.ObjectClass) {
         // After erasure, all former Any members are now Object members
         val ClassInfo(pre, _, ps, decls, selfInfo) = ref.info
@@ -99,7 +99,7 @@ class Erasure extends Phase with DenotTransformer {
         then
           ref
         else
-          assert(!ref.is(Flags.PackageClass), s"trans $ref @ ${currentPhase} oldOwner = $oldOwner, newOwner = $newOwner, oldInfo = $oldInfo, newInfo = $newInfo ${oldOwner eq newOwner} ${oldInfo eq newInfo}")
+          assert(!ref.is(Flags.PackageClass), s"trans $ref @ ${ctx.phase} oldOwner = $oldOwner, newOwner = $newOwner, oldInfo = $oldInfo, newInfo = $newInfo ${oldOwner eq newOwner} ${oldInfo eq newInfo}")
           ref.copySymDenotation(
             symbol = newSymbol,
             owner = newOwner,
@@ -166,7 +166,7 @@ class Erasure extends Phase with DenotTransformer {
            isAllowed(defn.TupleClass, "Tuple.scala") ||
            isAllowed(defn.NonEmptyTupleClass, "Tuple.scala") ||
            isAllowed(defn.PairClass, "Tuple.scala"),
-        i"The type $tp - ${tp.toString} of class ${tp.getClass} of tree $tree : ${tree.tpe} / ${tree.getClass} is illegal after erasure, phase = ${currentPhase.prev}")
+        i"The type $tp - ${tp.toString} of class ${tp.getClass} of tree $tree : ${tree.tpe} / ${tree.getClass} is illegal after erasure, phase = ${ctx.phase.prev}")
   }
 }
 
@@ -981,7 +981,7 @@ object Erasure {
 
     override def adapt(tree: Tree, pt: Type, locked: TypeVars, tryGadtHealing: Boolean)(using Context): Tree =
       trace(i"adapting ${tree.showSummary}: ${tree.tpe} to $pt", show = true) {
-        if currentPhase != erasurePhase && currentPhase != erasurePhase.next then
+        if ctx.phase != erasurePhase && ctx.phase != erasurePhase.next then
           // this can happen when reading annotations loaded during erasure,
           // since these are loaded at phase typer.
           atPhase(erasurePhase.next)(adapt(tree, pt, locked))

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

@@ -117,7 +117,7 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
         case ClassInfo(pre, cls, _, _, _) if cls is ModuleClass =>
           cls.linkedClass match {
             case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
-              val info1 = atPhase(currentPhase.next)(cls.denot).asClass.classInfo.derivedClassInfo(prefix = pre)
+              val info1 = atPhase(ctx.phase.next)(cls.denot).asClass.classInfo.derivedClassInfo(prefix = pre)
               ref.derivedSingleDenotation(ref.symbol, info1)
             case _ => ref
           }

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

@@ -39,7 +39,7 @@ class Staging extends MacroTransform {
   override def allowsImplicitSearch: Boolean = true
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =
-    if (currentPhase <= reifyQuotesPhase) {
+    if (ctx.phase <= reifyQuotesPhase) {
       // Recheck that PCP holds but do not heal any inconsistent types as they should already have been heald
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>

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

@@ -130,7 +130,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         case nme.productElementName => productElementNameBody(accessors.length, vrefss.head.head)
         case nme.ordinal => Select(This(clazz), nme.ordinalDollar)
       }
-      report.log(s"adding $synthetic to $clazz at ${currentPhase}")
+      report.log(s"adding $synthetic to $clazz at ${ctx.phase}")
       synthesizeDef(synthetic, syntheticRHS)
     }
 

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

@@ -37,7 +37,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
   def mkByNameClosure(arg: Tree, argType: Type)(using Context): Tree = unsupported(i"mkClosure($arg)")
 
   override def transformApply(tree: Apply)(using Context): Tree =
-    trace(s"transforming ${tree.show} at phase ${currentPhase}", show = true) {
+    trace(s"transforming ${tree.show} at phase ${ctx.phase}", show = true) {
 
       def transformArg(arg: Tree, formal: Type): Tree = formal.dealias match {
         case formalExpr: ExprType =>