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