Convert transform classes (2)

Author: odersky

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

@@ -31,13 +31,13 @@ object GenericSignatures {
    *  @param info The type of the symbol
    *  @return The signature if it could be generated, `None` otherwise.
    */
-  def javaSig(sym0: Symbol, info: Type)(implicit ctx: Context): Option[String] =
+  def javaSig(sym0: Symbol, info: Type)(using Context): Option[String] =
     // Avoid generating a signature for local symbols.
     if (sym0.isLocal) None
     else javaSig0(sym0, info)(using ctx.withPhase(ctx.erasurePhase))
 
   @noinline
-  private final def javaSig0(sym0: Symbol, info: Type)(implicit ctx: Context): Option[String] = {
+  private final def javaSig0(sym0: Symbol, info: Type)(using Context): Option[String] = {
     val builder = new StringBuilder(64)
     val isTraitSignature = sym0.enclosingClass.is(Trait)
 
@@ -247,7 +247,7 @@ object GenericSignatures {
 
         case mtpe: MethodType =>
           // erased method parameters do not make it to the bytecode.
-          def effectiveParamInfoss(t: Type)(implicit ctx: Context): List[List[Type]] = t match {
+          def effectiveParamInfoss(t: Type)(using Context): List[List[Type]] = t match {
             case t: MethodType if t.isErasedMethod => effectiveParamInfoss(t.resType)
             case t: MethodType => t.paramInfos :: effectiveParamInfoss(t.resType)
             case _ => Nil
@@ -319,7 +319,7 @@ object GenericSignatures {
     *    not Object, the dominator is Tc.                                        <--- @PP: "which is not Object" not in spec.
     *  - Otherwise, the dominator is the first element of the span.
     */
-  private def intersectionDominator(parents: List[Type])(implicit ctx: Context): Type =
+  private def intersectionDominator(parents: List[Type])(using Context): Type =
     if (parents.isEmpty) defn.ObjectType
     else {
       val psyms = parents map (_.typeSymbol)
@@ -342,7 +342,7 @@ object GenericSignatures {
   /* Drop redundant types (ones which are implemented by some other parent) from the immediate parents.
    * This is important on Android because there is otherwise an interface explosion.
    */
-  private def minimizeParents(cls: Symbol, parents: List[Type])(implicit ctx: Context): List[Type] = if (parents.isEmpty) parents else {
+  private def minimizeParents(cls: Symbol, parents: List[Type])(using Context): List[Type] = if (parents.isEmpty) parents else {
     // val requiredDirect: Symbol => Boolean = requiredDirectInterfaces.getOrElse(cls, Set.empty)
     var rest   = parents.tail
     var leaves = collection.mutable.ListBuffer.empty[Type] += parents.head
@@ -364,7 +364,7 @@ object GenericSignatures {
     leaves.toList
   }
 
-  private def hiBounds(bounds: TypeBounds)(implicit ctx: Context): List[Type] = bounds.hi.widenDealias match {
+  private def hiBounds(bounds: TypeBounds)(using Context): List[Type] = bounds.hi.widenDealias match {
     case AndType(tp1, tp2) => hiBounds(tp1.bounds) ::: hiBounds(tp2.bounds)
     case tp => tp :: Nil
   }
@@ -374,7 +374,7 @@ object GenericSignatures {
   // * higher-order type parameters
   // * type parameters appearing in method parameters
   // * type members not visible in an enclosing template
-  private def isTypeParameterInSig(sym: Symbol, initialSymbol: Symbol)(implicit ctx: Context) =
+  private def isTypeParameterInSig(sym: Symbol, initialSymbol: Symbol)(using Context) =
     !sym.maybeOwner.isTypeParam &&
       sym.isTypeParam && (
       sym.isContainedIn(initialSymbol.topLevelClass) ||
@@ -390,13 +390,13 @@ object GenericSignatures {
   // included (use pre.baseType(cls.owner)).
   //
   // This requires that cls.isClass.
-  private def rebindInnerClass(pre: Type, cls: Symbol)(implicit ctx: Context): Type = {
+  private def rebindInnerClass(pre: Type, cls: Symbol)(using Context): Type = {
     val owner = cls.owner
     if (owner.is(PackageClass) || owner.isTerm) pre else cls.owner.info /* .tpe_* */
   }
 
   private object RefOrAppliedType {
-    def unapply(tp: Type)(implicit ctx: Context): Option[(Symbol, Type, List[Type])] = tp match {
+    def unapply(tp: Type)(using Context): Option[(Symbol, Type, List[Type])] = tp match {
       case TypeParamRef(_, _) =>
         Some((tp.typeSymbol, tp, Nil))
       case TermParamRef(_, _) =>
@@ -411,12 +411,12 @@ object GenericSignatures {
     }
   }
 
-  private def needsJavaSig(tp: Type, throwsArgs: List[Type])(implicit ctx: Context): Boolean = !ctx.settings.YnoGenericSig.value && {
+  private def needsJavaSig(tp: Type, throwsArgs: List[Type])(using Context): Boolean = !ctx.settings.YnoGenericSig.value && {
       def needs(tp: Type) = (new NeedsSigCollector).apply(false, tp)
       needs(tp) || throwsArgs.exists(needs)
   }
 
-  private class NeedsSigCollector(implicit ctx: Context) extends TypeAccumulator[Boolean] {
+  private class NeedsSigCollector(using Context) extends TypeAccumulator[Boolean] {
     override def apply(x: Boolean, tp: Type): Boolean =
       if (!x)
         tp match {

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

@@ -62,7 +62,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
 
   override def phaseName: String = Getters.name
 
-  override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
+  override def transformSym(d: SymDenotation)(using Context): SymDenotation = {
     def noGetterNeeded =
       d.isOneOf(NoGetterNeededFlags) ||
       d.isAllOf(PrivateLocal) && !d.owner.is(Trait) && !isDerivedValueClass(d.owner) && !d.is(Lazy) ||
@@ -100,7 +100,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
         info = MethodType(sym.info.widenExpr :: Nil, defn.UnitType)
       ).enteredAfter(thisPhase)
 
-  override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree =
+  override def transformValDef(tree: ValDef)(using Context): Tree =
     val sym = tree.symbol
     if !sym.is(Method) then return tree
     val getterDef = DefDef(sym.asTerm, tree.rhs).withSpan(tree.span)
@@ -110,7 +110,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
     val setterDef = DefDef(sym.setter.asTerm, unitLiteral)
     Thicket(getterDef, setterDef)
 
-  override def transformAssign(tree: Assign)(implicit ctx: Context): Tree =
+  override def transformAssign(tree: Assign)(using Context): Tree =
     val lsym = tree.lhs.symbol.asTerm
     if (lsym.is(Method))
       ensureSetter(lsym)

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

@@ -54,7 +54,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
    *  parent super calls and constructor definitions.
    *  Hoisted superarg methods are collected in `superArgDefs`
    */
-  class Hoister(cls: Symbol)(implicit ctx: Context) {
+  class Hoister(cls: Symbol)(using Context) {
     val superArgDefs: mutable.ListBuffer[DefDef] = new mutable.ListBuffer
 
     /** If argument is complex, hoist it out into its own method and refer to the
@@ -197,7 +197,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
     }
   }
 
-  override def transformTypeDef(tdef: TypeDef)(implicit ctx: Context): Tree =
+  override def transformTypeDef(tdef: TypeDef)(using Context): Tree =
     tdef.rhs match {
       case impl @ Template(cdef, superCall :: others, _, _) =>
         val hoist = new Hoister(tdef.symbol)

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

@@ -24,25 +24,25 @@ class Instrumentation extends MiniPhase { thisPhase =>
 
   override def phaseName: String = "instrumentation"
 
-  override def isEnabled(implicit ctx: Context) =
+  override def isEnabled(using Context) =
     ctx.settings.YinstrumentClosures.value ||
     ctx.settings.YinstrumentAllocations.value
 
   private var consName: TermName = _
   private var consEqName: TermName = _
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = {
+  override def prepareForUnit(tree: Tree)(using Context): Context = {
     consName = "::".toTermName
     consEqName = "+=".toTermName
     ctx
   }
 
-  private def record(category: String, tree: Tree)(implicit ctx: Context): Tree = {
+  private def record(category: String, tree: Tree)(using Context): Tree = {
     val key = Literal(Constant(s"$category${tree.sourcePos.show}"))
     ref(defn.Stats_doRecord).appliedTo(key, Literal(Constant(1)))
   }
 
-  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = tree.fun match {
+  override def transformApply(tree: Apply)(using Context): Tree = tree.fun match {
     case Select(nu: New, _) =>
       cpy.Block(tree)(record(i"alloc/${nu.tpe}@", tree) :: Nil, tree)
     case Select(_, name) if name == consName || name == consEqName =>
@@ -51,7 +51,7 @@ class Instrumentation extends MiniPhase { thisPhase =>
       tree
   }
 
-  override def transformBlock(tree: Block)(implicit ctx: Context): Block = tree.expr match {
+  override def transformBlock(tree: Block)(using Context): Block = tree.expr match {
     case _: Closure =>
       cpy.Block(tree)(record("closure/", tree) :: tree.stats, tree.expr)
     case _ =>

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

@@ -28,13 +28,13 @@ class InterceptedMethods extends MiniPhase {
   override def phaseName: String = InterceptedMethods.name
 
   // this should be removed if we have guarantee that ## will get Apply node
-  override def transformSelect(tree: tpd.Select)(implicit ctx: Context): Tree =
+  override def transformSelect(tree: tpd.Select)(using Context): Tree =
     transformRefTree(tree)
 
-  override def transformIdent(tree: tpd.Ident)(implicit ctx: Context): Tree =
+  override def transformIdent(tree: tpd.Ident)(using Context): Tree =
     transformRefTree(tree)
 
-  private def transformRefTree(tree: RefTree)(implicit ctx: Context): Tree =
+  private def transformRefTree(tree: RefTree)(using Context): Tree =
     if (tree.symbol.isTerm && (defn.Any_## eq tree.symbol)) {
       val qual = tree match {
         case id: Ident => tpd.desugarIdentPrefix(id)
@@ -47,7 +47,7 @@ class InterceptedMethods extends MiniPhase {
     else tree
 
   // TODO: add missing cases from scalac
-  private def poundPoundValue(tree: Tree)(implicit ctx: Context) = {
+  private def poundPoundValue(tree: Tree)(using Context) = {
     val s = tree.tpe.widen.typeSymbol
 
     def staticsCall(methodName: TermName): Tree =
@@ -60,7 +60,7 @@ class InterceptedMethods extends MiniPhase {
     else staticsCall(nme.anyHash)
   }
 
-  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
+  override def transformApply(tree: Apply)(using Context): Tree = {
     lazy val qual = tree.fun match {
       case Select(qual, _) => qual
       case ident @ Ident(_) =>

compiler/src/dotty/tools/dotc/transform/IsInstanceOfEvaluator.scala.disabled

@@ -38,7 +38,7 @@ class IsInstanceOfEvaluator extends MiniPhase {
   /** Transforms a [TypeApply](dotty.tools.dotc.ast.Trees.TypeApply) in order to
    *  evaluate an `isInstanceOf` check according to the rules defined above.
    */
-  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree = {
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree = {
     val defn = ctx.definitions
 
     /** Handles the four cases of statically known `isInstanceOf`s and gives