Convert transform classes (3)

Author: odersky

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

@@ -41,7 +41,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
 
   /* Makes sure that, after getters and constructors gen, there doesn't
    * exist non-deferred definitions that are not implemented. */
-  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
+  override def checkPostCondition(tree: Tree)(using Context): Unit = {
     def errorLackImplementation(t: Tree) = {
       val firstPhaseId = t.symbol.initial.validFor.firstPhaseId
       val definingPhase = ctx.withPhase(firstPhaseId).phase.prev
@@ -68,7 +68,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
    */
   override def runsAfter: Set[String] = Set(Mixin.name)
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
     val sym = tree.symbol
 
     def newField = {

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

@@ -120,7 +120,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
 
   override def changesMembers: Boolean = true  // the phase adds implementions of mixin accessors
 
-  override def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
+  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
     if (sym.is(Accessor, butNot = Deferred) && sym.owner.is(Trait)) {
       val sym1 =
         if (sym.is(Lazy)) sym
@@ -134,7 +134,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
     else
       sym
 
-  private def initializer(sym: Symbol)(implicit ctx: Context): TermSymbol = {
+  private def initializer(sym: Symbol)(using Context): TermSymbol = {
     if (sym.is(Lazy)) sym
     else {
       val initName = InitializerName(sym.name.asTermName)
@@ -149,7 +149,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
     }
   }.asTerm
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
+  override def transformTemplate(impl: Template)(using Context): Template = {
     val cls = impl.symbol.owner.asClass
     val ops = new MixinOps(cls, thisPhase)
     import ops._

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

@@ -8,7 +8,7 @@ import SymUtils._
 import StdNames._, NameOps._
 import Decorators._
 
-class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Context) {
+class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   import ast.tpd._
 
   val superCls: Symbol = cls.superClass

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

@@ -23,7 +23,7 @@ class MoveStatics extends MiniPhase with SymTransformer {
   import tpd._
   override def phaseName: String = MoveStatics.name
 
-  def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
+  def transformSym(sym: SymDenotation)(using Context): SymDenotation =
     if (sym.hasAnnotation(defn.ScalaStaticAnnot) && sym.owner.is(Flags.Module) && sym.owner.companionClass.exists &&
         (sym.is(Flags.Method) || !(sym.is(Flags.Mutable) && sym.owner.companionClass.is(Flags.Trait)))) {
       sym.owner.asClass.delete(sym.symbol)
@@ -32,7 +32,7 @@ class MoveStatics extends MiniPhase with SymTransformer {
     }
     else sym
 
-  override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
+  override def transformStats(trees: List[Tree])(using Context): List[Tree] =
     if (ctx.owner.is(Flags.Package)) {
       val (classes, others) = trees.partition(x => x.isInstanceOf[TypeDef] && x.symbol.isClass)
       val pairs = classes.groupBy(_.symbol.name.stripModuleClassSuffix).asInstanceOf[Map[Name, List[TypeDef]]]

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

@@ -10,7 +10,7 @@ import config.SourceVersion._
 
 object NonLocalReturns {
   import ast.tpd._
-  def isNonLocalReturn(ret: Return)(implicit ctx: Context): Boolean =
+  def isNonLocalReturn(ret: Return)(using Context): Boolean =
     !ret.from.symbol.is(Label) && (ret.from.symbol != ctx.owner.enclosingMethod || ctx.owner.is(Lazy))
 }
 
@@ -24,21 +24,21 @@ class NonLocalReturns extends MiniPhase {
 
   override def runsAfter: Set[String] = Set(ElimByName.name)
 
-  private def ensureConforms(tree: Tree, pt: Type)(implicit ctx: Context) =
+  private def ensureConforms(tree: Tree, pt: Type)(using Context) =
     if (tree.tpe <:< pt) tree
     else Erasure.Boxing.adaptToType(tree, pt)
 
   private def nonLocalReturnControl(using Context) = defn.NonLocalReturnControlClass.typeRef
 
   /** The type of a non-local return expression with given argument type */
-  private def nonLocalReturnExceptionType(argtype: Type)(implicit ctx: Context) =
+  private def nonLocalReturnExceptionType(argtype: Type)(using Context) =
     nonLocalReturnControl.appliedTo(argtype)
 
   /** A hashmap from method symbols to non-local return keys */
   private val nonLocalReturnKeys = newMutableSymbolMap[TermSymbol]
 
   /** Return non-local return key for given method */
-  private def nonLocalReturnKey(meth: Symbol)(implicit ctx: Context) =
+  private def nonLocalReturnKey(meth: Symbol)(using Context) =
     nonLocalReturnKeys.getOrElseUpdate(meth,
       ctx.newSymbol(
         meth, NonLocalReturnKeyName.fresh(), Synthetic, defn.ObjectType, coord = meth.span))
@@ -50,7 +50,7 @@ class NonLocalReturns extends MiniPhase {
    *  todo: maybe clone a pre-existing exception instead?
    *  (but what to do about exceptions that miss their targets?)
    */
-  private def nonLocalReturnThrow(expr: Tree, meth: Symbol)(implicit ctx: Context) =
+  private def nonLocalReturnThrow(expr: Tree, meth: Symbol)(using Context) =
     Throw(
       New(
         nonLocalReturnControl,
@@ -69,7 +69,7 @@ class NonLocalReturns extends MiniPhase {
    *    }
    *  }
    */
-  private def nonLocalReturnTry(body: Tree, key: TermSymbol, meth: Symbol)(implicit ctx: Context) = {
+  private def nonLocalReturnTry(body: Tree, key: TermSymbol, meth: Symbol)(using Context) = {
     val keyDef = ValDef(key, New(defn.ObjectType, Nil))
     val ex = ctx.newSymbol(meth, nme.ex, Case, nonLocalReturnControl, coord = body.span)
     val pat = BindTyped(ex, nonLocalReturnControl)
@@ -82,13 +82,13 @@ class NonLocalReturns extends MiniPhase {
     Block(keyDef :: Nil, tryCatch)
   }
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree =
+  override def transformDefDef(tree: DefDef)(using Context): Tree =
     nonLocalReturnKeys.remove(tree.symbol) match {
       case Some(key) => cpy.DefDef(tree)(rhs = nonLocalReturnTry(tree.rhs, key, tree.symbol))
       case _ => tree
     }
 
-  override def transformReturn(tree: Return)(implicit ctx: Context): Tree =
+  override def transformReturn(tree: Return)(using Context): Tree =
     if isNonLocalReturn(tree) then
       if sourceVersion.isAtLeast(`3.1`) then
         ctx.errorOrMigrationWarning("Non local returns are no longer supported; use scala.util.control.NonLocalReturns instead", tree.sourcePos)

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

@@ -20,7 +20,7 @@ object OverridingPairs {
   /** The cursor class
    *  @param base   the base class that contains the overriding pairs
    */
-  class Cursor(base: Symbol)(implicit ctx: Context) {
+  class Cursor(base: Symbol)(using Context) {
 
     private val self = base.thisType
 

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

@@ -60,9 +60,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
 
   private val InAnnotation = Property.Key[Unit]()
 
-  override def transform(tree: Tree)(implicit ctx: Context): Tree =
+  override def transform(tree: Tree)(using Context): Tree =
     if (tree.source != ctx.source && tree.source.exists)
-      transform(tree)(ctx.withSource(tree.source))
+      transform(tree)(using ctx.withSource(tree.source))
     else if !isInQuoteOrSplice then
       checkAnnotations(tree)
       super.transform(tree)
@@ -100,7 +100,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     }
 
   /** Transform quoted trees while maintaining phase correctness */
-  override protected def transformQuotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree = {
+  override protected def transformQuotation(body: Tree, quote: Tree)(using Context): Tree = {
     val taggedTypes = new PCPCheckAndHeal.QuoteTypeTags(quote.span)(using ctx)
 
     if (ctx.property(InAnnotation).isDefined)
@@ -109,7 +109,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     val contextWithQuote =
       if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
       else quoteContext
-    val body1 = transform(body)(contextWithQuote)
+    val body1 = transform(body)(using contextWithQuote)
     val body2 =
       taggedTypes.getTypeTags match
         case Nil  => body1
@@ -123,8 +123,8 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
    *  - If inside inlined code, expand the macro code.
    *  - If inside of a macro definition, check the validity of the macro.
    */
-  protected def transformSplice(body: Tree, splice: Tree)(implicit ctx: Context): Tree = {
-    val body1 = transform(body)(spliceContext)
+  protected def transformSplice(body: Tree, splice: Tree)(using Context): Tree = {
+    val body1 = transform(body)(using spliceContext)
     splice match {
       case Apply(fun @ TypeApply(_, _ :: Nil), _) if splice.isTerm =>
         // Type of the splice itsel must also be healed
@@ -216,7 +216,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
    *  refercence to a type alias containing the equivalent of `${summon[quoted.Type[T]]}`.
    *  Emits and error if `T` cannot be healed and returns `T`.
    */
-  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SourcePosition)(implicit ctx: Context): TypeRef = {
+  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SourcePosition)(using Context): TypeRef = {
     val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
     val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
     tag.tpe match

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

@@ -29,7 +29,7 @@ class PatternMatcher extends MiniPhase {
   override def phaseName: String = PatternMatcher.name
   override def runsAfter: Set[String] = Set(ElimRepeated.name)
 
-  override def transformMatch(tree: Match)(implicit ctx: Context): Tree =
+  override def transformMatch(tree: Match)(using Context): Tree =
     if (tree.isInstanceOf[InlineMatch]) tree
     else {
       // Widen termrefs with underlying `=> T` types. Otherwise ElimByName will produce
@@ -62,7 +62,7 @@ object PatternMatcher {
   val TrustedTypeTestKey: Key[Unit] = new StickyKey[Unit]
 
   /** Was symbol generated by pattern matcher? */
-  def isPatmatGenerated(sym: Symbol)(implicit ctx: Context): Boolean =
+  def isPatmatGenerated(sym: Symbol)(using Context): Boolean =
     sym.is(Synthetic) && sym.name.is(PatMatStdBinderName)
 
   /** The pattern matching translator.
@@ -82,7 +82,7 @@ object PatternMatcher {
    *  It's represented by its own data type. Plans are optimized by merging common
    *  tests and eliminating dead code.
    */
-  class Translator(resultType: Type, thisPhase: MiniPhase)(implicit ctx: Context) {
+  class Translator(resultType: Type, thisPhase: MiniPhase)(using Context) {
 
     // ------- Bindings for variables and labels ---------------------
 
@@ -383,7 +383,7 @@ object PatternMatcher {
                 assert(mt.isImplicitMethod || mt.isContextualMethod)
                 val (args, rest) = implicits.splitAt(mt.paramNames.size)
                 applyImplicits(acc.appliedToArgs(args), rest, mt.resultType)
-              case _ => 
+              case _ =>
                 assert(implicits.isEmpty)
                 acc
             }
@@ -442,7 +442,7 @@ object PatternMatcher {
     /** A superclass for plan transforms */
     class PlanTransform extends (Plan => Plan) {
       protected val treeMap: TreeMap = new TreeMap {
-        override def transform(tree: Tree)(implicit ctx: Context) = tree
+        override def transform(tree: Tree)(using Context) = tree
       }
       def apply(tree: Tree): Tree = treeMap.transform(tree)
       def apply(plan: TestPlan): Plan = {
@@ -501,7 +501,7 @@ object PatternMatcher {
     private def varRefCount(plan: Plan): collection.Map[Symbol, Int] = {
       object refCounter extends RefCounter {
         override val treeMap = new TreeMap {
-          override def transform(tree: Tree)(implicit ctx: Context) = tree match {
+          override def transform(tree: Tree)(using Context) = tree match {
             case tree: Ident =>
               if (isPatmatGenerated(tree.symbol)) count(tree.symbol) += 1
               tree
@@ -563,7 +563,7 @@ object PatternMatcher {
     def mergeTests(plan: Plan): Plan = {
       class SubstituteIdent(from: TermSymbol, to: TermSymbol) extends PlanTransform {
         override val treeMap = new TreeMap {
-          override def transform(tree: Tree)(implicit ctx: Context) = tree match {
+          override def transform(tree: Tree)(using Context) = tree match {
             case tree: Ident if tree.symbol == from => ref(to)
             case _ => super.transform(tree)
           }
@@ -646,7 +646,7 @@ object PatternMatcher {
 
       object Inliner extends PlanTransform {
         override val treeMap = new TreeMap {
-          override def transform(tree: Tree)(implicit ctx: Context) = tree match {
+          override def transform(tree: Tree)(using Context) = tree match {
             case tree: Ident =>
               val sym = tree.symbol
               if (toDrop(sym)) transform(initializer(sym))

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

@@ -25,7 +25,7 @@ class Pickler extends Phase {
   override def phaseName: String = Pickler.name
 
   // No need to repickle trees coming from TASTY
-  override def isRunnable(implicit ctx: Context): Boolean =
+  override def isRunnable(using Context): Boolean =
     super.isRunnable && !ctx.settings.fromTasty.value
 
   private def output(name: String, msg: String) = {
@@ -39,13 +39,13 @@ class Pickler extends Phase {
   private val picklers = new mutable.HashMap[ClassSymbol, TastyPickler]
 
   /** Drop any elements of this list that are linked module classes of other elements in the list */
-  private def dropCompanionModuleClasses(clss: List[ClassSymbol])(implicit ctx: Context): List[ClassSymbol] = {
+  private def dropCompanionModuleClasses(clss: List[ClassSymbol])(using Context): List[ClassSymbol] = {
     val companionModuleClasses =
       clss.filterNot(_.is(Module)).map(_.linkedClass).filterNot(_.isAbsent())
     clss.filterNot(companionModuleClasses.contains)
   }
 
-  override def run(implicit ctx: Context): Unit = {
+  override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
     pickling.println(i"unpickling in run ${ctx.runId}")
 
@@ -87,11 +87,11 @@ class Pickler extends Phase {
     }
   }
 
-  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
     val result = super.runOn(units)
     if (ctx.settings.YtestPickler.value)
       testUnpickler(
-          ctx.fresh
+        using ctx.fresh
             .setPeriod(Period(ctx.runId + 1, FirstPhaseId))
             .setReporter(new ThrowingReporter(ctx.reporter))
             .addMode(Mode.ReadPositions)
@@ -100,7 +100,7 @@ class Pickler extends Phase {
     result
   }
 
-  private def testUnpickler(implicit ctx: Context): Unit = {
+  private def testUnpickler(using Context): Unit = {
     pickling.println(i"testing unpickler at run ${ctx.runId}")
     ctx.initialize()
     val unpicklers =
@@ -116,7 +116,7 @@ class Pickler extends Phase {
     }
   }
 
-  private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(implicit ctx: Context) =
+  private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(using Context) =
     if (previous != unpickled) {
       output("before-pickling.txt", previous)
       output("after-pickling.txt", unpickled)