Make more contexts Ctx instances

 - outer of a Ctx - fresh in a Ctx - ContextOps extension methods now all yield Ctx.

Author: odersky

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

@@ -147,7 +147,7 @@ class Compiler {
  reset()
  val rctx =
  if ctx.settings.Ysemanticdb.value
- currentContext.addMode(Mode.ReadPositions)
+ currentContext.withAddedMode(Mode.ReadPositions)
  else
  currentContext
  new Run(this, rctx)

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

@@ -200,7 +200,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
  profiler.finished()
  }
 
- val runCtx = ctx.fresh
+ val runCtx = currentContext.fresh
  runCtx.setProfiler(Profiler())
  unfusedPhases.foreach(_.initContext(runCtx))
  runPhases(using runCtx)

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

@@ -60,7 +60,7 @@ class TreeMapWithImplicits extends tpd.TreeMap {
  traverse(stats)
  }
 
- private def nestedScopeCtx(defs: List[Tree])(using Ctx, CState): Context = {
+ private def nestedScopeCtx(defs: List[Tree])(using Ctx, CState): Ctx = {
  val nestedCtx = ctx.fresh.setNewScope
  defs foreach {
  case d: DefTree if d.symbol.isOneOf(GivenOrImplicit) => nestedCtx.enter(d.symbol)
@@ -69,7 +69,7 @@ class TreeMapWithImplicits extends tpd.TreeMap {
  nestedCtx
  }
 
- private def patternScopeCtx(pattern: Tree)(using Ctx, CState): Context = {
+ private def patternScopeCtx(pattern: Tree)(using Ctx, CState): Ctx = {
  val nestedCtx = ctx.fresh.setNewScope
  new TreeTraverser {
  def traverse(tree: Tree)(using Ctx, CState): Unit = {

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

@@ -1223,7 +1223,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
  * EmptyTree calls (for parameters) cancel the next-enclosing call in the list instead of being added to it.
  * We assume parameters are never nested inside parameters.
  */
- override def inlineContext(call: Tree)(using Ctx, CState): Context = {
+ override def inlineContext(call: Tree)(using Ctx, CState): Ctx = {
  // We assume enclosingInlineds is already normalized, and only process the new call with the head.
  val oldIC = enclosingInlineds
 

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

@@ -64,22 +64,22 @@ object ContextOps:
  * Owner might not exist (can happen for self valdefs), in which case
  * no owner is set in result context
  */
- def localContext(tree: untpd.Tree, owner: Symbol)(using CState): FreshContext =
+ def localContext(tree: untpd.Tree, owner: Symbol)(using CState): FreshCtx =
  given Ctx = ctx
  val freshCtx = fresh.setTree(tree)
  if (owner.exists) freshCtx.setOwner(owner) else freshCtx
 
  /** A new context for the interior of a class */
- def inClassContext(selfInfo: TypeOrSymbol)(using CState): Context =
+ def inClassContext(selfInfo: TypeOrSymbol)(using CState): Ctx =
  given Ctx = ctx
- val localCtx: Context = fresh.setNewScope
+ val localCtx = fresh.setNewScope
  selfInfo match {
  case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
  case _ =>
  }
  localCtx
 
- def packageContext(tree: untpd.PackageDef, pkg: Symbol)(using CState): Context =
+ def packageContext(tree: untpd.PackageDef, pkg: Symbol)(using CState): Ctx =
  given Ctx = ctx
  if (pkg.is(Package)) fresh.setOwner(pkg.moduleClass).setTree(tree)
  else combinedContext
@@ -104,7 +104,7 @@ object ContextOps:
  * context see the constructor parameters instead, but then we'd need a final substitution step
  * from constructor parameters to class parameter accessors.
  */
- def superCallContext(using CState): Context =
+ def superCallContext(using CState): Ctx =
  given Ctx = ctx
  val locals = newScopeWith(owner.typeParams ++ owner.asClass.paramAccessors: _*)
  superOrThisCallContext(owner.primaryConstructor, locals)
@@ -117,7 +117,7 @@ object ContextOps:
  * - as outer context: The context enclosing the enclosing class context
  * - as scope: The parameters of the auxiliary constructor.
  */
- def thisCallArgContext(using CState): Context =
+ def thisCallArgContext(using CState): Ctx =
  given Ctx = ctx
  val constrCtx = outersIterator.dropWhile(_.outer.owner == owner).next()
  superOrThisCallContext(owner, constrCtx.scope)
@@ -127,22 +127,22 @@ object ContextOps:
  .setScope(ctx.scope)
 
  /** The super- or this-call context with given owner and locals. */
- def superOrThisCallContext(owner: Symbol, locals: Scope)(using CState): FreshContext =
+ def superOrThisCallContext(owner: Symbol, locals: Scope)(using CState): FreshCtx =
  given Ctx = ctx
  var classCtx = ctx.outersIterator.dropWhile(!_.isClassDefContext).next()
  classCtx.outer.fresh.setOwner(owner)
  .setScope(locals)
  .setMode(classCtx.mode)
 
  /** The context of expression `expr` seen as a member of a statement sequence */
- def exprContext(stat: Tree[? >: Untyped], exprOwner: Symbol)(using CState): Context =
+ def exprContext(stat: Tree[? >: Untyped], exprOwner: Symbol)(using CState): Ctx =
  given Ctx = ctx
  if (exprOwner == ctx.owner) combinedContext
  else if (untpd.isSuperConstrCall(stat) && ctx.owner.isClass) superCallContext
  else fresh.setOwner(exprOwner)
 
  /** A new context that summarizes an import statement */
- def importContext(imp: Import[?], sym: Symbol)(using CState): FreshContext =
+ def importContext(imp: Import[?], sym: Symbol)(using CState): FreshCtx =
  given Ctx = ctx
  val impNameOpt = imp.expr match {
  case ref: RefTree[?] => Some(ref.name.asTermName)

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

@@ -172,19 +172,66 @@ object Contexts {
  def uniqueNamedTypes: Uniques.NamedTypeUniques
  def uniques: util.HashSet[Type]
 
- def fresh: FreshContext
- def freshOver(outer: Context): FreshContext
+ def fresh: FreshCtx
+ def freshOver(outer: Ctx): FreshCtx
 
  def withPeriod(pd: Period): Context
  def withPhase(phaseId: PhaseId): Context
  def withPhase(phase: Phase): Context
  def withOwner(owner: Symbol): Ctx
  def withSource(source: SourceFile): Ctx
  def withProperty[T](key: Key[T], value: Option[T]): Ctx
+ def withAddedMode(mode: Mode): Ctx
+ def withRetractedMode(mode: Mode): Ctx
+
+ def toContext(using cs: CState) = withPeriod(cs)
+
+ private[Contexts] def storedSourceCtx(source: SourceFile): Ctx
 
  def toContextUNSAFE = asInstanceOf[Context]
  end Ctx
 
+ trait FreshCtx extends Ctx:
+ def setPeriod(period: Period): this.type
+ def setMode(mode: Mode): this.type
+ def addMode(mode: Mode): this.type
+ def retractMode(mode: Mode): this.type
+ def setOwner(owner: Symbol): this.type
+ def setTree(tree: Tree[? >: Untyped]): this.type
+ def setScope(scope: Scope): this.type
+ def setNewScope: this.type
+ def setTyperState(typerState: TyperState): this.type
+ def setNewTyperState(): this.type
+ def setExploreTyperState(): this.type
+ def setReporter(reporter: Reporter): this.type
+ def setTypeAssigner(typeAssigner: TypeAssigner): this.type
+ def setTyper(typer: Typer): this.type
+ def setGadt(gadt: GadtConstraint): this.type
+ def setFreshGADTBounds: this.type
+ def setSearchHistory(searchHistory: SearchHistory): this.type
+ def setSource(source: SourceFile): this.type
+ def setTypeComparerFn(tcfn: Context => TypeComparer): this.type
+ def setImplicits(implicits: ContextualImplicits): this.type
+ def setCompilationUnit(compilationUnit: CompilationUnit): this.type
+ def setCompilerCallback(callback: CompilerCallback): this.type
+ def setSbtCallback(callback: AnalysisCallback): this.type
+ def setPrinterFn(printer: Context => Printer): this.type
+ def setSettings(settingsState: SettingsState): this.type
+ def setRun(run: Run): this.type
+ def setProfiler(profiler: Profiler): this.type
+ def setNotNullInfos(notNullInfos: List[NotNullInfo]): this.type
+ def setImportInfo(importInfo: ImportInfo): this.type
+ def setProperty[T](key: Key[T], value: T): this.type
+ def dropProperty(key: Key[?]): this.type
+ def addLocation[T](initial: T): Store.Location[T]
+ def addLocation[T](): Store.Location[T]
+ def updateStore[T](loc: Store.Location[T], value: T): this.type
+ def setPhase(pid: PhaseId): this.type
+ def setPhase(phase: Phase): this.type
+ def setSetting[T](setting: Setting[T], value: T): this.type
+ def setDebug: this.type
+ end FreshCtx
+
  /** 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
@@ -210,16 +257,16 @@ object Contexts {
  protected given CState = cstate
 
  /** All outer contexts, ending in `base.initialCtx` and then `NoContext` */
- def outersIterator: Iterator[Context] = new Iterator[Context] {
- var current = thiscontext
+ def outersIterator: Iterator[Ctx] = new Iterator[Ctx] {
+ var current: Ctx = thiscontext
  def hasNext = current != NoContext
  def next = { val c = current; current = current.outer; c }
  }
 
  /** The outer context */
- private var _outer: Context = _
- protected def outer_=(outer: Context): Unit = _outer = outer
- final def outer: Context = _outer
+ private var _outer: Ctx = _
+ protected def outer_=(outer: Ctx): Unit = _outer = outer
+ final def outer: Ctx = _outer
 
  /** The current context */
  private var _period: Period = _
@@ -487,9 +534,12 @@ object Contexts {
  * @param outer The outer context
  * @param origin The context from which fields are copied
  */
- private[Contexts] def init(outer: Context, origin: Context): this.type = {
+ private[Contexts] def init(outer: Ctx, origin: Context): this.type =
+ init(outer, origin, origin.cstate)
+
+ private[Contexts] def init(outer: Ctx, origin: Ctx, cstate: CState): this.type = {
  _outer = outer
- _period = origin.period
+ _period = cstate
  _mode = origin.mode
  _owner = origin.owner
  _tree = origin.tree
@@ -514,20 +564,23 @@ object Contexts {
  def fresh: FreshContext = freshOver(this)
 
  /** A fresh clone of this context embedded in the specified `outer` context. */
- def freshOver(outer: Context): FreshContext =
+ def freshOver(outer: Ctx): FreshContext =
  util.Stats.record("Context.fresh")
  FreshContext(base).init(outer, this).setTyperState(this.typerState)
 
  final def withOwner(owner: Symbol): Context =
  if (owner ne this.owner) fresh.setOwner(owner) else this
 
- private var sourceCtx: SimpleIdentityMap[SourceFile, Context] = null
+ private var sourceCtx: SimpleIdentityMap[SourceFile, Ctx] = null
+
+ private[Contexts] def storedSourceCtx(source: SourceFile): Ctx =
+ if sourceCtx == null then null
+ else sourceCtx(source)
 
- final def withSource(source: SourceFile): Context =
- if (source `eq` this.source) this
- else if ((source `eq` outer.source) &&
- outer.sourceCtx != null &&
- (outer.sourceCtx(this.source) `eq` this)) outer
+ final def withSource(source: SourceFile): Ctx =
+ if source eq this.source then this
+ else if (source eq outer.source)
+ && (outer.storedSourceCtx(this.source) eq this) then outer
  else {
  if (sourceCtx == null) sourceCtx = SimpleIdentityMap.Empty
  val prev = sourceCtx(source)
@@ -551,6 +604,12 @@ object Contexts {
  case None => fresh.dropProperty(key)
  }
 
+ private def withModeBits(mode: Mode): Context =
+ if (mode != this.mode) fresh.setMode(mode) else this
+
+ def withAddedMode(mode: Mode): Context = withModeBits(this.mode | mode)
+ def withRetractedMode(mode: Mode): Context = withModeBits(this.mode &~ mode)
+
  def typer: Typer = this.typeAssigner match {
  case typer: Typer => typer
  case _ => new Typer
@@ -585,7 +644,7 @@ object Contexts {
  /** A fresh context allows selective modification
  * of its attributes using the with... methods.
  */
- class FreshContext(base: ContextBase) extends Context(base) {
+ class FreshContext(base: ContextBase) extends Context(base), FreshCtx {
  def setPeriod(period: Period): this.type =
  util.Stats.record("Context.setPeriod")
  this.period = period
@@ -594,6 +653,8 @@ object Contexts {
  util.Stats.record("Context.setMode")
  this.mode = mode
  this
+ final def addMode(mode: Mode): this.type = setMode(this.mode | mode)
+ final def retractMode(mode: Mode): this.type = setMode(this.mode &~ mode)
  def setOwner(owner: Symbol): this.type =
  util.Stats.record("Context.setOwner")
  assert(owner != NoSymbol)
@@ -696,7 +757,7 @@ object Contexts {
  def withNotNullInfos(infos: List[NotNullInfo])(using CState): Ctx =
  if c.notNullInfos eq infos then c else c.fresh.setNotNullInfos(infos)
  end ops
-
+/*
  // TODO: Fix issue when converting ModeChanges and FreshModeChanges to extension givens
  implicit class ModeChanges(val c: Context) extends AnyVal {
  final def withModeBits(mode: Mode): Context =
@@ -710,7 +771,7 @@ object Contexts {
  final def addMode(mode: Mode): c.type = c.setMode(c.mode | mode)
  final def retractMode(mode: Mode): c.type = c.setMode(c.mode &~ mode)
  }
-
+*/
  /** Test `op` in a fresh context with a typerstate that is not committable.
  * The passed context may not survive the operation.
  */
@@ -725,7 +786,7 @@ object Contexts {
  val ts = TyperState()
  .setReporter(TestingReporter())
  .setCommittable(false)
- val c = FreshContext(ctx.base).init(ctx.toContextUNSAFE, ctx.toContextUNSAFE).setTyperState(ts)
+ val c = FreshContext(ctx.base).init(ctx, ctx, currentPeriod).setTyperState(ts)
  testContexts += c
  c
  testsInUse += 1

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

@@ -291,10 +291,10 @@ object Phases {
  /** @pre `isRunnable` returns true */
  def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
  units.map { unit =>
- val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)
- assert(unitCtx.compilationUnit != null)
- run(using unitCtx, unitCtx.cstate)
- unitCtx.compilationUnit
+ val unitContext = currentContext.fresh.setPhase(this.start).setCompilationUnit(unit)
+ assert(unitContext.compilationUnit != null)
+ run(using unitContext, unitContext.cstate)
+ unitContext.compilationUnit
  }
 
  def description: String = phaseName
@@ -326,7 +326,7 @@ object Phases {
 
  def exists: Boolean = true
 
- def initContext(ctx: FreshContext): Unit = ()
+ def initContext(ctx: FreshCtx): Unit = ()
 
  private var myPeriod: Period = Periods.InvalidPeriod
  private var myBase: ContextBase = null

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

@@ -28,17 +28,17 @@ object StagingContext {
  ctx.property(QuotationLevel).getOrElse(0)
 
  /** Context with an incremented quotation level. */
- def quoteContext(using Ctx, CState): Context =
+ def quoteContext(using Ctx, CState): Ctx =
  ctx.fresh.setProperty(QuotationLevel, level + 1)
 
  /** Context with an incremented quotation level and pushes a refecence to a QuoteContext on the quote context stack */
- def pushQuoteContext(qctxRef: tpd.Tree)(using Ctx, CState): Context =
+ def pushQuoteContext(qctxRef: tpd.Tree)(using Ctx, CState): Ctx =
  val old = ctx.property(QuoteContextStack).getOrElse(List.empty)
  ctx.fresh.setProperty(QuotationLevel, level + 1)
  .setProperty(QuoteContextStack, qctxRef :: old)
 
  /** Context with a decremented quotation level. */
- def spliceContext(using Ctx, CState): Context =
+ def spliceContext(using Ctx, CState): Ctx =
  ctx.fresh.setProperty(QuotationLevel, level - 1)
 
  def contextWithQuoteTypeTags(taggedTypes: PCPCheckAndHeal.QuoteTypeTags)(using Ctx, CState) =
@@ -50,7 +50,7 @@ object StagingContext {
  /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
  * The quotation stack could be empty if we are in a top level splice or an eroneous splice directly witin a top level splice.
  */
- def popQuoteContext()(using Ctx, CState): (Option[tpd.Tree], Context) =
+ def popQuoteContext()(using Ctx, CState): (Option[tpd.Tree], Ctx) =
  val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
  val head =
  ctx.property(QuoteContextStack) match

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

@@ -636,7 +636,7 @@ object TypeOps:
 
  val childTp = if (child.isTerm) child.termRef else child.typeRef
 
- inContext(ctx.fresh.setExploreTyperState().setFreshGADTBounds) {
+ inCtx(ctx.fresh.setExploreTyperState().setFreshGADTBounds) {
  instantiateToSubType(childTp, parent).dealias
  }
  }
@@ -725,7 +725,7 @@ object TypeOps:
  // we manually patch subtyping check instead of changing TypeComparer.
  // See tests/patmat/i3645b.scala
  def parentQualify = tp1.widen.classSymbol.info.parents.exists { parent =>
- inContext(ctx.fresh.setNewTyperState()) {
+ inCtx(ctx.fresh.setNewTyperState()) {
  parent.argInfos.nonEmpty && minTypeMap.apply(parent) <:< maxTypeMap.apply(tp2)
  }
  }