Convert transform classes (1)

Author: odersky

compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala

@@ -63,15 +63,15 @@ object Rewrites {
   /** If -rewrite is set, record a patch that replaces the range
    *  given by `span` in `source` by `replacement`
    */
-  def patch(source: SourceFile, span: Span, replacement: String)(implicit ctx: Context): Unit =
+  def patch(source: SourceFile, span: Span, replacement: String)(using Context): Unit =
     if (ctx.reporter != Reporter.NoReporter) // NoReporter is used for syntax highlighting
       for (rewrites <- ctx.settings.rewrite.value)
         rewrites.patched
           .getOrElseUpdate(source, new Patches(source))
           .addPatch(span, replacement)
 
   /** Patch position in `ctx.compilationUnit.source`. */
-  def patch(span: Span, replacement: String)(implicit ctx: Context): Unit =
+  def patch(span: Span, replacement: String)(using Context): Unit =
     patch(ctx.compilationUnit.source, span, replacement)
 
   /** Does `span` overlap with a patch region of `source`? */
@@ -82,7 +82,7 @@ object Rewrites {
 
   /** If -rewrite is set, apply all patches and overwrite patched source files.
    */
-  def writeBack()(implicit ctx: Context): Unit =
+  def writeBack()(using Context): Unit =
     for (rewrites <- ctx.settings.rewrite.value; source <- rewrites.patched.keys) {
       ctx.echo(s"[patched file ${source.file.path}]")
       rewrites.patched(source).writeBack()

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

@@ -28,13 +28,13 @@ abstract class AccessProxies {
   /** Given the name of an accessor, is the receiver of the call to accessed obtained
    *  as a parameterer?
    */
-  protected def passReceiverAsArg(accessorName: Name)(implicit ctx: Context): Boolean = false
+  protected def passReceiverAsArg(accessorName: Name)(using Context): Boolean = false
 
   /** The accessor definitions that need to be added to class `cls`
    *  As a side-effect, this method removes entries from the `accessedBy` map.
    *  So a second call of the same method will yield the empty list.
    */
-  private def accessorDefs(cls: Symbol)(implicit ctx: Context): Iterator[DefDef] =
+  private def accessorDefs(cls: Symbol)(using Context): Iterator[DefDef] =
     for (accessor <- cls.info.decls.iterator; accessed <- accessedBy.remove(accessor)) yield
       polyDefDef(accessor.asTerm, tps => argss => {
         def numTypeParams = accessed.info match {
@@ -57,7 +57,7 @@ abstract class AccessProxies {
       })
 
   /** Add all needed accessors to the `body` of class `cls` */
-  def addAccessorDefs(cls: Symbol, body: List[Tree])(implicit ctx: Context): List[Tree] = {
+  def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] = {
     val accDefs = accessorDefs(cls)
     transforms.println(i"add accessors for $cls: $accDefs%, %")
     if (accDefs.isEmpty) body else body ++ accDefs
@@ -67,22 +67,22 @@ abstract class AccessProxies {
     import ast.tpd._
 
     def accessorNameKind: ClassifiedNameKind
-    def needsAccessor(sym: Symbol)(implicit ctx: Context): Boolean
+    def needsAccessor(sym: Symbol)(using Context): Boolean
 
-    def ifNoHost(reference: RefTree)(implicit ctx: Context): Tree = {
+    def ifNoHost(reference: RefTree)(using Context): Tree = {
       assert(false, "no host found for $reference with ${reference.symbol.showLocated} from ${ctx.owner}")
       reference
     }
 
     /** A fresh accessor symbol */
-    private def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, span: Span)(implicit ctx: Context): TermSymbol = {
+    private def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, span: Span)(using Context): TermSymbol = {
       val sym = ctx.newSymbol(owner, name, Synthetic | Method, info, coord = span).entered
       if (sym.allOverriddenSymbols.exists(!_.is(Deferred))) sym.setFlag(Override)
       sym
     }
 
     /** An accessor symbol, create a fresh one unless one exists already */
-    protected def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(implicit ctx: Context): Symbol = {
+    protected def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(using Context): Symbol = {
       def refersToAccessed(sym: Symbol) = accessedBy.get(sym).contains(accessed)
       owner.info.decl(accessorName).suchThat(refersToAccessed).symbol.orElse {
         val acc = newAccessorSymbol(owner, accessorName, accessorInfo, accessed.span)
@@ -92,15 +92,15 @@ abstract class AccessProxies {
     }
 
     /** Rewire reference to refer to `accessor` symbol */
-    private def rewire(reference: RefTree, accessor: Symbol)(implicit ctx: Context): Tree = {
+    private def rewire(reference: RefTree, accessor: Symbol)(using Context): Tree = {
       reference match {
         case Select(qual, _) if qual.tpe.derivesFrom(accessor.owner) => qual.select(accessor)
         case _ => ref(accessor)
       }
     }.withSpan(reference.span)
 
     /** Given a reference to a getter accessor, the corresponding setter reference */
-    def useSetter(getterRef: Tree)(implicit ctx: Context): Tree = getterRef match {
+    def useSetter(getterRef: Tree)(using Context): Tree = getterRef match {
       case getterRef: RefTree =>
         val getter = getterRef.symbol.asTerm
         val accessed = accessedBy(getter)
@@ -126,7 +126,7 @@ abstract class AccessProxies {
       *  @param reference    The original reference to the non-public symbol
       *  @param onLHS        The reference is on the left-hand side of an assignment
       */
-    def useAccessor(reference: RefTree)(implicit ctx: Context): Tree = {
+    def useAccessor(reference: RefTree)(using Context): Tree = {
       val accessed = reference.symbol.asTerm
       var accessorClass = hostForAccessorOf(accessed: Symbol)
       if (accessorClass.exists) {
@@ -142,7 +142,7 @@ abstract class AccessProxies {
     }
 
     /** Replace tree with a reference to an accessor if needed */
-    def accessorIfNeeded(tree: Tree)(implicit ctx: Context): Tree = tree match {
+    def accessorIfNeeded(tree: Tree)(using Context): Tree = tree match {
       case tree: RefTree if needsAccessor(tree.symbol) =>
         if (tree.symbol.isConstructor) {
           ctx.error("Implementation restriction: cannot use private constructors in inlineable methods", tree.sourcePos)
@@ -158,7 +158,7 @@ object AccessProxies {
   /** Where an accessor for the `accessed` symbol should be placed.
    *  This is the closest enclosing class that has `accessed` as a member.
    */
-  def hostForAccessorOf(accessed: Symbol)(implicit ctx: Context): Symbol = {
+  def hostForAccessorOf(accessed: Symbol)(using Context): Symbol = {
     def recur(cls: Symbol): Symbol =
       if (!cls.exists) NoSymbol
       else if cls.derivesFrom(accessed.owner)

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

@@ -22,7 +22,7 @@ class ArrayApply extends MiniPhase {
 
   override def phaseName: String = "arrayApply"
 
-  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree =
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
     if (tree.symbol.name == nme.apply && tree.symbol.owner == defn.ArrayModule.moduleClass) // Is `Array.apply`
       tree.args match {
         case StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: ct :: Nil
@@ -44,7 +44,7 @@ class ArrayApply extends MiniPhase {
    *  - `ClassTag.apply(java.lang.XYZ.Type)` for boxed primitives `XYZ``
    *  - `ClassTag.XYZ` for primitive types
    */
-  private def elideClassTag(ct: Tree)(implicit ctx: Context): Boolean = ct match {
+  private def elideClassTag(ct: Tree)(using Context): Boolean = ct match {
     case Apply(_, rc :: Nil) if ct.symbol == defn.ClassTagModule_apply =>
       rc match {
         case _: Literal => true // ClassTag.apply(classOf[XYZ])
@@ -60,7 +60,7 @@ class ArrayApply extends MiniPhase {
   }
 
   object StripAscription {
-    def unapply(tree: Tree)(implicit ctx: Context): Some[Tree] = tree match {
+    def unapply(tree: Tree)(using Context): Some[Tree] = tree match {
       case Typed(expr, _) => unapply(expr)
       case _ => Some(tree)
     }

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

@@ -24,7 +24,7 @@ class ArrayConstructors extends MiniPhase {
 
   override def phaseName: String = "arrayConstructors"
 
-  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = {
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree = {
     def expand(elemType: Type, dims: List[Tree]) =
       tpd.newArray(elemType, tree.tpe, tree.span, JavaSeqLiteral(dims, TypeTree(defn.IntClass.typeRef)))
 

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

@@ -36,7 +36,7 @@ class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer { this
 
   override def phaseName: String = AugmentScala2Traits.name
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
+  override def transformTemplate(impl: Template)(using Context): Template = {
     val cls = impl.symbol.owner.asClass
     for (mixin <- cls.mixins) {
       val erasedMixin = TypeErasure.normalizeClass(mixin)
@@ -46,7 +46,7 @@ class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer { this
     impl
   }
 
-  private def augmentScala2Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = {
+  private def augmentScala2Trait(mixin: ClassSymbol)(using Context): Unit = {
     def traitSetter(getter: TermSymbol) =
       getter.copy(
         name = getter.ensureNotPrivate.name

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

@@ -11,14 +11,14 @@ import util.Spans.Span
 import util.SourcePosition
 
 /** A helper class for generating bridge methods in class `root`. */
-class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Context) {
+class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   import ast.tpd._
 
   assert(ctx.phase == ctx.erasurePhase.next)
   private val preErasureCtx = ctx.withPhase(ctx.erasurePhase)
   private lazy val elimErasedCtx = ctx.withPhase(ctx.elimErasedValueTypePhase.next)
 
-  private class BridgesCursor(implicit ctx: Context) extends OverridingPairs.Cursor(root) {
+  private class BridgesCursor(using Context) extends OverridingPairs.Cursor(root) {
 
     /** Only use the superclass of `root` as a parent class. This means
      *  overriding pairs that have a common implementation in a trait parent
@@ -57,9 +57,9 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
     def bridgeExists =
       bridgesScope.lookupAll(member.name).exists(bridge =>
         bridgeTarget(bridge) == member && bridge.signature == other.signature)
-    def info(sym: Symbol)(implicit ctx: Context) = sym.info
+    def info(sym: Symbol)(using Context) = sym.info
     def desc(sym: Symbol)= {
-      val infoStr = info(sym)(preErasureCtx) match {
+      val infoStr = info(sym)(using preErasureCtx) match {
         case ExprType(info) => i": $info"
         case info => info.show
       }
@@ -69,7 +69,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
       if (!member.info.matches(other.info))
         ctx.error(em"""bridge generated for member ${desc(member)}
                       |which overrides ${desc(other)}
-                      |clashes with definition of the member itself; both have erased type ${info(member)(elimErasedCtx)}."""",
+                      |clashes with definition of the member itself; both have erased type ${info(member)(using elimErasedCtx)}."""",
                   bridgePosFor(member))
     }
     else if (!bridgeExists)
@@ -112,7 +112,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
    *  time deferred methods in `stats` that are replaced by a bridge with the same signature.
    */
   def add(stats: List[untpd.Tree]): List[untpd.Tree] =
-    val opc = new BridgesCursor()(preErasureCtx)
+    val opc = new BridgesCursor()(using preErasureCtx)
     val ectx = ctx.withPhase(thisPhase)
     while opc.hasNext do
       if !opc.overriding.is(Deferred) then

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

@@ -25,7 +25,7 @@ class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer
 
   override def phaseName: String = ByNameClosures.name
 
-  override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = {
+  override def mkByNameClosure(arg: Tree, argType: Type)(using Context): Tree = {
     val meth = ctx.newSymbol(
       ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType))
     Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase)).withSpan(arg.span)

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

@@ -46,7 +46,7 @@ class CacheAliasImplicits extends MiniPhase with IdentityDenotTransformer { this
 
   override def phaseName: String = CacheAliasImplicits.name
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
     val sym = tree.symbol
     val isCached = !sym.is(Inline) && {
       sym.info match {

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

@@ -27,12 +27,12 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     // lifting tries changes what variables are considered to be captured
 
   private[this] var Captured: Store.Location[collection.Set[Symbol]] = _
-  private def captured(implicit ctx: Context) = ctx.store(Captured)
+  private def captured(using Context) = ctx.store(Captured)
 
   override def initContext(ctx: FreshContext): Unit =
     Captured = ctx.addLocation(Set.empty)
 
-  private class RefInfo(implicit ctx: Context) {
+  private class RefInfo(using Context) {
     /** The classes for which a Ref type exists. */
     val refClassKeys: collection.Set[Symbol] =
       defn.ScalaNumericValueClasses() `union` Set(defn.BooleanClass, defn.ObjectClass)
@@ -48,14 +48,14 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   }
 
   private var myRefInfo: RefInfo = null
-  private def refInfo(implicit ctx: Context) = {
+  private def refInfo(using Context) = {
     if (myRefInfo == null) myRefInfo = new RefInfo()
     myRefInfo
   }
 
   private class CollectCaptured extends TreeTraverser {
     private val captured = mutable.HashSet[Symbol]()
-    def traverse(tree: Tree)(implicit ctx: Context) = tree match {
+    def traverse(tree: Tree)(using Context) = tree match {
       case id: Ident =>
         val sym = id.symbol
         if (sym.is(Mutable, butNot = Method) && sym.owner.isTerm) {
@@ -68,13 +68,13 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
       case _ =>
         traverseChildren(tree)
     }
-    def runOver(tree: Tree)(implicit ctx: Context): collection.Set[Symbol] = {
+    def runOver(tree: Tree)(using Context): collection.Set[Symbol] = {
       traverse(tree)
       captured
     }
   }
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = {
+  override def prepareForUnit(tree: Tree)(using Context): Context = {
     val captured = (new CollectCaptured)
       .runOver(ctx.compilationUnit.tpdTree)(using ctx.withPhase(thisPhase))
     ctx.fresh.updateStore(Captured, captured)
@@ -83,14 +83,14 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   /** The {Volatile|}{Int|Double|...|Object}Ref class corresponding to the class `cls`,
     *  depending on whether the reference should be @volatile
     */
-  def refClass(cls: Symbol, isVolatile: Boolean)(implicit ctx: Context): Symbol = {
+  def refClass(cls: Symbol, isVolatile: Boolean)(using Context): Symbol = {
     val refMap = if (isVolatile) refInfo.volatileRefClass else refInfo.refClass
     if (cls.isClass)
       refMap.getOrElse(cls, refMap(defn.ObjectClass))
     else refMap(defn.ObjectClass)
   }
 
-  override def prepareForValDef(vdef: ValDef)(implicit ctx: Context): Context = {
+  override def prepareForValDef(vdef: ValDef)(using Context): Context = {
     val sym = vdef.symbol(using ctx.withPhase(thisPhase))
     if (captured contains sym) {
       val newd = sym.denot(using ctx.withPhase(thisPhase)).copySymDenotation(
@@ -102,7 +102,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     ctx
   }
 
-  override def transformValDef(vdef: ValDef)(implicit ctx: Context): Tree = {
+  override def transformValDef(vdef: ValDef)(using Context): Tree = {
     val vble = vdef.symbol
     if (captured.contains(vble)) {
       def boxMethod(name: TermName): Tree =
@@ -114,7 +114,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     else vdef
   }
 
-  override def transformIdent(id: Ident)(implicit ctx: Context): Tree = {
+  override def transformIdent(id: Ident)(using Context): Tree = {
     val vble = id.symbol
     if (captured.contains(vble))
       id.select(nme.elem).ensureConforms(vble.denot(using ctx.withPhase(thisPhase)).info)
@@ -137,7 +137,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     *  Also: If the ref type lhs is followed by a cast (can be an artifact of nested translation),
     *  drop the cast.
     */
-  override def transformAssign(tree: Assign)(implicit ctx: Context): Tree = {
+  override def transformAssign(tree: Assign)(using Context): Tree = {
     def recur(lhs: Tree): Tree = lhs match {
       case TypeApply(Select(qual, nme.asInstanceOf_), _) =>
         val Select(_, nme.elem) = qual

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

@@ -44,7 +44,7 @@ class CheckReentrant extends MiniPhase {
   private val scalaJSIRPackageClass = new CtxLazy(
     summon[Context].getPackageClassIfDefined("org.scalajs.ir"))
 
-  def isIgnored(sym: Symbol)(implicit ctx: Context): Boolean =
+  def isIgnored(sym: Symbol)(using Context): Boolean =
     sym.hasAnnotation(sharableAnnot()) ||
     sym.hasAnnotation(unsharedAnnot()) ||
     sym.topLevelClass.owner == scalaJSIRPackageClass() ||
@@ -54,14 +54,14 @@ class CheckReentrant extends MiniPhase {
       // enum values are initialized eagerly before use
       // in the long run, we should make them vals
 
-  def scanning(sym: Symbol)(op: => Unit)(implicit ctx: Context): Unit = {
+  def scanning(sym: Symbol)(op: => Unit)(using Context): Unit = {
     ctx.log(i"${"  " * indent}scanning $sym")
     indent += 1
     try op
     finally indent -= 1
   }
 
-  def addVars(cls: ClassSymbol)(implicit ctx: Context): Unit =
+  def addVars(cls: ClassSymbol)(using Context): Unit =
     if (!seen.contains(cls) && !isIgnored(cls)) {
       seen += cls
       scanning(cls) {
@@ -82,7 +82,7 @@ class CheckReentrant extends MiniPhase {
       }
     }
 
-  override def transformTemplate(tree: Template)(implicit ctx: Context): Tree = {
+  override def transformTemplate(tree: Template)(using Context): Tree = {
     if (ctx.settings.YcheckReentrant.value && tree.symbol.owner.isStaticOwner)
       addVars(tree.symbol.owner.asClass)
     tree