Eliminate more withPhase calls

Author: odersky

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

@@ -72,9 +72,12 @@ object Contexts {
   inline def atNextPhase[T](inline op: Context ?=> T)(using Context): T =
     atPhase(currentPhase.next)(op)
 
-  inline def atPhaseNotLaterThan[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
+  inline def atPhaseNoLater[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
     op(using if !limit.exists || currentPhase <= limit then ctx else ctx.withPhase(limit))
 
+  inline def atPhaseNoEarlier[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
+    op(using if !limit.exists || limit <= currentPhase then ctx else ctx.withPhase(limit))
+
   inline def currentPeriod(using ctx: Context): Period = ctx.period
 
   inline def currentPhase(using ctx: Context): Phase = ctx.base.phases(ctx.period.firstPhaseId)

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

@@ -431,7 +431,7 @@ object Symbols {
                 }
                 case none => NoSource
               }
-            sourceFromTopLevel(using ctx.withPhaseNoLater(flattenPhase))
+            atPhaseNoLater(flattenPhase)(sourceFromTopLevel)
           }
         }
       mySource

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -607,7 +607,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       }
       atReadPos(startCoord(denot).toIndex,
           () => withMode(Mode.Scala2Unpickling) {
-            atPhaseNotLaterThan(picklerPhase) {
+            atPhaseNoLater(picklerPhase) {
               parseToCompletion(denot)
             }
           })

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3,7 +3,7 @@ package dotc
 package reporting
 
 import core._
-import Contexts.{Context, ctx}
+import Contexts._
 import Decorators._, Symbols._, Names._, NameOps._, Types._, Flags._, Phases._
 import Denotations.SingleDenotation
 import SymDenotations.SymDenotation
@@ -2011,9 +2011,8 @@ import ast.tpd
             case NoMatch =>
               // If the signatures don't match at all at the current phase, then
               // they might match after erasure.
-              val elimErasedCtx = ctx.withPhaseNoEarlier(elimErasedValueTypePhase.next)
-              if (elimErasedCtx != ctx)
-                details(using elimErasedCtx)
+              if currentPhase.id <= elimErasedValueTypePhase.id then
+                atPhase(elimErasedValueTypePhase.next)(details)
               else
                 "" // shouldn't be reachable
             case ParamMatch =>

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

@@ -105,14 +105,13 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer { thisPhase =>
           !info1.matchesLoosely(info2) && !bothPolyApply)
         report.error(DoubleDefinition(sym1, sym2, root), root.sourcePos)
     }
-    val earlyCtx = ctx.withPhase(elimRepeatedPhase.next)
     while (opc.hasNext) {
       val sym1 = opc.overriding
       val sym2 = opc.overridden
       // Do the test at the earliest phase where both symbols existed.
       val phaseId =
         sym1.originDenotation.validFor.firstPhaseId max sym2.originDenotation.validFor.firstPhaseId
-      checkNoConflict(sym1, sym2, sym1.info)(using earlyCtx)
+      atPhase(elimRepeatedPhase.next)(checkNoConflict(sym1, sym2, sym1.info))
       opc.next()
     }
   }

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

@@ -174,7 +174,7 @@ object ExplicitOuter {
         outerThis.baseType(outerCls).orElse(
   		    outerCls.typeRef.appliedTo(outerCls.typeParams.map(_ => TypeBounds.empty)))
     val info = if (flags.is(Method)) ExprType(target) else target
-    inContext(ctx.withPhaseNoEarlier(explicitOuterPhase.next)) { // outer accessors are entered at explicitOuter + 1, should not be defined before.
+    atPhaseNoEarlier(explicitOuterPhase.next) { // outer accessors are entered at explicitOuter + 1, should not be defined before.
       newSymbol(owner, name, Synthetic | flags, info, coord = cls.coord)
     }
   }
@@ -300,7 +300,7 @@ object ExplicitOuter {
           else tpe.prefix
         case _ =>
           // Need to be careful to dealias before erasure, otherwise we lose prefixes.
-          outerPrefix(tpe.underlying(using ctx.withPhaseNoLater(erasurePhase)))
+          atPhaseNoLater(erasurePhase)(outerPrefix(tpe.underlying))
       }
     case tpe: TypeProxy =>
       outerPrefix(tpe.underlying)

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

@@ -23,7 +23,7 @@ object ValueClasses {
   }
 
   def isMethodWithExtension(sym: Symbol)(using Context): Boolean =
-    atPhaseNotLaterThan(extensionMethodsPhase) {
+    atPhaseNoLater(extensionMethodsPhase) {
       val d = sym.denot
       d.validFor.containsPhaseId(currentPhaseId) &&
       d.isRealMethod &&