Move isCurrentlyAfterTyper to Context

The idea is that all core operation that query or set the current context
should be in Contexts. That way they are easier to import.

Also: Do some cleanups on phases names

Author: odersky

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

@@ -10,7 +10,7 @@ import Scopes._
 import typer.{ImportInfo, Typer}
 import Decorators._
 import io.{AbstractFile, PlainFile}
-import Phases.curPhases
+import Phases.unfusedPhases
 
 import scala.io.Codec
 import util.{Set => _, _}
@@ -165,7 +165,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       else ctx.settings.YstopAfter.value
 
     val pluginPlan = ctx.base.addPluginPhases(ctx.base.phasePlan)
-    val phases = ctx.base.squashPhases(pluginPlan,
+    val phases = ctx.base.fusePhases(pluginPlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.base.usePhases(phases)
 
@@ -195,7 +195,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
     val runCtx = ctx.fresh
     runCtx.setProfiler(Profiler())
-    curPhases.foreach(_.initContext(runCtx))
+    unfusedPhases.foreach(_.initContext(runCtx))
     runPhases(using runCtx)
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
     while (finalizeActions.nonEmpty) {

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

@@ -83,6 +83,7 @@ object Contexts {
 
   inline def currentPhaseId(using ctx: Context): Int = ctx.period.phaseId
 
+  def currentlyAfterTyper(using Context): Boolean = ctx.base.isAfterTyper(currentPhase)
 
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
@@ -784,7 +785,7 @@ object Contexts {
     private[dotc] var phases: Array[Phase] = _
 
     /** Phases with consecutive Transforms grouped into a single phase, Empty array if squashing is disabled */
-    private[core] var squashedPhases: Array[Phase] = Array.empty[Phase]
+    private[core] var fusedPhases: Array[Phase] = Array.empty[Phase]
 
     /** Next denotation transformer id */
     private[core] var nextDenotTransformerId: Array[Int] = _

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

@@ -1,7 +1,7 @@
 package dotty.tools.dotc.core
 
 import Contexts._
-import Phases.curPhases
+import Phases.unfusedPhases
 
 object Periods {
 
@@ -22,8 +22,8 @@ object Periods {
     val period = currentPeriod
     period == p ||
     period.runId == p.runId &&
-      curPhases(period.phaseId).sameBaseTypesStartId ==
-      curPhases(p.phaseId).sameBaseTypesStartId
+      unfusedPhases(period.phaseId).sameBaseTypesStartId ==
+      unfusedPhases(p.phaseId).sameBaseTypesStartId
 
   /** A period is a contiguous sequence of phase ids in some run.
    *  It is coded as follows:

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

@@ -27,13 +27,11 @@ object Phases {
   inline def phaseOf(id: PhaseId)(using Context): Phase =
     ctx.base.phases(id)
 
-  def currentlyAfterTyper(using Context): Boolean = ctx.base.isAfterTyper(currentPhase)
-
   trait PhasesBase {
     this: ContextBase =>
 
     // drop NoPhase at beginning
-    def allPhases: Array[Phase] = (if (squashedPhases.nonEmpty) squashedPhases else phases).tail
+    def allPhases: Array[Phase] = (if (fusedPhases.nonEmpty) fusedPhases else phases).tail
 
     object NoPhase extends Phase {
       override def exists: Boolean = false
@@ -63,12 +61,12 @@ object Phases {
       * Each TreeTransform gets own period,
       * whereas a combined TreeTransformer gets period equal to union of periods of it's TreeTransforms
       */
-    final def squashPhases(phasess: List[List[Phase]],
+    final def fusePhases(phasess: List[List[Phase]],
                            phasesToSkip: List[String],
                            stopBeforePhases: List[String],
                            stopAfterPhases: List[String],
                            YCheckAfter: List[String])(using Context): List[Phase] = {
-      val squashedPhases = ListBuffer[Phase]()
+      val fusedPhases = ListBuffer[Phase]()
       var prevPhases: Set[String] = Set.empty
       val YCheckAll = YCheckAfter.contains("all")
 
@@ -111,17 +109,17 @@ object Phases {
               prevPhases += phase.phaseName
               phase
             }
-          squashedPhases += phaseToAdd
+          fusedPhases += phaseToAdd
           val shouldAddYCheck = YCheckAfter.containsPhase(phaseToAdd) || YCheckAll
           if (shouldAddYCheck) {
             val checker = new TreeChecker
-            squashedPhases += checker
+            fusedPhases += checker
           }
         }
 
         i += 1
       }
-      squashedPhases.toList
+      fusedPhases.toList
     }
 
     /** Use the following phases in the order they are given.
@@ -192,9 +190,9 @@ object Phases {
       }
 
       if (squash)
-        this.squashedPhases = (NoPhase :: phasess).toArray
+        this.fusedPhases = (NoPhase :: phasess).toArray
       else
-        this.squashedPhases = this.phases
+        this.fusedPhases = this.phases
 
       config.println(s"Phases = ${phases.toList}")
       config.println(s"nextDenotTransformerId = ${nextDenotTransformerId.toList}")
@@ -421,7 +419,7 @@ object Phases {
   def flattenPhase(using Context): Phase                = ctx.base.flattenPhase
   def genBCodePhase(using Context): Phase               = ctx.base.genBCodePhase
 
-  def curPhases(using Context): Array[Phase] = ctx.base.phases
+  def unfusedPhases(using Context): Array[Phase] = ctx.base.phases
 
   /** Replace all instances of `oldPhaseClass` in `current` phases
    *  by the result of `newPhases` applied to the old phase.

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

@@ -4,8 +4,8 @@ package core
 
 import Periods._, Contexts._, Symbols._, Denotations._, Names._, NameOps._, Annotations._
 import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._
-import NameOps._, NameKinds._, Phases._
-import Phases.typerPhase
+import NameOps._, NameKinds._
+import Phases.{Phase, typerPhase, unfusedPhases}
 import Constants.Constant
 import TypeApplications.TypeParamInfo
 import Scopes.Scope
@@ -2577,8 +2577,8 @@ object SymDenotations {
     def isValidAt(phase: Phase)(using Context) =
       checkedPeriod == currentPeriod ||
         createdAt.runId == currentRunId &&
-        createdAt.phaseId < curPhases.length &&
-        sameGroup(curPhases(createdAt.phaseId), phase) &&
+        createdAt.phaseId < unfusedPhases.length &&
+        sameGroup(unfusedPhases(createdAt.phaseId), phase) &&
         { checkedPeriod = currentPeriod; true }
   }
 

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

@@ -3,7 +3,8 @@ package dotc
 package core
 
 import Types._, Contexts._, Symbols._, Flags._, Names._, NameOps._, Denotations._
-import Decorators._, Phases._
+import Decorators._
+import Phases.gettersPhase
 import StdNames.nme
 import TypeOps.refineUsingParent
 import collection.mutable

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

@@ -9,7 +9,6 @@ import util.Stats.record
 import util.{SourcePosition, NoSourcePosition, SourceFile}
 import Trees.Untyped
 import Contexts._
-import Phases.currentlyAfterTyper
 import Flags._
 import Symbols._
 import Denotations.Denotation

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

@@ -18,7 +18,7 @@ import CheckRealizable._
 import ErrorReporting.errorTree
 import rewrites.Rewrites.patch
 import util.Spans.Span
-import Phases.{refchecksPhase, currentlyAfterTyper}
+import Phases.refchecksPhase
 
 import util.SourcePosition
 import util.Spans.Span

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

@@ -10,7 +10,6 @@ import Flags._
 import Symbols._
 import Names._
 import StdNames._
-import Phases.currentlyAfterTyper
 import NameKinds.UniqueName
 import util.Spans._
 import collection.mutable

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

@@ -24,7 +24,6 @@ import Constants._
 import ProtoTypes._
 import ErrorReporting._
 import reporting.Message
-import Phases.currentlyAfterTyper
 import Inferencing.{fullyDefinedType, isFullyDefined}
 import Trees._
 import transform.SymUtils._

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

@@ -20,7 +20,6 @@ import config.{Config, Feature}
 import config.Printers.typr
 import Annotations._
 import Inferencing._
-import Phases.currentlyAfterTyper
 import transform.ValueClasses._
 import transform.TypeUtils._
 import transform.SymUtils._

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

@@ -12,12 +12,11 @@ import Types._
 import Decorators._
 import NameKinds._
 import StdNames.nme
-import Contexts.{Context, ctx}
+import Contexts._
 import Names.Name
 import NameKinds.{InlineAccessorName, UniqueInlineName}
 import NameOps._
 import Annotations._
-import Phases.currentlyAfterTyper
 import transform.{AccessProxies, PCPCheckAndHeal, Splicer, TreeMapWithStages}
 import config.Printers.inlining
 import util.{Property, SourcePosition}

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

@@ -8,7 +8,6 @@ import Symbols._
 import StdNames._
 import Decorators._
 import typer.ProtoTypes._
-import Phases.currentlyAfterTyper
 import ast.{tpd, untpd, Trees}
 import Trees._
 import scala.util.control.NonFatal

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

@@ -25,7 +25,6 @@ import Decorators.{given _}
 import ErrorReporting._
 import Checking._
 import Inferencing._
-import Phases.currentlyAfterTyper
 import EtaExpansion.etaExpand
 import util.Spans._
 import util.common._

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -5,7 +5,7 @@ import java.io.{File => JFile, PrintStream}
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.ast.{tpd, untpd}
 import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Phases.{curPhases, typerPhase}
+import dotty.tools.dotc.core.Phases.{unfusedPhases, typerPhase}
 import dotty.tools.dotc.core.Denotations.Denotation
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Mode
@@ -223,7 +223,7 @@ class ReplDriver(settings: Array[String],
     }
 
     def extractTopLevelImports(ctx: Context): List[tpd.Import] =
-      curPhases(using ctx).collectFirst { case phase: CollectTopLevelImports => phase.imports }.get
+      unfusedPhases(using ctx).collectFirst { case phase: CollectTopLevelImports => phase.imports }.get
 
     implicit val state = {
       val state0 = newRun(istate)