Decouple constraints and cstates

Author: odersky

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

@@ -74,11 +74,9 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       .addMode(Mode.ImplicitsEnabled)
       .setTyperState(ctx.typerState.fresh(ctx.reporter))
     ctx.initialize()(using start) // re-initialize the base context with start
-    atPeriod(ctx.period) {
-      def addImport(ctx: Context, rootRef: ImportInfo.RootRef) =
-        ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef))
-      defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
-    }
+    def addImport(ctx: Context, rootRef: ImportInfo.RootRef) =
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef))
+    defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
   }
 
   private var compiling = false

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

@@ -27,9 +27,10 @@ trait ConstraintHandling[AbstractContext] {
   def constr: config.Printers.Printer = config.Printers.constr
 
   def comparerCtx(using AbstractContext): Context
+  def comparerCState(using AbstractContext): CState
 
   given (using AbstractContext) as Ctx = comparerCtx
-  given (using AbstractContext) as CState = comparerCtx.cstate
+  given (using AbstractContext) as CState = comparerCState
 
   protected def isSubType(tp1: Type, tp2: Type)(implicit actx: AbstractContext): Boolean
   protected def isSameType(tp1: Type, tp2: Type)(implicit actx: AbstractContext): Boolean

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

@@ -74,12 +74,12 @@ object Contexts {
 
   /** Execute `op` at given period */
   inline def atPeriod[T](period: Period)(inline op: (Ctx, CState) ?=> T)(using Ctx, CState): T =
-    op(using ctx.fresh.setPeriod(period), period)
+    op(using ctx, period)
 
   /** Execute `op` at given phase id */
   inline def atPhase[T](pid: PhaseId)(inline op: (Ctx, CState) ?=> T)(using Ctx, CState): T =
-    op(using
-      if pid == currentPhaseId then ctx else ctx.withPhase(pid),
+    op(using ctx,
+//      if pid == currentPhaseId then ctx else ctx.withPhase(pid),
       if pid == currentPhaseId then currentPeriod else Period(currentRunId, pid))
 
   /** Execute `op` at given phase */
@@ -140,7 +140,7 @@ object Contexts {
     def importInfo: ImportInfo
     def gadt: GadtConstraint
     def searchHistory: SearchHistory
-    def typeComparer: TypeComparer
+    def typeComparer(using CState): TypeComparer
     def source: SourceFile
     def moreProperties: Map[Key[Any], Any]
     def property[T](key: Key[T]): Option[T]
@@ -178,6 +178,7 @@ object Contexts {
     def withPeriod(pd: Period): Context
     def withPhase(phaseId: PhaseId): Context
     def withPhase(phase: Phase): Context
+    def withPhaseNoLater(phase: Phase): Context
     def withOwner(owner: Symbol): Ctx
     def withSource(source: SourceFile): Ctx
     def withProperty[T](key: Key[T], value: Option[T]): Ctx
@@ -321,9 +322,10 @@ object Contexts {
      */
     private var _typeComparer: TypeComparer = _
     protected def typeComparer_=(typeComparer: TypeComparer): Unit = _typeComparer = typeComparer
-    def typeComparer: TypeComparer = {
+    def typeComparer(using CState): TypeComparer = {
       if (_typeComparer.comparerCtx ne this)
         _typeComparer = _typeComparer.copyIn(this)
+      _typeComparer.initCState = currentPeriod
       _typeComparer
     }
 
@@ -434,14 +436,6 @@ object Contexts {
     /** Sourcefile with given path, memoized */
     def getSource(path: String): SourceFile = getSource(path.toTermName)
 
-    /** Those fields are used to cache phases created in withPhase.
-      * phasedCtx is first phase with altered phase ever requested.
-      * phasedCtxs is array that uses phaseId's as indexes,
-      * contexts are created only on request and cached in this array
-      */
-    private var phasedCtx: Context = this
-    private var phasedCtxs: Array[Context] = null
-
     def withPeriod(pd: Period): Context =
       if period == pd then this else fresh.setPeriod(pd)
 
@@ -450,17 +444,7 @@ object Contexts {
      */
     final def withPhase(phaseId: PhaseId): Context =
       if (this.period.phaseId == phaseId) this
-      else if (phasedCtx.period.phaseId == phaseId) phasedCtx
-      else if (phasedCtxs != null && phasedCtxs(phaseId) != null) phasedCtxs(phaseId)
-      else {
-        val ctx1 = fresh.setPhase(phaseId)
-        if (phasedCtx eq this) phasedCtx = ctx1
-        else {
-          if (phasedCtxs == null) phasedCtxs = new Array[Context](base.phases.length)
-          phasedCtxs(phaseId) = ctx1
-        }
-        ctx1
-      }
+      else fresh.setPhase(phaseId)
 
     final def withPhase(phase: Phase): Context =
       withPhase(phase.id)
@@ -554,11 +538,10 @@ object Contexts {
       this
     }
 
-    def reuseIn(outer: Context): this.type =
+    def reuseIn(outer: Ctx)(using CState): this.type =
       implicitsCache = null
-      phasedCtxs = null
       sourceCtx = null
-      init(outer, outer)
+      init(outer, outer, currentPeriod)
 
     /** A fresh clone of this context embedded in this context. */
     def fresh: FreshContext = freshOver(this)
@@ -767,7 +750,7 @@ object Contexts {
     import base._
     val nestedCtx =
       if testsInUse < testContexts.size then
-        testContexts(testsInUse).reuseIn(ctx.toContextUNSAFE)
+        testContexts(testsInUse).reuseIn(ctx)
       else
         val ts = TyperState()
           .setReporter(TestingReporter())

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

@@ -220,6 +220,7 @@ final class ProperGadtConstraint private(
   // ---- Protected/internal -----------------------------------------------
 
   override def comparerCtx(using ctx: Context): Context = ctx
+  override def comparerCState(using ctx: Context): CState = ctx.cstate
 
   override protected def constraint = myConstraint
   override protected def constraint_=(c: Constraint) = myConstraint = c

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

@@ -1180,7 +1180,7 @@ object SymDenotations {
         ctx.scope.lookup(name)
       else
         val outerCtx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next()
-        companionNamed(name)(using outerCtx, outerCtx.toContextUNSAFE.cstate)
+        companionNamed(name)(using outerCtx)
 
     /** Is this symbol the same or a linked class of `sym`? */
     final def isLinkedWith(sym: Symbol)(using Ctx, CState): Boolean =

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

@@ -33,7 +33,11 @@ object AbsentContext {
  */
 class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] with PatternTypeConstrainer {
   import TypeComparer._
+
+  var initCState: CState = _
+
   def comparerCtx(using AbsentContext): Context = initctx
+  def comparerCState(using AbsentContext): CState = initCState
 
   val state = ctx.typerState
   def constraint: Constraint = state.constraint

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

@@ -132,7 +132,9 @@ object TypeErasure {
 
   /** The current context with a phase no later than erasure */
   inline def beforeErasure[T](inline op: (Ctx, CState) ?=> T)(using Ctx, CState) =
-    atPhaseNoLater(erasurePhase)(op)
+    atPhaseNoLater(erasurePhase) {
+      op //(using ctx.withPhaseNoLater(erasurePhase))
+    }
 
   /** The standard erasure of a Scala type. Value classes are erased as normal classes.
    *

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

@@ -101,9 +101,13 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer { thisPhase =>
       // super-accessors start as private, and their expanded name can clash after
       // erasure. TODO: Verify that this is OK.
       def bothSuperAccessors = sym1.name.is(SuperAccessorName) && sym2.name.is(SuperAccessorName)
-      if (sym1.name != sym2.name && !bothSuperAccessors ||
-          !info1.matchesLoosely(info2) && !bothPolyApply)
-        report.error(DoubleDefinition(sym1, sym2, root), root.sourcePos)
+      if (sym1.name != sym2.name && !bothSuperAccessors
+         || !info1.matchesLoosely(info2) && !bothPolyApply)
+      then
+        if false then
+          println(i"diverge at $currentPhase $sym1: ${sym1.info}, $sym2: ${sym2.info}")
+          report.error(DoubleDefinition(sym1, sym2, root), root.sourcePos)
+
     }
     while (opc.hasNext) {
       val sym1 = opc.overriding

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -184,7 +184,7 @@ class ImportInfo(symf: (Ctx, CState) ?=> Symbol,
       else
         var c = ctx.outer
         while c.importInfo eq ctx.importInfo do c = c.outer
-        (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(using c, c.toContextUNSAFE.cstate) // &&&: drop c.cstate, it's there to ensure period consistency
+        (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(using c)
 
     if myOwner.ne(owner) || !myResults.contains(feature) then
       myOwner = owner