Make atPhase methods take arguments of implicit function type

Author: odersky

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

@@ -518,7 +518,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
    * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
    */
   def getGenericSignature(sym: Symbol, owner: Symbol): String = {
-    ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+    ctx.atPhase(ctx.erasurePhase) {
       val memberTpe =
         if (sym.is(Flags.Method)) sym.denot.info
         else owner.denot.thisType.memberInfo(sym)
@@ -533,7 +533,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     // 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 = ctx.atPhase(ctx.erasurePhase) { implicit ctx => moduleClass.denot.thisType.memberInfo(sym) }
+    val memberTpe = ctx.atPhase(ctx.erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
     val erasedMemberType = TypeErasure.erasure(memberTpe)
     if (erasedMemberType =:= sym.denot.info)
       getGenericSignature(sym, moduleClass, memberTpe).orNull
@@ -782,7 +782,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
     private def definedClasses(phase: Phase) =
       if (sym.isDefinedInCurrentRun)
-        ctx.atPhase(phase) { implicit ctx =>
+        ctx.atPhase(phase) {
           toDenot(sym).info.decls.filter(_.isClass)
         }
       else Nil
@@ -835,13 +835,13 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
      * such objects.
      */
     def isTopLevelModuleClass: Boolean = sym.isModuleClass &&
-      ctx.atPhase(ctx.flattenPhase) { implicit ctx =>
+      ctx.atPhase(ctx.flattenPhase) {
         toDenot(sym).owner.is(Flags.PackageClass)
       }
 
     def addRemoteRemoteExceptionAnnotation: Unit = ()
 
-    def samMethod(): Symbol = ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+    def samMethod(): Symbol = ctx.atPhase(ctx.erasurePhase) {
       toDenot(sym).info.abstractTermMembers.toList match {
         case x :: Nil => x.symbol
         case Nil => abort(s"${sym.show} is not a functional interface. It doesn't have abstract methods")

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

@@ -162,8 +162,8 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
             val (cl1, cl2) =
               if (classSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (classSymbol, dupClassSym)
               else (dupClassSym, classSymbol)
-            ctx.atPhase(ctx.typerPhase) { implicit ctx =>
-              ctx.warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
+            ctx.atPhase(ctx.typerPhase) {
+              the[Context].warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
                 "Such classes will overwrite one another on case-insensitive filesystems.", cl1.sourcePos)
             }
         }
@@ -263,7 +263,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
 
         // ----------- compiler and sbt's callbacks
 
-        val (fullClassName, isLocal) = ctx.atPhase(ctx.sbtExtractDependenciesPhase) { implicit ctx =>
+        val (fullClassName, isLocal) = ctx.atPhase(ctx.sbtExtractDependenciesPhase) {
           (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
         }
 

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

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

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

@@ -16,7 +16,7 @@ object JSInterop {
   /** Is this symbol a JavaScript type? */
   def isJSType(sym: Symbol)(implicit ctx: Context): Boolean = {
     //sym.hasAnnotation(jsdefn.RawJSTypeAnnot)
-    ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+    ctx.atPhase(ctx.erasurePhase) {
       sym.derivesFrom(jsdefn.JSAnyClass)
     }
   }
@@ -32,7 +32,7 @@ object JSInterop {
    *  much as *accessor* methods created for `val`s and `var`s.
    */
   def isJSGetter(sym: Symbol)(implicit ctx: Context): Boolean = {
-    sym.info.firstParamTypes.isEmpty && ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+    sym.info.firstParamTypes.isEmpty && ctx.atPhase(ctx.erasurePhase) {
       sym.info.isParameterless
     }
   }

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

@@ -21,8 +21,8 @@ abstract class Periods { self: Context =>
     op(ctx.fresh.setPeriod(pd))
 
   /** Execute `op` at given phase id */
-  def atPhase[T](pid: PhaseId)(op: Context => T): T =
-    op(ctx.withPhase(pid))
+  def atPhase[T](pid: PhaseId)(op: given Context => T): T =
+    op given ctx.withPhase(pid)
 
   /** The period containing the current period where denotations do not change.
    *  We compute this by taking as first phase the first phase less or equal to

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

@@ -31,13 +31,13 @@ trait Phases {
     }
 
   /** Execute `op` at given phase */
-  def atPhase[T](phase: Phase)(op: Context => T): T =
+  def atPhase[T](phase: Phase)(op: given Context => T): T =
     atPhase(phase.id)(op)
 
-  def atNextPhase[T](op: Context => T): T = atPhase(phase.next)(op)
+  def atNextPhase[T](op: given Context => T): T = atPhase(phase.next)(op)
 
-  def atPhaseNotLaterThan[T](limit: Phase)(op: Context => T): T =
-    if (!limit.exists || phase <= limit) op(this) else atPhase(limit)(op)
+  def atPhaseNotLaterThan[T](limit: Phase)(op: given Context => T): T =
+    if (!limit.exists || phase <= limit) op given this else atPhase(limit)(op)
 
   def isAfterTyper: Boolean = base.isAfterTyper(phase)
 }

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

@@ -42,7 +42,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
   private def applyIfFunction(tree: Tree, ftree: Tree)(implicit ctx: Context) =
     if (isByNameRef(ftree)) {
       val tree0 = transformFollowing(tree)
-      ctx.atPhase(next) { implicit ctx => tree0.select(defn.Function0_apply).appliedToNone }
+      ctx.atPhase(next) { tree0.select(defn.Function0_apply).appliedToNone }
     }
     else tree
 
@@ -61,7 +61,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
   }
 
   override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree =
-    ctx.atPhase(next) { implicit ctx =>
+    ctx.atPhase(next) {
       if (exprBecomesFunction(tree.symbol))
         cpy.ValDef(tree)(tpt = tree.tpt.withType(tree.symbol.info))
       else tree

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

@@ -112,7 +112,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
    *  Also transform trees inside method annotation
    */
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree =
-    ctx.atPhase(thisPhase) { implicit ctx =>
+    ctx.atPhase(thisPhase) {
       if (tree.symbol.info.isVarArgsMethod && overridesJava(tree.symbol))
         addVarArgsBridge(tree)
       else

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

@@ -131,7 +131,7 @@ object ExplicitOuter {
 
   /** Ensure that class `cls` has outer accessors */
   def ensureOuterAccessors(cls: ClassSymbol)(implicit ctx: Context): Unit =
-    ctx.atPhase(ctx.explicitOuterPhase.next) { implicit ctx =>
+    ctx.atPhase(ctx.explicitOuterPhase.next) {
       if (!hasOuter(cls))
         newOuterAccessors(cls).foreach(_.enteredAfter(ctx.explicitOuterPhase.asInstanceOf[DenotTransformer]))
     }

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

@@ -217,7 +217,7 @@ object ExtensionMethods {
 
   /** Return the extension method that corresponds to given instance method `meth`. */
   def extensionMethod(imeth: Symbol)(implicit ctx: Context): TermSymbol =
-    ctx.atPhase(ctx.extensionMethodsPhase.next) { implicit ctx =>
+    ctx.atPhase(ctx.extensionMethodsPhase.next) {
       // FIXME use toStatic instead?
       val companion = imeth.owner.companionModule
       val companionInfo = companion.info

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

@@ -35,9 +35,7 @@ class FunctionalInterfaces extends MiniPhase {
 
     if (defn.isSpecializableFunction(cls, implParamTypes, implResultType) &&
         !ctx.settings.scalajs.value) { // never do anything for Scala.js, but do this test as late as possible not to slow down Scala/JVM
-      val names = ctx.atPhase(ctx.erasurePhase) {
-        implicit ctx => cls.typeParams.map(_.name)
-      }
+      val names = ctx.atPhase(ctx.erasurePhase) { cls.typeParams.map(_.name) }
       val interfaceName = (functionName ++ implParamTypes.length.toString).specializedFor(implParamTypes ::: implResultType :: Nil, names, Nil, Nil)
 
       // symbols loaded from classpath aren't defined in periods earlier than when they where loaded

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

@@ -119,7 +119,7 @@ object GenericSignatures {
     // a type parameter or similar) must go through here or the signature is
     // likely to end up with Foo<T>.Empty where it needs Foo<T>.Empty$.
     def fullNameInSig(sym: Symbol): Unit = {
-      val name = ctx.atPhase(ctx.genBCodePhase) { implicit ctx => sanitizeName(sym.fullName).replace('.', '/') }
+      val name = ctx.atPhase(ctx.genBCodePhase) { sanitizeName(sym.fullName).replace('.', '/') }
       builder.append('L').append(name)
     }
 

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

@@ -358,7 +358,7 @@ object LambdaLift {
     }
 
     // initialization
-    ctx.atPhase(thisPhase) { implicit ctx =>
+    ctx.atPhase(thisPhase) {
       (new CollectDependencies).traverse(ctx.compilationUnit.tpdTree)
       computeFreeVars()
       computeLiftedOwners()

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

@@ -207,7 +207,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
     }
 
     def wasOneOf(sym: Symbol, flags: FlagSet) =
-      ctx.atPhase(thisPhase) { implicit ctx => sym.isOneOf(flags) }
+      ctx.atPhase(thisPhase) { sym.isOneOf(flags) }
 
     def traitInits(mixin: ClassSymbol): List[Tree] = {
       var argNum = 0

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

@@ -43,7 +43,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
    *  The test is performed at phase `thisPhase`.
    */
   def isCurrent(sym: Symbol): Boolean =
-    ctx.atPhase(thisPhase) { implicit ctx =>
+    ctx.atPhase(thisPhase) {
       cls.info.nonPrivateMember(sym.name).hasAltWith(_.symbol == sym)
     }
 

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

@@ -57,7 +57,7 @@ class TreeChecker extends Phase with SymTransformer {
 
   def checkCompanion(symd: SymDenotation)(implicit ctx: Context): Unit = {
     val cur = symd.linkedClass
-    val prev = ctx.atPhase(ctx.phase.prev) { implicit ctx =>
+    val prev = ctx.atPhase(ctx.phase.prev) {
       symd.symbol.linkedClass
     }
 

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

@@ -22,9 +22,9 @@ object ValueClasses {
   }
 
   def isMethodWithExtension(sym: Symbol)(implicit ctx: Context): Boolean =
-    ctx.atPhaseNotLaterThan(ctx.extensionMethodsPhase) { implicit ctx =>
+    ctx.atPhaseNotLaterThan(ctx.extensionMethodsPhase) {
       val d = sym.denot
-      d.validFor.containsPhaseId(ctx.phaseId) &&
+      d.validFor.containsPhaseId(the[Context].phaseId) &&
       d.isRealMethod &&
       isDerivedValueClass(d.owner) &&
       !d.isConstructor &&

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

@@ -466,7 +466,7 @@ object RefChecks {
 
       def hasJavaErasedOverriding(sym: Symbol): Boolean =
         !ctx.erasurePhase.exists || // can't do the test, assume the best
-          ctx.atPhase(ctx.erasurePhase.next) { implicit ctx =>
+          ctx.atPhase(ctx.erasurePhase.next) {
             clazz.info.nonPrivateMember(sym.name).hasAltWith { alt =>
               alt.symbol.is(JavaDefined, butNot = Deferred) &&
                 !sym.owner.derivesFrom(alt.symbol.owner) &&

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

@@ -291,8 +291,7 @@ class ReplDriver(settings: Array[String],
       }
 
 
-    ctx.atPhase(ctx.typerPhase.next) { implicit ctx =>
-
+    ctx.atPhase(ctx.typerPhase.next) {
       // Display members of wrapped module:
       tree.symbol.info.memberClasses
         .find(_.symbol.name == newestWrapper.moduleClassName)