Move individual phases to Phases

Author: odersky

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -20,6 +20,7 @@ import dotty.tools.dotc.transform.Erasure
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.core.Contexts.{inContext, atPhase}
+import dotty.tools.dotc.core.Phases._
 
 /*
  *
@@ -1461,7 +1462,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       // TODO specialization
       val constrainedType = new MethodBType(lambdaParamTypes.map(p => toTypeKind(p)), toTypeKind(lambdaTarget.info.resultType)).toASMType
 
-      val abstractMethod = atPhase(ctx.erasurePhase) {
+      val abstractMethod = atPhase(erasurePhase) {
         val samMethods = toDenot(functionalInterface).info.possibleSamMethods.toList
         samMethods match {
           case x :: Nil => x.symbol

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -14,6 +14,7 @@ import dotty.tools.dotc.ast.Trees
 import dotty.tools.dotc.core.Annotations._
 import dotty.tools.dotc.core.Constants._
 import dotty.tools.dotc.core.Contexts.{Context, atPhase}
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Names.Name
@@ -360,7 +361,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       val narg = normalizeArgument(arg)
       // Transformation phases are not run on annotation trees, so we need to run
       // `constToLiteral` at this point.
-      val t = constToLiteral(narg)(using ctx.withPhase(ctx.erasurePhase))
+      val t = atPhase(erasurePhase)(constToLiteral(narg))
       t match {
         case Literal(const @ Constant(_)) =>
           const.tag match {
@@ -478,7 +479,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
      */
     def getGenericSignature(sym: Symbol, owner: Symbol): String = {
-      atPhase(ctx.erasurePhase) {
+      atPhase(erasurePhase) {
         val memberTpe =
           if (sym.is(Method)) sym.denot.info
           else owner.denot.thisType.memberInfo(sym)
@@ -913,7 +914,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
     // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
 
-    val memberTpe = atPhase(ctx.erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
+    val memberTpe = atPhase(erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
     val erasedMemberType = TypeErasure.erasure(memberTpe)
     if (erasedMemberType =:= sym.denot.info)
       getGenericSignatureHelper(sym, moduleClass, memberTpe).orNull

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -9,6 +9,7 @@ import scala.collection.generic.Clearable
 
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Contexts.{inContext, atPhase}
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform.SymUtils._
@@ -203,12 +204,12 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
   /** For currently compiled classes: All locally defined classes including local classes.
    *  The empty list for classes that are not currently compiled.
    */
-  private def getNestedClasses(sym: Symbol): List[Symbol] = definedClasses(sym, ctx.flattenPhase)
+  private def getNestedClasses(sym: Symbol): List[Symbol] = definedClasses(sym, flattenPhase)
 
   /** For currently compiled classes: All classes that are declared as members of this class
    *  (but not inherited ones). The empty list for classes that are not currently compiled.
    */
-  private def getMemberClasses(sym: Symbol): List[Symbol] = definedClasses(sym, ctx.lambdaLiftPhase)
+  private def getMemberClasses(sym: Symbol): List[Symbol] = definedClasses(sym, lambdaLiftPhase)
 
   private def definedClasses(sym: Symbol, phase: Phase) =
     if (sym.isDefinedInCurrentRun)
@@ -229,11 +230,11 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
       // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
       val enclosingClassSym = {
         if (innerClassSym.isClass) {
-          atPhase(ctx.flattenPhase.prev) {
+          atPhase(flattenPhase.prev) {
             toDenot(innerClassSym).owner.enclosingClass
           }
         }
-        else innerClassSym.enclosingClass(using ctx.withPhase(ctx.flattenPhase.prev))
+        else atPhase(flattenPhase.prev)(innerClassSym.enclosingClass)
       } //todo is handled specially for JavaDefined symbols in scalac
 
       val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym)
@@ -257,7 +258,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
         if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None
         else {
           val original = innerClassSym.initial
-          Some(innerClassSym.name(using ctx.withPhase(original.validFor.phaseId)).mangledString) // moduleSuffix for module classes
+          Some(atPhase(original.validFor.phaseId)(innerClassSym.name).mangledString) // moduleSuffix for module classes
         }
       }
 

compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala

@@ -2,6 +2,7 @@ package dotty.tools.backend.jvm
 
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.{Context, ctx}
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Flags.Trait
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
@@ -32,7 +33,7 @@ class CollectSuperCalls extends MiniPhase {
   }
 
   private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Context) = {
-    ctx.genBCodePhase match {
+    genBCodePhase match {
       case genBCodePhase: GenBCode =>
         genBCodePhase.registerSuperCall(sym, calls)
       case _ =>

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -160,7 +160,7 @@ object DottyBackendInterface {
      */
     def isTopLevelModuleClass(using Context): Boolean =
       sym.is(ModuleClass) &&
-      atPhase(ctx.flattenPhase) {
+      atPhase(flattenPhase) {
         toDenot(sym).owner.is(PackageClass)
       }
 

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -15,6 +15,7 @@ import java.util.Optional
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.sbt.ExtractDependencies
 import Contexts._
+import Phases._
 import Symbols._
 import Decorators._
 
@@ -166,7 +167,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using ctx: Context) exten
             if (classSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (classSymbol, dupClassSym)
             else (dupClassSym, classSymbol)
           val same = classSymbol.effectiveName.toString == dupClassSym.effectiveName.toString
-          atPhase(ctx.typerPhase) {
+          atPhase(typerPhase) {
             if (same)
               summon[Context].warning( // FIXME: This should really be an error, but then FromTasty tests fail
                 s"${cl1.show} and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
@@ -271,7 +272,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using ctx: Context) exten
 
       // ----------- compiler and sbt's callbacks
 
-      val (fullClassName, isLocal) = atPhase(ctx.sbtExtractDependenciesPhase) {
+      val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
         (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
       }
 

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -2121,7 +2121,7 @@ class JSCodeGen()(using genCtx: Context) {
     if (isStat) {
       boxedResult
     } else {
-      val tpe = atPhase(ctx.elimErasedValueTypePhase) {
+      val tpe = atPhase(elimErasedValueTypePhase) {
         sym.info.finalResultType
       }
       unbox(boxedResult, tpe)
@@ -2735,14 +2735,14 @@ class JSCodeGen()(using genCtx: Context) {
     def paramNamesAndTypes(using Context): List[(Names.TermName, Type)] =
       sym.info.paramNamess.flatten.zip(sym.info.paramInfoss.flatten)
 
-    val wereRepeated = atPhase(ctx.elimRepeatedPhase) {
+    val wereRepeated = atPhase(elimRepeatedPhase) {
       val list =
         for ((name, tpe) <- paramNamesAndTypes)
         yield (name -> tpe.isRepeatedParam)
       list.toMap
     }
 
-    val paramTypes = atPhase(ctx.elimErasedValueTypePhase) {
+    val paramTypes = atPhase(elimErasedValueTypePhase) {
       paramNamesAndTypes.toMap
     }
 

compiler/src/dotty/tools/backend/sjs/JSInterop.scala

@@ -6,6 +6,7 @@ import Flags._
 import Symbols._
 import NameOps._
 import StdNames._
+import Phases._
 import NameKinds.DefaultGetterName
 
 import JSDefinitions._
@@ -16,7 +17,7 @@ object JSInterop {
   /** Is this symbol a JavaScript type? */
   def isJSType(sym: Symbol)(using Context): Boolean = {
     //sym.hasAnnotation(jsdefn.RawJSTypeAnnot)
-    atPhase(ctx.erasurePhase) {
+    atPhase(erasurePhase) {
       sym.derivesFrom(jsdefn.JSAnyClass)
     }
   }
@@ -32,7 +33,7 @@ object JSInterop {
    *  much as *accessor* methods created for `val`s and `var`s.
    */
   def isJSGetter(sym: Symbol)(using Context): Boolean = {
-    sym.info.firstParamTypes.isEmpty && atPhase(ctx.erasurePhase) {
+    sym.info.firstParamTypes.isEmpty && atPhase(erasurePhase) {
       sym.info.isParameterless
     }
   }

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

@@ -4,7 +4,7 @@ package ast
 
 import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
-import Symbols._, StdNames._, Trees._
+import Symbols._, StdNames._, Trees._, Phases._
 import Decorators.{given _}, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.{FrontEnd, Namer}
@@ -1402,7 +1402,7 @@ object desugar {
    */
   def makeAnnotated(fullName: String, tree: Tree)(using Context): Annotated = {
     val parts = fullName.split('.')
-    val ttree = ctx.typerPhase match {
+    val ttree = typerPhase match {
       case phase: FrontEnd if phase.stillToBeEntered(parts.last) =>
         val prefix =
           parts.init.foldLeft(Ident(nme.ROOTPKG): Tree)((qual, name) =>

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -3,7 +3,7 @@ package dotc
 package config
 
 import core._
-import Contexts._, Symbols._, Names._, NameOps._
+import Contexts._, Symbols._, Names._, NameOps._, Phases._
 import StdNames.nme
 import Decorators.{given _}
 import util.SourcePosition
@@ -36,7 +36,7 @@ object Feature:
    *       import owner.{ feature => _ }
    */
   def enabledByImport(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
-    atPhase(ctx.typerPhase) {
+    atPhase(typerPhase) {
       ctx.importInfo != null
       && ctx.importInfo.featureImported(feature,
           if owner.exists then owner else defn.LanguageModule.moduleClass)