Convert transform classes (4)

Author: odersky

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

@@ -114,7 +114,7 @@ class TailRec extends MiniPhase {
 
   override def runsAfter: Set[String] = Set(Erasure.name) // tailrec assumes erased types
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
     val method = tree.symbol
     val mandatory = method.hasAnnotation(defn.TailrecAnnot)
     def noTailTransform(failureReported: Boolean) = {
@@ -222,7 +222,7 @@ class TailRec extends MiniPhase {
 
     /** The `tailLabelN` label symbol, used to encode a `continue` from the infinite `while` loop. */
     private var myContinueLabel: Symbol = _
-    def continueLabel(implicit ctx: Context): Symbol = {
+    def continueLabel(using Context): Symbol = {
       if (myContinueLabel == null)
         myContinueLabel = ctx.newSymbol(method, TailLabelName.fresh(), Label, defn.UnitType)
       myContinueLabel
@@ -235,7 +235,7 @@ class TailRec extends MiniPhase {
     /** The replacement `var`s for the params in `rewrittenParamSyms`. */
     var varsForRewrittenParamSyms: List[Symbol] = Nil
 
-    private def getVarForRewrittenThis()(implicit ctx: Context): Symbol =
+    private def getVarForRewrittenThis()(using Context): Symbol =
       varForRewrittenThis match {
         case Some(sym) => sym
         case none =>
@@ -247,7 +247,7 @@ class TailRec extends MiniPhase {
           sym
       }
 
-    private def getVarForRewrittenParam(param: Symbol)(implicit ctx: Context): Symbol =
+    private def getVarForRewrittenParam(param: Symbol)(using Context): Symbol =
       rewrittenParamSyms.indexOf(param) match {
         case -1 =>
           val sym = ctx.newSymbol(method, TailLocalName.fresh(param.name.toTermName), Synthetic | Mutable, param.info)
@@ -263,7 +263,7 @@ class TailRec extends MiniPhase {
     private var inTailPosition = true
 
     /** Rewrite this tree to contain no tail recursive calls */
-    def transform(tree: Tree, tailPosition: Boolean)(implicit ctx: Context): Tree =
+    def transform(tree: Tree, tailPosition: Boolean)(using Context): Tree =
       if (inTailPosition == tailPosition) transform(tree)
       else {
         val saved = inTailPosition
@@ -272,7 +272,7 @@ class TailRec extends MiniPhase {
         finally inTailPosition = saved
       }
 
-    def yesTailTransform(tree: Tree)(implicit ctx: Context): Tree =
+    def yesTailTransform(tree: Tree)(using Context): Tree =
       transform(tree, tailPosition = true)
 
     /** If not in tail position a tree traversal may not be needed.
@@ -285,15 +285,15 @@ class TailRec extends MiniPhase {
     private def isTraversalNeeded =
       isMandatory || tailPositionLabeledSyms.nonEmpty
 
-    def noTailTransform(tree: Tree)(implicit ctx: Context): Tree =
+    def noTailTransform(tree: Tree)(using Context): Tree =
       if (isTraversalNeeded) transform(tree, tailPosition = false)
       else tree
 
-    def noTailTransforms[Tr <: Tree](trees: List[Tr])(implicit ctx: Context): List[Tr] =
+    def noTailTransforms[Tr <: Tree](trees: List[Tr])(using Context): List[Tr] =
       if (isTraversalNeeded) trees.mapConserve(noTailTransform).asInstanceOf[List[Tr]]
       else trees
 
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+    override def transform(tree: Tree)(using Context): Tree = {
       /* Rewrite an Apply to be considered for tail call transformation. */
       def rewriteApply(tree: Apply): Tree = {
         val arguments = noTailTransforms(tree.args)

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

@@ -22,21 +22,21 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
   import ast.tpd._
 
   /** The info of the tree's symbol before it is potentially transformed in this phase */
-  private def originalDenotation(tree: Tree)(implicit ctx: Context) =
+  private def originalDenotation(tree: Tree)(using Context) =
     tree.symbol.denot(using ctx.withPhase(thisPhase))
 
   /** If denotation had an ExprType before, it now gets a function type */
-  protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context): Boolean =
+  protected def exprBecomesFunction(symd: SymDenotation)(using Context): Boolean =
     symd.is(Param) || symd.is(ParamAccessor, butNot = Method)
 
-  protected def isByNameRef(tree: Tree)(implicit ctx: Context): Boolean = {
+  protected def isByNameRef(tree: Tree)(using Context): Boolean = {
     val origDenot = originalDenotation(tree)
     origDenot.info.isInstanceOf[ExprType] && exprBecomesFunction(origDenot)
   }
 
-  def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = unsupported(i"mkClosure($arg)")
+  def mkByNameClosure(arg: Tree, argType: Type)(using Context): Tree = unsupported(i"mkClosure($arg)")
 
-  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
+  override def transformApply(tree: Apply)(using Context): Tree =
     trace(s"transforming ${tree.show} at phase ${ctx.phase}", show = true) {
 
       def transformArg(arg: Tree, formal: Type): Tree = formal.dealias match {

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

@@ -16,13 +16,13 @@ class TransformWildcards extends MiniPhase with IdentityDenotTransformer {
 
   override def phaseName: String = "transformWildcards"
 
-  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit =
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
     tree match {
       case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs))
       case _ =>
     }
 
-  override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree =
+  override def transformValDef(tree: ValDef)(using Context): Tree =
     if (ctx.owner.isClass) tree
     else cpy.ValDef(tree)(rhs = tree.rhs.wildcardToDefault)
 }

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

@@ -11,7 +11,7 @@ object TreeExtractors {
 
   /** Match arg1.op(arg2) and extract (arg1, op.symbol, arg2) */
   object BinaryOp {
-    def unapply(t: Tree)(implicit ctx: Context): Option[(Tree, Symbol, Tree)] = t match {
+    def unapply(t: Tree)(using Context): Option[(Tree, Symbol, Tree)] = t match {
       case Apply(sel @ Select(arg1, _), List(arg2)) =>
         Some((arg1, sel.symbol, arg2))
       case _ =>
@@ -21,7 +21,7 @@ object TreeExtractors {
 
  /** Match new C(args) and extract (C, args) */
   object NewWithArgs {
-    def unapply(t: Tree)(implicit ctx: Context): Option[(Type, List[Tree])] = t match {
+    def unapply(t: Tree)(using Context): Option[(Type, List[Tree])] = t match {
       case Apply(Select(New(_), nme.CONSTRUCTOR), args) =>
         Some((t.tpe, args))
       case _ =>
@@ -34,7 +34,7 @@ object TreeExtractors {
    *  Match v.underlying() and extract v
    */
   object ValueClassUnbox {
-    def unapply(t: Tree)(implicit ctx: Context): Option[Tree] = t match {
+    def unapply(t: Tree)(using Context): Option[Tree] = t match {
       case Apply(sel @ Select(ref, _), Nil) =>
         val sym = ref.tpe.widenDealias.typeSymbol
         if (isDerivedValueClass(sym) && (sel.symbol eq valueClassUnbox(sym.asClass)))

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

@@ -53,30 +53,30 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
   protected def isInQuoteOrSplice: Boolean = inQuoteOrSplice
 
   /** Enter staging level of symbol defined by `tree` */
-  private def markSymbol(sym: Symbol)(implicit ctx: Context): Unit =
+  private def markSymbol(sym: Symbol)(using Context): Unit =
     if level != 0 && !levelOfMap.contains(sym) then
       levelOfMap(sym) = level
       enteredSyms = sym :: enteredSyms
 
   /** Enter staging level of symbol defined by `tree`, if applicable. */
-  private def markDef(tree: Tree)(implicit ctx: Context): Unit = tree match {
+  private def markDef(tree: Tree)(using Context): Unit = tree match {
     case tree: DefTree => markSymbol(tree.symbol)
     case _ =>
   }
 
   /** Transform the quote `quote` which contains the quoted `body`. */
-  protected def transformQuotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree =
+  protected def transformQuotation(body: Tree, quote: Tree)(using Context): Tree =
     quote match {
       case quote: Apply => cpy.Apply(quote)(quote.fun, body :: Nil)
       case quote: TypeApply => cpy.TypeApply(quote)(quote.fun, body :: Nil)
     }
 
   /** Transform the splice `splice` which contains the spliced `body`. */
-  protected def transformSplice(body: Tree, splice: Tree)(implicit ctx: Context): Tree
+  protected def transformSplice(body: Tree, splice: Tree)(using Context): Tree
 
-  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 reporting.trace(i"StagingTransformer.transform $tree at $level", staging, show = true) {
       def mapOverTree(lastEntered: List[Symbol]) =
         try super.transform(tree)
@@ -149,7 +149,7 @@ object TreeMapWithStages {
   private val LevelOfKey = new Property.Key[mutable.HashMap[Symbol, Int]]
 
   /** Initial context for a StagingTransformer transformation. */
-  def freshStagingContext(implicit ctx: Context): Context =
+  def freshStagingContext(using Context): Context =
     ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int])
 
 }

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

@@ -46,7 +46,7 @@ class TryCatchPatterns extends MiniPhase {
 
   override def runsAfter: Set[String] = Set(ElimRepeated.name)
 
-  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
+  override def checkPostCondition(tree: Tree)(using Context): Unit = tree match {
     case Try(_, cases, _) =>
       cases.foreach {
         case CaseDef(Typed(_, _), guard, _) => assert(guard.isEmpty, "Try case should not contain a guard.")
@@ -57,20 +57,20 @@ class TryCatchPatterns extends MiniPhase {
     case _ =>
   }
 
-  override def transformTry(tree: Try)(implicit ctx: Context): Tree = {
+  override def transformTry(tree: Try)(using Context): Tree = {
     val (tryCases, patternMatchCases) = tree.cases.span(isCatchCase)
     val fallbackCase = mkFallbackPatterMatchCase(patternMatchCases, tree.span)
     cpy.Try(tree)(cases = tryCases ++ fallbackCase)
   }
 
   /** Is this pattern node a catch-all or type-test pattern? */
-  private def isCatchCase(cdef: CaseDef)(implicit ctx: Context): Boolean = cdef match {
+  private def isCatchCase(cdef: CaseDef)(using Context): Boolean = cdef match {
     case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _)          => isSimpleThrowable(tpt.tpe)
     case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) => isSimpleThrowable(tpt.tpe)
     case _                                                               => isDefaultCase(cdef)
   }
 
-  private def isSimpleThrowable(tp: Type)(implicit ctx: Context): Boolean = tp.stripAnnots match {
+  private def isSimpleThrowable(tp: Type)(using Context): Boolean = tp.stripAnnots match {
     case tp @ TypeRef(pre, _) =>
       (pre == NoPrefix || pre.widen.typeSymbol.isStatic) && // Does not require outer class check
       !tp.symbol.is(Flags.Trait) && // Traits not supported by JVM

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

@@ -23,7 +23,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   def phaseName: String = "genericTuples"
 
-  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree =
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
     if (!tree.symbol.exists || tree.symbol.owner != defn.RuntimeTupleModuleClass) tree
     else if (tree.symbol == defn.RuntimeTuple_cons) transformTupleCons(tree)
     else if (tree.symbol == defn.RuntimeTuple_tail) transformTupleTail(tree)
@@ -33,7 +33,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
     else if (tree.symbol == defn.RuntimeTuple_toArray) transformTupleToArray(tree)
     else tree
 
-  private def transformTupleCons(tree: tpd.Apply)(implicit ctx: Context): Tree = {
+  private def transformTupleCons(tree: tpd.Apply)(using Context): Tree = {
     val head :: tail :: Nil = tree.args
     defn.tupleTypes(tree.tpe.widenTermRefExpr.dealias) match {
       case Some(tpes) =>
@@ -61,7 +61,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
     }
   }
 
-  private def transformTupleTail(tree: tpd.Apply)(implicit ctx: Context): Tree = {
+  private def transformTupleTail(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, tup :: Nil) = tree
     defn.tupleTypes(tup.tpe.widenTermRefExpr.dealias, MaxTupleArity + 1) match {
       case Some(tpes) =>
@@ -98,13 +98,13 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
     }
   }
 
-  private def transformTupleSize(tree: tpd.Apply)(implicit ctx: Context): Tree =
+  private def transformTupleSize(tree: tpd.Apply)(using Context): Tree =
     tree.tpe.tryNormalize match {
       case tp: ConstantType => Literal(tp.value)
       case _ => tree
     }
 
-  private def transformTupleConcat(tree: tpd.Apply)(implicit ctx: Context): Tree = {
+  private def transformTupleConcat(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, self :: that :: Nil) = tree
     (defn.tupleTypes(self.tpe.widenTermRefExpr.dealias), defn.tupleTypes(that.tpe.widenTermRefExpr.dealias)) match {
       case (Some(tpes1), Some(tpes2)) =>
@@ -139,7 +139,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
     }
   }
 
-  private def transformTupleApply(tree: tpd.Apply)(implicit ctx: Context): Tree = {
+  private def transformTupleApply(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, tup :: nTree :: Nil) = tree
     (defn.tupleTypes(tup.tpe.widenTermRefExpr.dealias), nTree.tpe) match {
       case (Some(tpes), nTpe: ConstantType) =>
@@ -166,7 +166,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
     }
   }
 
-  private def transformTupleToArray(tree: tpd.Apply)(implicit ctx: Context): Tree = {
+  private def transformTupleToArray(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, tup :: Nil) = tree
     defn.tupleTypes(tup.tpe.widen, MaxTupleArity) match {
       case Some(tpes) =>
@@ -188,14 +188,14 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
   }
 
   /** Create a TupleN (1 <= N < 23) from the elements */
-  private def knownTupleFromElements(tpes: List[Type], elements: List[Tree])(implicit ctx: Context) = {
+  private def knownTupleFromElements(tpes: List[Type], elements: List[Tree])(using Context) = {
     val size = elements.size
     assert(0 < size && size <= MaxTupleArity)
     val tupleModule = defn.TupleType(size).classSymbol.companionModule
     ref(tupleModule).select(nme.apply).appliedToTypes(tpes).appliedToArgs(elements)
   }
 
-  private def knownTupleFromIterator(size: Int, it: Tree)(implicit ctx: Context): Tree =
+  private def knownTupleFromIterator(size: Int, it: Tree)(using Context): Tree =
     if (size == 0)
       // EmptyTuple for empty tuple
       ref(defn.EmptyTupleModule.termRef) // TODO should this code be here? Or assert(size > specializedSize)
@@ -214,7 +214,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
       // TupleXXL.fromIterator(it)
       ref(defn.TupleXXL_fromIterator).appliedTo(it)
 
-  private def tupleSelectors(tup: Tree, size: Int)(implicit ctx: Context): List[Tree] =
+  private def tupleSelectors(tup: Tree, size: Int)(using Context): List[Tree] =
     (0 until size).map(i => tup.select(nme.selectorName(i))).toList
 }
 

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

@@ -56,7 +56,7 @@ object TypeTestsCasts {
   def checkable(X: Type, P: Type, span: Span)(using Context): Boolean = {
     def isAbstract(P: Type) = !P.dealias.typeSymbol.isClass
 
-    def replaceP(tp: Type)(implicit ctx: Context) = new TypeMap {
+    def replaceP(tp: Type)(using Context) = new TypeMap {
       def apply(tp: Type) = tp match {
         case tref: TypeRef if tref.typeSymbol.isPatternBound =>
           WildcardType
@@ -66,7 +66,7 @@ object TypeTestsCasts {
       }
     }.apply(tp)
 
-    def replaceX(tp: Type)(implicit ctx: Context) = new TypeMap {
+    def replaceX(tp: Type)(using Context) = new TypeMap {
       def apply(tp: Type) = tp match {
         case tref: TypeRef if tref.typeSymbol.isPatternBound =>
           if (variance == 1) tref.info.hiBound
@@ -77,7 +77,7 @@ object TypeTestsCasts {
     }.apply(tp)
 
     /** Approximate type parameters depending on variance */
-    def stripTypeParam(tp: Type)(implicit ctx: Context) = new ApproximatingTypeMap {
+    def stripTypeParam(tp: Type)(using Context) = new ApproximatingTypeMap {
       def apply(tp: Type): Type = tp match {
         case _: MatchType =>
           tp // break cycles

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

@@ -15,26 +15,26 @@ object TypeUtils {
    */
   implicit class TypeUtilsOps(val self: Type) extends AnyVal {
 
-    def isErasedValueType(implicit ctx: Context): Boolean =
+    def isErasedValueType(using Context): Boolean =
       self.isInstanceOf[ErasedValueType]
 
-    def isPrimitiveValueType(implicit ctx: Context): Boolean =
+    def isPrimitiveValueType(using Context): Boolean =
       self.classSymbol.isPrimitiveValueClass
 
-    def ensureMethodic(implicit ctx: Context): Type = self match {
+    def ensureMethodic(using Context): Type = self match {
       case self: MethodicType => self
       case _ => if (ctx.erasedTypes) MethodType(Nil, self) else ExprType(self)
     }
 
-    def widenToParents(implicit ctx: Context): Type = self.parents match {
+    def widenToParents(using Context): Type = self.parents match {
       case Nil => self
       case ps => ps.reduceLeft(AndType(_, _))
     }
 
     /** The arity of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs,
      *  or -1 if this is not a tuple type.
      */
-    def tupleArity(implicit ctx: Context): Int = self match {
+    def tupleArity(using Context): Int = self match {
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         val arity = tl.tupleArity
         if (arity < 0) arity else arity + 1
@@ -47,7 +47,7 @@ object TypeUtils {
     }
 
     /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs */
-    def tupleElementTypes(implicit ctx: Context): List[Type] = self match {
+    def tupleElementTypes(using Context): List[Type] = self match {
       case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         hd :: tl.tupleElementTypes
       case self: TermRef if self.symbol == defn.EmptyTupleModule =>
@@ -59,15 +59,15 @@ object TypeUtils {
     }
 
     /** The `*:` equivalent of an instance of a Tuple class */
-    def toNestedPairs(implicit ctx: Context): Type =
+    def toNestedPairs(using Context): Type =
       TypeOps.nestedPairs(tupleElementTypes)
 
-    def refinedWith(name: Name, info: Type)(implicit ctx: Context) = RefinedType(self, name, info)
+    def refinedWith(name: Name, info: Type)(using Context) = RefinedType(self, name, info)
 
     /** The TermRef referring to the companion of the underlying class reference
      *  of this type, while keeping the same prefix.
      */
-    def companionRef(implicit ctx: Context): TermRef = self match {
+    def companionRef(using Context): TermRef = self match {
       case self @ TypeRef(prefix, _) if self.symbol.isClass =>
         prefix.select(self.symbol.companionModule).asInstanceOf[TermRef]
       case self: TypeProxy =>