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))