Merge pull request #6861 from dotty-staging/refactor-dotc2

More dotc refactorings

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/Annotations.scala

@@ -124,32 +124,32 @@ object Annotations {
     }
 
     /** Create an annotation where the tree is computed lazily. */
-    def deferred(sym: Symbol, treeFn: Context => Tree)(implicit ctx: Context): Annotation =
+    def deferred(sym: Symbol)(treeFn: given Context => Tree)(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         override def symbol(implicit ctx: Context): Symbol = sym
-        def complete(implicit ctx: Context) = treeFn(ctx)
+        def complete(implicit ctx: Context) = treeFn given ctx
       }
 
     /** Create an annotation where the symbol and the tree are computed lazily. */
-    def deferredSymAndTree(symf: Context => Symbol, treeFn: Context => Tree)(implicit ctx: Context): Annotation =
+    def deferredSymAndTree(symf: given Context => Symbol)(treeFn: given Context => Tree)(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         private[this] var mySym: Symbol = _
 
         override def symbol(implicit ctx: Context): Symbol = {
           if (mySym == null || mySym.defRunId != ctx.runId) {
-            mySym = symf(ctx)
+            mySym = symf given ctx
             assert(mySym != null)
           }
           mySym
         }
-        def complete(implicit ctx: Context) = treeFn(ctx)
+        def complete(implicit ctx: Context) = treeFn given ctx
       }
 
     def deferred(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
-      deferred(atp.classSymbol, implicit ctx => New(atp, args))
+      deferred(atp.classSymbol)(New(atp, args))
 
     def deferredResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
-      deferred(atp.classSymbol, implicit ctx => resolveConstructor(atp, args))
+      deferred(atp.classSymbol)(resolveConstructor(atp, args))
 
     def makeAlias(sym: TermSymbol)(implicit ctx: Context): Annotation =
       apply(defn.AliasAnnot, List(
@@ -165,7 +165,7 @@ object Annotations {
           New(defn.ChildAnnotType.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil)
             .withSpan(span)
         }
-        deferred(defn.ChildAnnot, implicit ctx => makeChildLater(ctx))
+        deferred(defn.ChildAnnot)(makeChildLater(ctx))
       }
 
       /** A regular, non-deferred Child annotation */

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

@@ -315,7 +315,7 @@ object Contexts {
     /** Run `op` as if it was run in a fresh explore typer state, but possibly
      *  optimized to re-use the current typer state.
      */
-    final def test[T](op: Context => T): T = typerState.test(op)(this)
+    final def test[T](op: given Context => T): T = typerState.test(op)(this)
 
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =
@@ -404,7 +404,7 @@ object Contexts {
         case _               => None
       }
       ctx.fresh.setImportInfo(
-        new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt, imp.importDelegate))
+        ImportInfo(sym, imp.selectors, impNameOpt, imp.importDelegate))
     }
 
     /** Does current phase use an erased types interpretation? */

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

@@ -204,7 +204,7 @@ object Decorators {
      *  give more info about type variables and to disambiguate where needed.
      */
     def ex(args: Any*)(implicit ctx: Context): String =
-      explained(implicit ctx => em(args: _*))
+      explained(em(args: _*))
   }
 
   implicit class ArrayInterpolator[T <: AnyRef](val arr: Array[T]) extends AnyVal {

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/core/TypeComparer.scala

@@ -195,7 +195,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
         //}
         assert(!ctx.settings.YnoDeepSubtypes.value)
         if (Config.traceDeepSubTypeRecursions && !this.isInstanceOf[ExplainingTypeComparer])
-          ctx.log(TypeComparer.explained(implicit ctx => ctx.typeComparer.isSubType(tp1, tp2, approx)))
+          ctx.log(TypeComparer.explained(the[Context].typeComparer.isSubType(tp1, tp2, approx)))
       }
       // Eliminate LazyRefs before checking whether we have seen a type before
       val normalize = new TypeMap {
@@ -2307,15 +2307,15 @@ object TypeComparer {
    */
   val FreshApprox: ApproxState = new ApproxState(4)
 
-  /** Show trace of comparison operations when performing `op` as result string */
-  def explaining[T](say: String => Unit)(op: Context => T)(implicit ctx: Context): T = {
+  /** Show trace of comparison operations when performing `op` */
+  def explaining[T](say: String => Unit)(op: given Context => T)(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setTypeComparerFn(new ExplainingTypeComparer(_))
-    val res = try { op(nestedCtx) } finally { say(nestedCtx.typeComparer.lastTrace()) }
+    val res = try { op given nestedCtx } finally { say(nestedCtx.typeComparer.lastTrace()) }
     res
   }
 
   /** Like [[explaining]], but returns the trace instead */
-  def explained[T](op: Context => T)(implicit ctx: Context): String = {
+  def explained[T](op: given Context => T)(implicit ctx: Context): String = {
     var trace: String = null
     try { explaining(trace = _)(op) } catch { case ex: Throwable => ex.printStackTrace }
     trace