Use atPhase instead of passing ctx.withPhase

odersky · odersky · commit 165b7d8390d3 · 2020-07-10T17:43:04.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -833,7 +833,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           def traverse(tree: Tree)(using Context) = tree match {
             case tree: DefTree =>
               val sym = tree.symbol
-              val prevDenot = sym.denot(using ctx.withPhase(trans))
+              val prevDenot = atPhase(trans)(sym.denot)
               if (prevDenot.effectiveOwner == from.skipWeakOwner) {
                 val d = sym.copySymDenotation(owner = to)
                 d.installAfter(trans)
@@ -847,7 +847,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         traverser.traverse(tree)
         tree
       }
-      else changeOwnerAfter(from, to, trans)(using ctx.withPhase(trans.next))
+      else atPhase(trans.next)(changeOwnerAfter(from, to, trans))
 
     /** A select node with the given selector name and a computed type */
     def select(name: Name)(using Context): Select =
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1285,7 +1285,7 @@ class Definitions {
   object ContextFunctionType:
     def unapply(tp: Type)(using Context): Option[(List[Type], Type, Boolean)] =
       if ctx.erasedTypes then
-        unapply(tp)(using ctx.withPhase(erasurePhase))
+        atPhase(erasurePhase)(unapply(tp))
       else
         val tp1 = tp.dealias
         if isContextFunctionClass(tp1.typeSymbol) then
diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -3,7 +3,7 @@ package dotc
 package core
 
 import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation, LazyType }
-import Contexts.{Context, ctx, ContextBase}
+import Contexts._
 import Names._
 import NameKinds._
 import StdNames._
@@ -797,7 +797,7 @@ object Denotations {
               val transformer = ctx.base.denotTransformers(nextTransformerId)
               //println(s"transforming $this with $transformer")
               try
-                next = transformer.transform(cur)(using ctx.withPhase(transformer))
+                next = atPhase(transformer)(transformer.transform(cur))
               catch {
                 case ex: CyclicReference =>
                   println(s"error while transforming $this") // DEBUG
@@ -834,7 +834,7 @@ object Denotations {
             // 10 times. Best out of 10: 18154ms with `prev` field, 17777ms without.
             cnt += 1
             if (cnt > MaxPossiblePhaseId)
-              return current(using ctx.withPhase(coveredInterval.firstPhaseId))
+              return atPhase(coveredInterval.firstPhaseId)(current)
           }
           cur
         }
@@ -851,7 +851,7 @@ object Denotations {
      */
     protected def installAfter(phase: DenotTransformer)(using Context): Unit = {
       val targetId = phase.next.id
-      if (ctx.phaseId != targetId) installAfter(phase)(using ctx.withPhase(phase.next))
+      if (ctx.phaseId != targetId) atPhase(phase.next)(installAfter(phase))
       else {
         val current = symbol.current
         // println(s"installing $this after $phase/${phase.id}, valid = ${current.validFor}")
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -243,7 +243,7 @@ object SymDenotations {
         myFlags |= Touched
 
         // completions.println(s"completing ${this.debugString}")
-        try completer.complete(this)(using ctx.withPhase(validFor.firstPhaseId))
+        try atPhase(validFor.firstPhaseId)(completer.complete(this))
         catch {
           case ex: CyclicReference =>
             println(s"error while completing ${this.debugString}")
@@ -257,7 +257,7 @@ object SymDenotations {
       else {
         if (myFlags.is(Touched)) throw CyclicReference(this)
         myFlags |= Touched
-        completer.complete(this)(using ctx.withPhase(validFor.firstPhaseId))
+        atPhase(validFor.firstPhaseId)(completer.complete(this))
       }
 
     protected[dotc] def info_=(tp: Type): Unit = {
@@ -847,13 +847,12 @@ object SymDenotations {
       isClass && derivesFrom(defn.JavaSerializableClass)
 
     /** Is this symbol a class that extends `AnyVal`? */
-    final def isValueClass(using Context): Boolean = {
+    final def isValueClass(using Context): Boolean =
       val di = initial
-      di.isClass &&
-      di.derivesFrom(defn.AnyValClass)(using ctx.withPhase(di.validFor.firstPhaseId))
+      di.isClass
+      && atPhase(di.validFor.firstPhaseId)(di.derivesFrom(defn.AnyValClass))
         // We call derivesFrom at the initial phase both because AnyVal does not exist
         // after Erasure and to avoid cyclic references caused by forcing denotations
-    }
 
     /** Is this symbol a class of which `null` is a value? */
     final def isNullableClass(using Context): Boolean =
@@ -2200,7 +2199,7 @@ object SymDenotations {
      *  `phase.next`, install a new denotation with a cloned scope in `phase.next`.
      */
     def ensureFreshScopeAfter(phase: DenotTransformer)(using Context): Unit =
-      if (ctx.phaseId != phase.next.id) ensureFreshScopeAfter(phase)(using ctx.withPhase(phase.next))
+      if (ctx.phaseId != phase.next.id) atPhase(phase.next)(ensureFreshScopeAfter(phase))
       else {
         val prevClassInfo = atPhase(phase) {
           current.asInstanceOf[ClassDenotation].classInfo
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -585,7 +585,7 @@ object Symbols {
      */
     def enteredAfter(phase: DenotTransformer)(using Context): this.type =
       if ctx.phaseId != phase.next.id then
-        enteredAfter(phase)(using ctx.withPhase(phase.next))
+        atPhase(phase.next)(enteredAfter(phase))
       else this.owner match {
         case owner: ClassSymbol =>
           if (owner.is(Package)) {
@@ -610,7 +610,7 @@ object Symbols {
      */
     def dropAfter(phase: DenotTransformer)(using Context): Unit =
       if ctx.phaseId != phase.next.id then
-        dropAfter(phase)(using ctx.withPhase(phase.next))
+        atPhase(phase.next)(dropAfter(phase))
       else {
         assert (!this.owner.is(Package))
         this.owner.asClass.ensureFreshScopeAfter(phase)
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -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 computeSignature(using ctx.withPhase(erasurePhase))
+      else if ctx.erasedTypes 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 currentSignature(using ctx.withPhase(erasurePhase))
+        else if ctx.erasedTypes then atPhase(erasurePhase)(currentSignature)
         else
           val sym = currentSymbol
           if sym.exists then sym.asSeenFrom(prefix).signature
@@ -2053,7 +2053,7 @@ object Types {
         d = memberDenot(prefix, name, true)
       if (!d.exists && ctx.phaseId > FirstPhaseId && lastDenotation.isInstanceOf[SymDenotation])
         // name has changed; try load in earlier phase and make current
-        d = memberDenot(name, allowPrivate)(using ctx.withPhase(ctx.phaseId - 1)).current
+        d = atPhase(ctx.phaseId - 1)(memberDenot(name, allowPrivate)).current
       if (d.isOverloaded)
         d = disambiguate(d)
       d
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -940,7 +940,7 @@ class ClassfileParser(
       val outerName = entry.outerName.stripModuleClassSuffix
       val innerName = entry.originalName
       val owner = classNameToSymbol(outerName)
-      val result = getMember(owner, innerName.toTypeName)(using ctx.withPhase(typerPhase))
+      val result = atPhase(typerPhase)(getMember(owner, innerName.toTypeName))
       assert(result ne NoSymbol,
         i"""failure to resolve inner class:
            |externalName = ${entry.externalName},
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -986,7 +986,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     val atp = readTypeRef()
     val phase = ctx.phase
     Annotation.deferred(atp.typeSymbol)(
-        atReadPos(start, () => readAnnotationContents(end)(using ctx.withPhase(phase))))
+        atReadPos(start, () => atPhase(phase)(readAnnotationContents(end))))
   }
 
   /* Read an abstract syntax tree */
diff --git a/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala b/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala
@@ -75,8 +75,9 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   }
 
   override def prepareForUnit(tree: Tree)(using Context): Context = {
-    val captured = (new CollectCaptured)
-      .runOver(ctx.compilationUnit.tpdTree)(using ctx.withPhase(thisPhase))
+    val captured = atPhase(thisPhase) {
+      CollectCaptured().runOver(ctx.compilationUnit.tpdTree)
+    }
     ctx.fresh.updateStore(Captured, captured)
   }
 
@@ -91,9 +92,9 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   }
 
   override def prepareForValDef(vdef: ValDef)(using Context): Context = {
-    val sym = vdef.symbol(using ctx.withPhase(thisPhase))
+    val sym = atPhase(thisPhase)(vdef.symbol)
     if (captured contains sym) {
-      val newd = sym.denot(using ctx.withPhase(thisPhase)).copySymDenotation(
+      val newd = atPhase(thisPhase)(sym.denot).copySymDenotation(
         info = refClass(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef,
         initFlags = sym.flags &~ Mutable)
       newd.removeAnnotation(defn.VolatileAnnot)
@@ -117,7 +118,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def transformIdent(id: Ident)(using Context): Tree = {
     val vble = id.symbol
     if (captured.contains(vble))
-      id.select(nme.elem).ensureConforms(vble.denot(using ctx.withPhase(thisPhase)).info)
+      id.select(nme.elem).ensureConforms(atPhase(thisPhase)(vble.denot).info)
     else id
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -717,7 +717,9 @@ object Erasure {
       }
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree = {
-      val ntree = interceptTypeApply(tree.asInstanceOf[TypeApply])(using ctx.withPhase(erasurePhase)).withSpan(tree.span)
+      val ntree = atPhase(erasurePhase)(
+        interceptTypeApply(tree.asInstanceOf[TypeApply])
+      ).withSpan(tree.span)
 
       ntree match {
         case TypeApply(fun, args) =>
@@ -953,7 +955,7 @@ object Erasure {
         if ctx.phase != erasurePhase && ctx.phase != erasurePhase.next then
           // this can happen when reading annotations loaded during erasure,
           // since these are loaded at phase typer.
-          adapt(tree, pt, locked)(using ctx.withPhase(erasurePhase.next))
+          atPhase(erasurePhase.next)(adapt(tree, pt, locked))
         else if (tree.isEmpty) tree
         else if (ctx.mode is Mode.Pattern) tree // TODO: replace with assertion once pattern matcher is active
         else adaptToType(tree, pt)
diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -117,7 +117,7 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
         case ClassInfo(pre, cls, _, _, _) if cls is ModuleClass =>
           cls.linkedClass match {
             case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
-              val info1 = cls.denot(using ctx.withPhase(ctx.phase.next)).asClass.classInfo.derivedClassInfo(prefix = pre)
+              val info1 = atPhase(ctx.phase.next)(cls.denot).asClass.classInfo.derivedClassInfo(prefix = pre)
               ref.derivedSingleDenotation(ref.symbol, info1)
             case _ => ref
           }
@@ -135,7 +135,7 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
       (imeth.flags | Final) &~ (Override | Protected | AbsOverride),
       fullyParameterizedType(imeth.info, imeth.owner.asClass),
       privateWithin = imeth.privateWithin, coord = imeth.coord)
-    extensionMeth.addAnnotations(imeth.annotations)(using ctx.withPhase(thisPhase))
+    atPhase(thisPhase)(extensionMeth.addAnnotations(imeth.annotations))
       // need to change phase to add tailrec annotation which gets removed from original method in the same phase.
     extensionMeth
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -9,7 +9,7 @@ import ast.untpd
 import Flags._
 import Types._
 import Constants.Constant
-import Contexts.{Context, ctx}
+import Contexts._
 import Symbols._
 import Decorators._
 import scala.collection.mutable
@@ -129,7 +129,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   }
 
   override def transformStats(trees: List[Tree])(using Context): List[Tree] =
-    ast.Trees.flatten(reorderAndComplete(trees)(using ctx.withPhase(thisPhase.next)))
+    ast.Trees.flatten(atPhase(thisPhase.next)(reorderAndComplete(trees)))
 
   private object collectBinders extends TreeAccumulator[List[Ident]] {
     def apply(annots: List[Ident], t: Tree)(using Context): List[Ident] = t match {
diff --git a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
@@ -35,7 +35,7 @@ object GenericSignatures {
   def javaSig(sym0: Symbol, info: Type)(using Context): Option[String] =
     // Avoid generating a signature for local symbols.
     if (sym0.isLocal) None
-    else javaSig0(sym0, info)(using ctx.withPhase(erasurePhase))
+    else atPhase(erasurePhase)(javaSig0(sym0, info))
 
   @noinline
   private final def javaSig0(sym0: Symbol, info: Type)(using Context): Option[String] = {
diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
@@ -374,8 +374,10 @@ object LambdaLift {
       (new CollectDependencies).traverse(ctx.compilationUnit.tpdTree)
       computeFreeVars()
       computeLiftedOwners()
-      generateProxies()(using ctx.withPhase(thisPhase.next))
-      liftLocals()(using ctx.withPhase(thisPhase.next))
+    }
+    atPhase(thisPhase.next) {
+      generateProxies()
+      liftLocals()
     }
 
     def currentEnclosure(using Context): Symbol =
@@ -421,7 +423,7 @@ object LambdaLift {
     }
 
     def proxyRef(sym: Symbol)(using Context): Tree = {
-      val psym = proxy(sym)(using ctx.withPhase(thisPhase))
+      val psym = atPhase(thisPhase)(proxy(sym))
       thisPhase.transformFollowingDeep(if (psym.owner.isTerm) ref(psym) else memberRef(psym))
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala b/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
@@ -18,7 +18,7 @@ abstract class MacroTransform extends Phase {
 
   override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
-    unit.tpdTree = newTransformer.transform(unit.tpdTree)(using ctx.withPhase(transformPhase))
+    unit.tpdTree = atPhase(transformPhase)(newTransformer.transform(unit.tpdTree))
   }
 
   protected def newTransformer(using Context): Transformer
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -424,7 +424,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
 
   override def run(using Context): Unit =
     ctx.compilationUnit.tpdTree =
-      transformUnit(ctx.compilationUnit.tpdTree)(using ctx.withPhase(miniPhases.last.next))
+      atPhase(miniPhases.last.next)(transformUnit(ctx.compilationUnit.tpdTree))
 
   // Initialization code
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
@@ -56,7 +56,7 @@ class ParamForwarding extends MiniPhase with IdentityDenotTransformer:
     val sym = mdef.symbol.asTerm
     if sym.is(SuperParamAlias) then
       assert(sym.is(ParamAccessor, butNot = Mutable))
-      val alias = inheritedAccessor(sym)(using ctx.withPhase(thisPhase))
+      val alias = atPhase(thisPhase)(inheritedAccessor(sym))
       if alias.exists then
         sym.copySymDenotation(
             name = ParamAccessorName(sym.name),
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -147,7 +147,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     }
     if (name.isTermName && mix.name.isEmpty &&
         (clazz.is(Trait) || clazz != ctx.owner.enclosingClass || !validCurrentClass))
-      superAccessorCall(sel)(using ctx.withPhase(thisPhase.next))
+      atPhase(thisPhase.next)(superAccessorCall(sel))
     else sel
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala b/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
@@ -23,7 +23,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
 
   /** The info of the tree's symbol before it is potentially transformed in this phase */
   private def originalDenotation(tree: Tree)(using Context) =
-    tree.symbol.denot(using ctx.withPhase(thisPhase))
+    atPhase(thisPhase)(tree.symbol.denot)
 
   /** If denotation had an ExprType before, it now gets a function type */
   protected def exprBecomesFunction(symd: SymDenotation)(using Context): Boolean =

Original file line number	Diff line number	Diff line change
`@@ -986,7 +986,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas`
`986`	`986`	`val atp = readTypeRef()`
`987`	`987`	`val phase = ctx.phase`
`988`	`988`	`Annotation.deferred(atp.typeSymbol)(`
`989`		`- atReadPos(start, () => readAnnotationContents(end)(using ctx.withPhase(phase))))`
	`989`	`+ atReadPos(start, () => atPhase(phase)(readAnnotationContents(end))))`
`990`	`990`	`}`
`991`	`991`
`992`	`992`	`/* Read an abstract syntax tree */`