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