Rename ctx.erasedTypes -> Phases.currentlyAfterErasure

Author: odersky

community-build/community-projects/dotty-cps-async

@@ -13,7 +13,7 @@ import Decorators.{given _}, DenotTransformers._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
-import Phases.currentPhase
+import Phases.{currentPhase, currentlyAfterErasure}
 import typer.ConstFold
 
 import scala.annotation.tailrec
@@ -415,7 +415,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ref(NamedType(sym.owner.thisType, sym.name, sym.denot))
 
   private def followOuterLinks(t: Tree)(using Context) = t match {
-    case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
+    case t: This if currentlyAfterErasure && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
       // after erasure outer paths should be respected
       ExplicitOuter.OuterOps(ctx).path(toCls = t.tpe.widen.classSymbol)
     case t =>
@@ -459,7 +459,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def newArr =
       ref(defn.DottyArraysModule).select(defn.newArrayMethod).withSpan(span)
 
-    if (!ctx.erasedTypes) {
+    if (!currentlyAfterErasure) {
       assert(!TypeErasure.isGeneric(elemTpe), elemTpe) //needs to be done during typer. See Applications.convertNewGenericArray
       newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
     }
@@ -963,7 +963,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     /** cast tree to `tp`, assuming no exception is raised, i.e the operation is pure */
     def cast(tp: Type)(using Context): Tree = {
       assert(tp.isValueType, i"bad cast: $tree.asInstanceOf[$tp]")
-      tree.select(if (ctx.erasedTypes) defn.Any_asInstanceOf else defn.Any_typeCast)
+      tree.select(if (currentlyAfterErasure) defn.Any_asInstanceOf else defn.Any_typeCast)
         .appliedToType(tp)
     }
 
@@ -973,7 +973,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      */
     def ensureConforms(tp: Type)(using Context): Tree =
       if (tree.tpe <:< tp) tree
-      else if (!ctx.erasedTypes) cast(tp)
+      else if (!currentlyAfterErasure) cast(tp)
       else Erasure.Boxing.adaptToType(tree, tp)
 
     /** `tree ne null` (might need a cast to be type correct) */
@@ -1157,7 +1157,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** A tree that corresponds to `Predef.classOf[$tp]` in source */
   def clsOf(tp: Type)(using Context): Tree =
-    if ctx.erasedTypes then
+    if currentlyAfterErasure then
       def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_)
       defn.scalaClassName(tp) match
         case tpnme.Boolean => TYPE(defn.BoxedBooleanModule)

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

@@ -436,9 +436,6 @@ object Contexts {
       fresh.setImportInfo(ImportInfo(sym, imp.selectors, impNameOpt))
     }
 
-    /** Does current phase use an erased types interpretation? */
-    def erasedTypes: Boolean = currentPhase(using this).erasedTypes
-
     /** Is the debug option set? */
     def debug: Boolean = base.settings.Ydebug.value
 

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

@@ -905,7 +905,7 @@ class Definitions {
 
   object ArrayOf {
     def apply(elem: Type)(using Context): Type =
-      if (ctx.erasedTypes) JavaArrayType(elem)
+      if (currentlyAfterErasure) JavaArrayType(elem)
       else ArrayType.appliedTo(elem :: Nil)
     def unapply(tp: Type)(using Context): Option[Type] = tp.dealias match {
       case AppliedType(at, arg :: Nil) if at.isRef(ArrayType.symbol) => Some(arg)
@@ -1020,7 +1020,7 @@ class Definitions {
   @tu lazy val Function0_apply: Symbol = ImplementedFunctionType(0).symbol.requiredMethod(nme.apply)
 
   def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(using Context): TypeRef =
-    if (n <= MaxImplementedFunctionArity && (!isContextual || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
+    if (n <= MaxImplementedFunctionArity && (!isContextual || currentlyAfterErasure) && !isErased) ImplementedFunctionType(n)
     else FunctionClass(n, isContextual, isErased).typeRef
 
   lazy val PolyFunctionClass = requiredClass("scala.PolyFunction")
@@ -1285,7 +1285,7 @@ class Definitions {
    */
   object ContextFunctionType:
     def unapply(tp: Type)(using Context): Option[(List[Type], Type, Boolean)] =
-      if ctx.erasedTypes then
+      if currentlyAfterErasure then
         atPhase(erasurePhase)(unapply(tp))
       else
         val tp1 = tp.dealias

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

@@ -15,7 +15,7 @@ import Flags._
 import DenotTransformers._
 import Decorators._
 import Signature.MatchDegree._
-import Phases.currentPhase
+import Phases.{currentPhase, currentlyAfterErasure}
 import printing.Texts._
 import printing.Printer
 import io.AbstractFile
@@ -978,10 +978,10 @@ object Denotations {
           true
         case MethodNotAMethodMatch =>
           // Java allows defining both a field and a zero-parameter method with the same name
-          !ctx.erasedTypes && !(symbol.is(JavaDefined) && other.symbol.is(JavaDefined))
+          !currentlyAfterErasure && !(symbol.is(JavaDefined) && other.symbol.is(JavaDefined))
         case ParamMatch =>
            // The signatures do not tell us enough to be sure about matching
-          !ctx.erasedTypes && info.matches(other.info)
+          !currentlyAfterErasure && info.matches(other.info)
         case noMatch =>
           false
     end matches

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

@@ -31,6 +31,8 @@ object Phases {
 
   def currentlyAfterTyper(using Context): Boolean = ctx.base.isAfterTyper(currentPhase)
 
+  def currentlyAfterErasure(using Context): Boolean = currentPhase.erasedTypes
+
   trait PhasesBase {
     this: ContextBase =>
 

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

@@ -864,7 +864,7 @@ object SymDenotations {
     def membersNeedAsSeenFrom(pre: Type)(using Context): Boolean =
       !(  this.isTerm
        || this.isStaticOwner && !this.seesOpaques
-       || ctx.erasedTypes
+       || currentlyAfterErasure
        || (pre eq NoPrefix)
        || (pre eq thisType)
        )
@@ -877,7 +877,7 @@ object SymDenotations {
      *  Default parameters are recognized until erasure.
      */
     def hasDefaultParams(using Context): Boolean =
-      if ctx.erasedTypes then false
+      if currentlyAfterErasure then false
       else if is(HasDefaultParams) then true
       else if is(NoDefaultParams) then false
       else
@@ -1643,7 +1643,7 @@ object SymDenotations {
     override final def typeParams(using Context): List[TypeSymbol] = {
       if (myTypeParams == null)
         myTypeParams =
-          if (ctx.erasedTypes || is(Module)) Nil // fast return for modules to avoid scanning package decls
+          if (currentlyAfterErasure || is(Module)) Nil // fast return for modules to avoid scanning package decls
           else {
             val di = initial
             if (this ne di) di.typeParams
@@ -1731,7 +1731,7 @@ object SymDenotations {
 
     def computeBaseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
       def emptyParentsExpected =
-        is(Package) || (symbol == defn.AnyClass) || ctx.erasedTypes && (symbol == defn.ObjectClass)
+        is(Package) || (symbol == defn.AnyClass) || currentlyAfterErasure && (symbol == defn.ObjectClass)
       if (classParents.isEmpty && !emptyParentsExpected)
         onBehalf.signalProvisional()
       val builder = new BaseDataBuilder
@@ -1827,7 +1827,7 @@ object SymDenotations {
      */
     def ensureTypeParamsInCorrectOrder()(using Context): Unit = {
       val tparams = typeParams
-      if (!ctx.erasedTypes && !typeParamsFromDecls.corresponds(tparams)(_.name == _.name)) {
+      if (!currentlyAfterErasure && !typeParamsFromDecls.corresponds(tparams)(_.name == _.name)) {
         val decls = info.decls
         val decls1 = newScope
         for (tparam <- typeParams) decls1.enter(decls.lookup(tparam.name))

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

@@ -11,6 +11,7 @@ import util.Stats._
 import Names._
 import NameOps._
 import Flags.Module
+import Phases.currentlyAfterErasure
 import Variances.variancesConform
 import dotty.tools.dotc.config.Config
 
@@ -287,7 +288,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     val typParams = self.typeParams
     val stripped = self.stripTypeVar
     val dealiased = stripped.safeDealias
-    if (args.isEmpty || ctx.erasedTypes) self
+    if (args.isEmpty || currentlyAfterErasure) self
     else dealiased match {
       case dealiased: HKTypeLambda =>
         def tryReduce =

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

@@ -260,7 +260,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
                 // This is safe because X$ self-type is X.type
                 sym1 = sym1.companionModule
               if ((sym1 ne NoSymbol) && (sym1 eq sym2))
-                ctx.erasedTypes ||
+                currentlyAfterErasure ||
                 sym1.isStaticOwner ||
                 isSubPrefix(tp1.prefix, tp2.prefix) ||
                 thirdTryNamed(tp2)
@@ -1861,7 +1861,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   final def glb(tps: List[Type]): Type = tps.foldLeft(AnyType: Type)(glb)
 
   def widenInUnions(using Context): Boolean =
-    migrateTo3 || ctx.erasedTypes
+    migrateTo3 || currentlyAfterErasure
 
   /** The least upper bound of two types
    *  @param canConstrain  If true, new constraints might be added to simplify the lub.
@@ -2020,7 +2020,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     }
 
   private def andTypeGen(tp1: Type, tp2: Type, op: (Type, Type) => Type,
-      original: (Type, Type) => Type = _ & _, isErased: Boolean = ctx.erasedTypes): Type = trace(s"glb(${tp1.show}, ${tp2.show})", subtyping, show = true) {
+      original: (Type, Type) => Type = _ & _, isErased: Boolean = currentlyAfterErasure): Type = trace(s"glb(${tp1.show}, ${tp2.show})", subtyping, show = true) {
     val t1 = distributeAnd(tp1, tp2)
     if (t1.exists) t1
     else {
@@ -2048,7 +2048,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *  Finally, refined types with the same refined name are
    *  opportunistically merged.
    */
-  final def andType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type =
+  final def andType(tp1: Type, tp2: Type, isErased: Boolean = currentlyAfterErasure): Type =
     andTypeGen(tp1, tp2, AndType(_, _), isErased = isErased)
 
   final def simplifyAndTypeWithFallback(tp1: Type, tp2: Type, fallback: Type): Type =
@@ -2063,7 +2063,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *  @param isErased Apply erasure semantics. If erased is true, instead of creating
    *                  an OrType, the lub will be computed using TypeCreator#erasedLub.
    */
-  final def orType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type = {
+  final def orType(tp1: Type, tp2: Type, isErased: Boolean = currentlyAfterErasure): Type = {
     val t1 = distributeOr(tp1, tp2)
     if (t1.exists) t1
     else {

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

@@ -132,7 +132,7 @@ object TypeErasure {
 
   /** The current context with a phase no later than erasure */
   def preErasureCtx(using Context) =
-    if (ctx.erasedTypes) ctx.withPhase(erasurePhase) else ctx
+    if (currentlyAfterErasure) ctx.withPhase(erasurePhase) else ctx
 
   /** The standard erasure of a Scala type. Value classes are erased as normal classes.
    *
@@ -608,7 +608,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         else
           val cls = normalizeClass(sym.asClass)
           val fullName =
-            if !ctx.erasedTypes then
+            if !currentlyAfterErasure then
               // It's important to use the initial symbol to compute the full name
               // because the current symbol might have a different name or owner
               // and signatures are required to be stable before erasure.

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

@@ -10,7 +10,7 @@ import util.SourcePosition
 import NameKinds.DepParamName
 import Decorators._
 import StdNames._
-import Phases.currentPhase
+import Phases.{currentPhase, currentlyAfterErasure}
 import collection.mutable
 import ast.tpd._
 import reporting.{trace, Message}
@@ -193,7 +193,7 @@ object TypeOps:
         val accu1 = if (accu exists (_ derivesFrom c)) accu else c :: accu
         if (cs == c.baseClasses) accu1 else dominators(rest, accu1)
       case Nil => // this case can happen because after erasure we do not have a top class anymore
-        assert(ctx.erasedTypes || ctx.reporter.errorsReported)
+        assert(currentlyAfterErasure || ctx.reporter.errorsReported)
         defn.ObjectClass :: Nil
     }
 

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

@@ -1413,7 +1413,7 @@ object Types {
       TermRef(this, name, member(name))
 
     def select(name: TermName, sig: Signature)(using Context): TermRef =
-      TermRef(this, name, member(name).atSignature(sig, relaxed = !ctx.erasedTypes))
+      TermRef(this, name, member(name).atSignature(sig, relaxed = !currentlyAfterErasure))
 
 // ----- Access to parts --------------------------------------------
 
@@ -1601,8 +1601,8 @@ object Types {
     def toFunctionType(dropLast: Int = 0)(using Context): Type = this match {
       case mt: MethodType if !mt.isParamDependent =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
-        val isContextual = mt.isContextualMethod && !ctx.erasedTypes
-        val isErased = mt.isErasedMethod && !ctx.erasedTypes
+        val isContextual = mt.isContextualMethod && !currentlyAfterErasure
+        val isErased = mt.isErasedMethod && !currentlyAfterErasure
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType()
           case res => res
@@ -1904,7 +1904,7 @@ object Types {
     protected[dotc] def computeSignature(using Context): Signature =
       val lastd = lastDenotation
       if lastd != null then sigFromDenot(lastd)
-      else if ctx.erasedTypes then atPhase(erasurePhase)(computeSignature)
+      else if currentlyAfterErasure then atPhase(erasurePhase)(computeSignature)
       else symbol.asSeenFrom(prefix).signature
 
     /** The signature computed from the current denotation with `sigFromDenot` if it is
@@ -1918,7 +1918,7 @@ object Types {
       else
         val lastd = lastDenotation
         if lastd != null then sigFromDenot(lastd)
-        else if ctx.erasedTypes then atPhase(erasurePhase)(currentSignature)
+        else if currentlyAfterErasure then atPhase(erasurePhase)(currentSignature)
         else
           val sym = currentSymbol
           if sym.exists then sym.asSeenFrom(prefix).signature
@@ -1964,6 +1964,7 @@ object Types {
       case _ => if (denotationIsCurrent) lastDenotation.symbol else NoSymbol
     }
 
+
     /** Retrieves currently valid symbol without necessarily updating denotation.
      *  Assumes that symbols do not change between periods in the same run.
      *  Used to get the class underlying a ThisType.
@@ -2036,7 +2037,7 @@ object Types {
 
     private def disambiguate(d: Denotation, sig: Signature)(using Context): Denotation =
       if (sig != null)
-        d.atSignature(sig, relaxed = !ctx.erasedTypes) match {
+        d.atSignature(sig, relaxed = !currentlyAfterErasure) match {
           case d1: SingleDenotation => d1
           case d1 =>
             d1.atSignature(sig, relaxed = false) match {
@@ -2559,7 +2560,7 @@ object Types {
     }
 
     override def underlying(using Context): Type =
-      if (ctx.erasedTypes) tref
+      if (currentlyAfterErasure) tref
       else cls.info match {
         case cinfo: ClassInfo => cinfo.selfType
         case _: ErrorType | NoType if ctx.mode.is(Mode.Interactive) => cls.info
@@ -2727,7 +2728,7 @@ object Types {
       else make(RefinedType(parent, names.head, infos.head), names.tail, infos.tail)
 
     def apply(parent: Type, name: Name, info: Type)(using Context): RefinedType = {
-      assert(!ctx.erasedTypes)
+      assert(!currentlyAfterErasure)
       unique(new CachedRefinedType(parent, name, info)).checkInst
     }
   }
@@ -4378,7 +4379,7 @@ object Types {
           val givenSelf = clsd.givenSelfType
           if (!givenSelf.isValueType) appliedRef
           else if (clsd.is(Module)) givenSelf
-          else if (ctx.erasedTypes) appliedRef
+          else if (currentlyAfterErasure) appliedRef
           else AndType(givenSelf, appliedRef)
         }
       selfTypeCache

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

@@ -120,7 +120,7 @@ object ContextFunctionResults:
    *  @param `n` the select nodes seen in previous recursive iterations of this method
    */
   def integrateSelect(tree: untpd.Tree, n: Int = 0)(using Context): Boolean =
-    if ctx.erasedTypes then
+    if currentlyAfterErasure then
       atPhase(erasurePhase)(integrateSelect(tree, n))
     else tree match
       case Select(qual, name) =>

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

@@ -318,7 +318,7 @@ class TreeChecker extends Phase with SymTransformer {
     override def typed(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree = {
       val tpdTree = super.typed(tree, pt)
       Typer.assertPositioned(tree)
-      if (ctx.erasedTypes)
+      if (currentlyAfterErasure)
         // Can't be checked in earlier phases since `checkValue` is only run in
         // Erasure (because running it in Typer would force too much)
         checkIdentNotJavaClass(tpdTree)
@@ -384,7 +384,7 @@ class TreeChecker extends Phase with SymTransformer {
       val tpe = tree.typeOpt
       val sym = tree.symbol
       val symIsFixed = tpe match {
-        case tpe: TermRef => ctx.erasedTypes || !tpe.isMemberRef
+        case tpe: TermRef => currentlyAfterErasure || !tpe.isMemberRef
         case _ => false
       }
       if (sym.exists && !sym.is(Private) &&
@@ -455,7 +455,7 @@ class TreeChecker extends Phase with SymTransformer {
         (ddef.tparams :: ddef.vparamss).filter(!_.isEmpty).map(_.map(_.symbol))
       def layout(symss: List[List[Symbol]]): String =
         symss.map(syms => i"($syms%, %)").mkString
-      assert(ctx.erasedTypes || sym.rawParamss == defParamss,
+      assert(currentlyAfterErasure || sym.rawParamss == defParamss,
         i"""param mismatch for ${sym.showLocated}:
            |defined in tree  = ${layout(defParamss)}
            |stored in symbol = ${layout(sym.rawParamss)}""")