Simplify and reuse using migration rewrites

Author: jchyb

compiler/src/dotty/tools/dotc/core/NamerOps.scala

@@ -88,10 +88,10 @@ object NamerOps:
       case Nil =>
         resultType
       case TermSymbols(params) :: paramss1 =>
-        val (isContextual, isImplicit, implicitToGiven) =
-          if params.isEmpty then (false, false, false)
-          else (params.head.is(Given), params.head.is(Implicit), params.head.isImplicitRewrittenToGiven)
-        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit, implicitToGiven = implicitToGiven)
+        val (isContextual, isImplicit) =
+          if params.isEmpty then (false, false)
+          else (params.head.is(Given), params.head.is(Implicit))
+        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit)
         if isJava then
           for param <- params do
             if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -404,10 +404,6 @@ object Symbols extends SymUtils {
     def paramVariance(using Context): Variance = denot.variance
     def paramRef(using Context): TypeRef = denot.typeRef
 
-     /** Was it an implicit, currently rewritten into a given with `-Yimplicit-to-given` */
-    def isImplicitRewrittenToGiven(using Context): Boolean =
-      ctx.settings.YimplicitToGiven.value && denot.flags.is(Implicit) && this.isDefinedInSource
-
     /** Copy a symbol, overriding selective fields.
      *  Note that `coord` and `compilationUnitInfo` will be set from the fields in `owner`, not
      *  the fields in `sym`. */

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -478,9 +478,6 @@ object Types extends TypeUtils {
     /** Is this a Method or PolyType which has implicit or contextual parameters? */
     def isImplicitMethod: Boolean = false
 
-    /** Is this method parameter list implicit, currently rewritten into a given with `-Yimplicit-to-given`? */
-    def isImplicitMethodRewrittenToContextual: Boolean = false
-
     /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
     def isContextualMethod: Boolean = false
 
@@ -4157,16 +4154,13 @@ object Types extends TypeUtils {
     def companion: MethodTypeCompanion
 
     final override def isImplicitMethod: Boolean =
-      companion.eq(ImplicitMethodType) || companion.eq(ImplicitRewrittenToContextualMethodType) || isContextualMethod
+      companion.eq(ImplicitMethodType) || isContextualMethod
     final override def hasErasedParams(using Context): Boolean =
       paramInfos.exists(p => p.hasAnnotation(defn.ErasedParamAnnot))
 
     final override def isContextualMethod: Boolean =
       companion.eq(ContextualMethodType)
 
-    final override def isImplicitMethodRewrittenToContextual: Boolean =
-      companion.eq(ImplicitRewrittenToContextualMethodType)
-
     def erasedParams(using Context): List[Boolean] =
       paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot))
 
@@ -4298,16 +4292,14 @@ object Types extends TypeUtils {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, implicitToGiven: Boolean = false): MethodTypeCompanion =
-      if (implicitToGiven) ImplicitRewrittenToContextualMethodType
-      else if (isContextual) ContextualMethodType
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false): MethodTypeCompanion =
+      if (isContextual) ContextualMethodType
       else if (isImplicit) ImplicitMethodType
       else MethodType
   }
 
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
-  object ImplicitRewrittenToContextualMethodType extends MethodTypeCompanion("ImplicitRewrittenToContextualMethodType")
 
   /** A ternary extractor for MethodType */
   object MethodTpe {

compiler/src/dotty/tools/dotc/typer/Migrations.scala

@@ -132,23 +132,81 @@ trait Migrations:
     if tp.companion == ImplicitMethodType && pt.applyKind != ApplyKind.Using && pt.args.nonEmpty then
       // The application can only be rewritten if it uses parentheses syntax.
       // See issue #22927 and related tests.
-      val hasParentheses =
-        ctx.source.content
-          .slice(tree.span.end, pt.args.head.span.start)
-          .exists(_ == '(')
+      val hasParentheses = checkParentheses(tree, pt)
       val rewriteMsg =
         if hasParentheses then
           Message.rewriteNotice("This code", mversion.patchFrom)
         else
           ""
       report.errorOrMigrationWarning(
         em"""Implicit parameters should be provided with a `using` clause.$rewriteMsg
-            |To disable the warning, please use the following option: 
+            |To disable the warning, please use the following option:
             |  "-Wconf:msg=Implicit parameters should be provided with a `using` clause:s"
-            |""", 
+            |""",
         pt.args.head.srcPos, mversion)
       if hasParentheses && mversion.needsPatch then
-        patch(Span(pt.args.head.span.start), "using ")
+        patchImplicitParams(tree, pt)
   end implicitParams
 
+  private def checkParentheses(tree: Tree, pt: FunProto)(using Context): Boolean =
+    ctx.source.content
+      .slice(tree.span.end, pt.args.head.span.start)
+      .exists(_ == '(')
+
+  private def patchImplicitParams(tree: Tree, pt: FunProto)(using Context): Unit =
+    patch(Span(pt.args.head.span.start), "using ")
+
+  object ImplicitToGiven:
+    def valDef(vdef: ValDef)(using Context): Unit =
+      if ctx.settings.YimplicitToGiven.value
+        && vdef.symbol.is(Implicit)
+        && !vdef.symbol.isParamOrAccessor
+      then
+        val implicitSpan =
+          vdef.mods.mods.collectFirst {
+            case mod: untpd.Mod.Implicit => mod.span
+          }.get
+        patch(
+          Span(implicitSpan.start, implicitSpan.end + 1),
+          ""
+        )
+        patch(
+          Span(vdef.mods.mods.last.span.end + 1, vdef.namePos.span.start), "given "
+        )
+
+    def defDef(ddef: DefDef)(using Context): Unit =
+      if
+        ctx.settings.YimplicitToGiven.value
+        && ddef.symbol.is(Implicit)
+        && !ddef.symbol.isParamOrAccessor
+        && !ddef.symbol.isOldStyleImplicitConversion()
+      then
+        val implicitSpan =
+          ddef.mods.mods.collectFirst {
+            case mod: untpd.Mod.Implicit => mod.span
+          }.get
+        patch(
+          Span(implicitSpan.start, implicitSpan.end + 1), ""
+        )
+        patch(
+          Span(ddef.mods.mods.last.span.end + 1, ddef.namePos.span.start), "given "
+        )
+        ddef.tpt match
+          case refinedType: untpd.RefinedTypeTree =>
+            patch(refinedType.span.startPos, "(")
+            patch(refinedType.span.endPos, ")")
+          case _ =>
+
+    def implicitParams(tree: Tree, tp: MethodOrPoly, pt: FunProto)(using Context): Unit =
+      if
+        ctx.settings.YimplicitToGiven.value
+        && !mv.ExplicitContextBoundArgument.needsPatch // let's not needlessly repeat the patch
+        && tp.companion == ImplicitMethodType
+        && pt.applyKind != ApplyKind.Using
+        && pt.args.nonEmpty
+        && checkParentheses(tree, pt)
+      then
+          patchImplicitParams(tree, pt)
+
+
 end Migrations

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2885,18 +2885,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     postProcessInfo(vdef1, sym)
     vdef1.setDefTree
 
-    if ctx.isTyper && vdef1.symbol.isImplicitRewrittenToGiven && !vdef1.symbol.isParamOrAccessor then
-      val implicitSpan =
-        vdef1.mods.mods.collectFirst {
-          case mod: Mod.Implicit => mod.span
-        }.get
-      patch(
-        Span(implicitSpan.start, implicitSpan.end + 1),
-        ""
-      )
-      patch(
-        Span(vdef1.mods.mods.last.span.end + 1, vdef1.namePos.span.start), "given "
-      )
+    migrate(ImplicitToGiven.valDef(vdef1))
 
     val nnInfo = rhs1.notNullInfo
     vdef1.withNotNullInfo(if sym.is(Lazy) then nnInfo.retractedInfo else nnInfo)
@@ -3010,27 +2999,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     val ddef2 = assignType(cpy.DefDef(ddef)(name, paramss1, tpt1, rhs1), sym)
 
-    if
-      ctx.isTyper
-      && ddef2.symbol.isImplicitRewrittenToGiven
-      && !ddef2.symbol.isParamOrAccessor
-      && !ddef2.symbol.isOldStyleImplicitConversion()
-    then
-      val implicitSpan =
-        ddef2.mods.mods.collectFirst {
-          case mod: Mod.Implicit => mod.span
-        }.get
-      patch(
-        Span(implicitSpan.start, implicitSpan.end + 1), ""
-      )
-      patch(
-        Span(ddef2.mods.mods.last.span.end + 1, ddef2.namePos.span.start), "given "
-      )
-      ddef.tpt match
-        case refinedType: untpd.RefinedTypeTree =>
-          patch(refinedType.span.startPos, "(")
-          patch(refinedType.span.endPos, ")")
-        case _ =>
+    migrate(ImplicitToGiven.defDef(ddef2))
 
     postProcessInfo(ddef2, sym)
     //todo: make sure dependent method types do not depend on implicits or by-name params
@@ -4229,10 +4198,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case wtp: MethodOrPoly =>
         def methodStr = methPart(tree).symbol.showLocated
         if matchingApply(wtp, pt) then
-          val isUsingApply = pt.applyKind == ApplyKind.Using
-          val notSynthetic = tree.span.exists && tree.span.start != tree.span.end
-          if ctx.isTyper && wtp.isImplicitMethodRewrittenToContextual && notSynthetic && !isUsingApply then
-            patch(Span(tree.span.end, tree.span.end + 1), "(using ")
+          migrate(ImplicitToGiven.implicitParams(tree, wtp, pt))
           migrate(contextBoundParams(tree, wtp, pt))
           migrate(implicitParams(tree, wtp, pt))
           if needsTupledDual(wtp, pt) then adapt(tree, pt.tupledDual, locked)

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2284,7 +2284,6 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           self.companion match
             case Types.ContextualMethodType => MethodTypeKind.Contextual
             case Types.ImplicitMethodType => MethodTypeKind.Implicit
-            case Types.ImplicitRewrittenToContextualMethodType => MethodTypeKind.Implicit
             case _ => MethodTypeKind.Plain
         def param(idx: Int): TypeRepr = self.newParamRef(idx)
 

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -86,7 +86,7 @@ class CompilationTests {
       compileFile("tests/rewrites/i22440.scala", defaultOptions.and("-rewrite")),
       compileFile("tests/rewrites/i22731.scala", defaultOptions.and("-rewrite", "-source:3.7-migration")),
       compileFile("tests/rewrites/i22731b.scala", defaultOptions.and("-rewrite", "-source:3.7-migration")),
-      compileFile("tests/rewrites/implicit-as-given.scala", defaultOptions.and("-rewrite", "-Yimplicit-to-given"))
+      compileFile("tests/rewrites/implicit-to-given.scala", defaultOptions.and("-rewrite", "-Yimplicit-to-given"))
     ).checkRewrites()
   }
 

tests/rewrites/implicit-as-given.check renamed to tests/rewrites/implicit-to-given.check

@@ -18,3 +18,6 @@ object Def:
   val implicitArg: Int => Unit = (implicit a => applicationTest) // should not change
 
   given refined(): (A {type B = Int}) = ???
+
+  class EmptyParamListClass()(using a: Int)
+  def emptyParamListTest() = new EmptyParamListClass()(using 0)

tests/rewrites/implicit-as-given.scala renamed to tests/rewrites/implicit-to-given.scala

@@ -18,3 +18,6 @@ object Def:
   val implicitArg: Int => Unit = (implicit a => applicationTest) // should not change
 
   implicit def refined(): A {type B = Int} = ???
+
+  class EmptyParamListClass(implicit a: Int)
+  def emptyParamListTest() = new EmptyParamListClass()(0)