Changes after renaming to make compilation go through

Author: odersky

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

@@ -58,7 +58,7 @@ class GenBCode extends Phase {
 
 
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
-    given CState = ctx.cstate
+    given CState = currentContext.cstate
     try super.runOn(units)
     finally myOutput match {
       case jar: JarArchive =>

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

@@ -31,7 +31,7 @@ import scala.collection.immutable
  *
  * Inspired from the `scalac` compiler.
  */
-class DottyPrimitives(ictx: Context, cs: CState) {
+class DottyPrimitives(ictx: Ctx, cs: CState) {
   import dotty.tools.backend.ScalaPrimitivesOps._
 
   @threadUnsafe private lazy val primitives: immutable.Map[Symbol, Int] = init
@@ -120,7 +120,7 @@ class DottyPrimitives(ictx: Context, cs: CState) {
   /** Initialize the primitive map */
   private def init: immutable.Map[Symbol, Int]  = {
 
-    given Context = ictx
+    given Ctx = ictx
     given CState = cs
 
     import Symbols.defn
@@ -399,7 +399,7 @@ class DottyPrimitives(ictx: Context, cs: CState) {
   }
 
   def isPrimitive(fun: Tree): Boolean =
-    given Context = ictx
+    given Ctx = ictx
     given CState = cs
     primitives.contains(fun.symbol)
     || (fun.symbol == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}}

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -138,7 +138,7 @@ class Compiler {
     runId += 1; runId
   }
 
-  def reset()(using Context): Unit = {
+  def reset()(using Ctx): Unit = {
     ctx.base.reset()
     if (ctx.run != null) ctx.run.reset()
   }
@@ -147,9 +147,9 @@ class Compiler {
     reset()
     val rctx =
       if ctx.settings.Ysemanticdb.value
-        ctx.addMode(Mode.ReadPositions)
+        currentContext.addMode(Mode.ReadPositions)
       else
-        ctx
+        currentContext
     new Run(this, rctx)
   }
 }

compiler/src/dotty/tools/dotc/Driver.scala

@@ -32,7 +32,7 @@ class Driver {
   protected def emptyReporter: Reporter = new StoreReporter(null)
 
   protected def doCompile(compiler: Compiler, fileNames: List[String])(using Context): Reporter =
-    given CState = ctx.cstate
+    given CState = currentContext.cstate
     if (fileNames.nonEmpty)
       try
         val run = compiler.newRun
@@ -79,7 +79,7 @@ class Driver {
       if Feature.enabledBySetting(nme.Scala2Compat) && false then // TODO: enable
         report.warning("-language:Scala2Compat will go away; use -source 3.0-migration instead")
       val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)
-      fromTastySetup(fileNames, ctx)
+      fromTastySetup(fileNames, currentContext)
     }
   }
 

compiler/src/dotty/tools/dotc/Run.scala

@@ -174,7 +174,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.base.usePhases(phases)
 
-    def runPhases(using Ctx, CState) = {
+    def runPhases(using c: Context) = {
+      given CState = c.cstate
       var lastPrintedTree: PrintedTree = NoPrintedTree
       val profiler = ctx.profiler
 
@@ -203,7 +204,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     runCtx.setProfiler(Profiler())
     unfusedPhases.foreach(_.initContext(runCtx))
     runPhases(using runCtx)
-    if (!ctx.reporter.hasErrors) Rewrites.writeBack()
+    if (!runCtx.reporter.hasErrors) Rewrites.writeBack()
     while (finalizeActions.nonEmpty) {
       val action = finalizeActions.remove(0)
       action()

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

@@ -1245,11 +1245,11 @@ object Trees {
      *  innermost enclosing call for which the inlined version is currently
      *  processed.
      */
-    protected def inlineContext(call: Tree)(using Ctx, CState): Context = ctx
+    protected def inlineContext(call: Tree)(using Ctx, CState): Ctx = ctx
 
     abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self =>
       def transform(tree: Tree)(using Ctx, CState): Tree = {
-        inContext(
+        inCtx(
           if tree.source != ctx.source && tree.source.exists
           then ctx.withSource(tree.source)
           else ctx
@@ -1313,11 +1313,11 @@ object Trees {
             case AppliedTypeTree(tpt, args) =>
               cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
             case LambdaTypeTree(tparams, body) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 cpy.LambdaTypeTree(tree)(transformSub(tparams), transform(body))
               }
             case TermLambdaTypeTree(params, body) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 cpy.TermLambdaTypeTree(tree)(transformSub(params), transform(body))
               }
             case MatchTypeTree(bound, selector, cases) =>
@@ -1335,17 +1335,17 @@ object Trees {
             case EmptyValDef =>
               tree
             case tree @ ValDef(name, tpt, _) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 val tpt1 = transform(tpt)
                 val rhs1 = transform(tree.rhs)
                 cpy.ValDef(tree)(name, tpt1, rhs1)
               }
             case tree @ DefDef(name, tparams, vparamss, tpt, _) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 cpy.DefDef(tree)(name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt), transform(tree.rhs))
               }
             case tree @ TypeDef(name, rhs) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 cpy.TypeDef(tree)(name, transform(rhs))
               }
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
@@ -1446,11 +1446,11 @@ object Trees {
             case AppliedTypeTree(tpt, args) =>
               this(this(x, tpt), args)
             case LambdaTypeTree(tparams, body) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 this(this(x, tparams), body)
               }
             case TermLambdaTypeTree(params, body) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 this(this(x, params), body)
               }
             case MatchTypeTree(bound, selector, cases) =>
@@ -1466,15 +1466,15 @@ object Trees {
             case UnApply(fun, implicits, patterns) =>
               this(this(this(x, fun), implicits), patterns)
             case tree @ ValDef(_, tpt, _) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 this(this(x, tpt), tree.rhs)
               }
             case tree @ DefDef(_, tparams, vparamss, tpt, _) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 this(this(vparamss.foldLeft(this(x, tparams))(apply), tpt), tree.rhs)
               }
             case TypeDef(_, rhs) =>
-              inContext(localCtx) {
+              inCtx(localCtx) {
                 this(x, rhs)
               }
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
@@ -1538,7 +1538,7 @@ object Trees {
     }.asInstanceOf[tree.ThisTree[T]]
 
     /** Delegate to FunProto or FunProtoTyped depending on whether the prefix is `untpd` or `tpd`. */
-    protected def FunProto(args: List[Tree], resType: Type)(using Context): ProtoTypes.FunProto
+    protected def FunProto(args: List[Tree], resType: Type)(using Ctx, CState): ProtoTypes.FunProto
 
     /** Construct the application `$receiver.$method[$targs]($args)` using overloading resolution
      *  to find a matching overload of `$method` if necessary.
@@ -1549,41 +1549,41 @@ object Trees {
      */
     def applyOverloaded(
         receiver: tpd.Tree, method: TermName, args: List[Tree], targs: List[Type],
-        expectedType: Type)(using parentCtx: Context, cs: CState): tpd.Tree = {
-      given ctx as Context = parentCtx.retractMode(Mode.ImplicitsEnabled)
-      import dotty.tools.dotc.ast.tpd.TreeOps
-
-      val typer = ctx.typer
-      val proto = FunProto(args, expectedType)
-      val denot = receiver.tpe.member(method)
-      assert(denot.exists, i"no member $receiver . $method, members = ${receiver.tpe.decls}")
-      val selected =
-        if (denot.isOverloaded) {
-          def typeParamCount(tp: Type) = tp.widen match {
-            case tp: PolyType => tp.paramInfos.length
-            case _ => 0
+        expectedType: Type)(using parentCtx: Ctx, cs: CState): tpd.Tree =
+      withoutMode(Mode.ImplicitsEnabled) {
+        import dotty.tools.dotc.ast.tpd.TreeOps
+
+        val typer = ctx.typer
+        val proto = FunProto(args, expectedType)
+        val denot = receiver.tpe.member(method)
+        assert(denot.exists, i"no member $receiver . $method, members = ${receiver.tpe.decls}")
+        val selected =
+          if (denot.isOverloaded) {
+            def typeParamCount(tp: Type) = tp.widen match {
+              case tp: PolyType => tp.paramInfos.length
+              case _ => 0
+            }
+            val allAlts = denot.alternatives
+              .map(denot => TermRef(receiver.tpe, denot.symbol))
+              .filter(tr => typeParamCount(tr) == targs.length)
+              .filter { _.widen match {
+                case MethodTpe(_, _, x: MethodType) => !x.isImplicitMethod
+                case _ => true
+              }}
+            val alternatives = ctx.typer.resolveOverloaded(allAlts, proto)
+            assert(alternatives.size == 1,
+              i"${if (alternatives.isEmpty) "no" else "multiple"} overloads available for " +
+                i"$method on ${receiver.tpe.widenDealiasKeepAnnots} with targs: $targs%, %; args: $args%, %; expectedType: $expectedType." +
+                i"all alternatives: ${allAlts.map(_.symbol.showDcl).mkString(", ")}\n" +
+                i"matching alternatives: ${alternatives.map(_.symbol.showDcl).mkString(", ")}.") // this is parsed from bytecode tree. there's nothing user can do about it
+              alternatives.head
           }
-          val allAlts = denot.alternatives
-            .map(denot => TermRef(receiver.tpe, denot.symbol))
-            .filter(tr => typeParamCount(tr) == targs.length)
-            .filter { _.widen match {
-              case MethodTpe(_, _, x: MethodType) => !x.isImplicitMethod
-              case _ => true
-            }}
-          val alternatives = ctx.typer.resolveOverloaded(allAlts, proto)
-          assert(alternatives.size == 1,
-            i"${if (alternatives.isEmpty) "no" else "multiple"} overloads available for " +
-              i"$method on ${receiver.tpe.widenDealiasKeepAnnots} with targs: $targs%, %; args: $args%, %; expectedType: $expectedType." +
-              i"all alternatives: ${allAlts.map(_.symbol.showDcl).mkString(", ")}\n" +
-              i"matching alternatives: ${alternatives.map(_.symbol.showDcl).mkString(", ")}.") // this is parsed from bytecode tree. there's nothing user can do about it
-            alternatives.head
-        }
-        else TermRef(receiver.tpe, denot.symbol)
-      val fun = receiver.select(selected).appliedToTypes(targs)
+          else TermRef(receiver.tpe, denot.symbol)
+        val fun = receiver.select(selected).appliedToTypes(targs)
 
-      val apply = untpd.Apply(fun, args)
-      typer.ApplyTo(apply, fun, selected, proto, expectedType)
-    }
+        val apply = untpd.Apply(fun, args)
+        typer.ApplyTo(apply, fun, selected, proto, expectedType)
+      }
 
 
     def resolveConstructor(atp: Type, args: List[Tree])(using Ctx, CState): tpd.Tree = {

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

@@ -1385,6 +1385,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       .appliedToVarargs(trees, tpe)
 
 
-  protected def FunProto(args: List[Tree], resType: Type)(using Context) =
+  protected def FunProto(args: List[Tree], resType: Type)(using Ctx, CState) =
     ProtoTypes.FunProtoTyped(args, resType)(ctx.typer, ApplyKind.Regular)
 }

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

@@ -782,6 +782,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     acc(false, tree)
   }
 
-  protected def FunProto(args: List[Tree], resType: Type)(using Context) =
+  protected def FunProto(args: List[Tree], resType: Type)(using Ctx, CState) =
     ProtoTypes.FunProto(args, resType)(ctx.typer, ApplyKind.Regular)
 }

compiler/src/dotty/tools/dotc/config/CompilerCommand.scala

@@ -65,8 +65,8 @@ object CompilerCommand {
    *  @return  The list of files to compile.
    */
   def checkUsage(summary: ArgsSummary, sourcesRequired: Boolean)(using Context): List[String] = {
-    given CState = ctx.cstate
-    val settings = ctx.settings
+    given CState = currentContext.cstate
+    val settings = currentContext.settings
 
     /** Creates a help message for a subset of options based on cond */
     def availableOptionsMsg(cond: Setting[?] => Boolean): String = {