Add -Yimplicit-as-given flag allowing rewriting implicits to givens

Author: jchyb

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -465,6 +465,7 @@ private sealed trait YSettings:
 
   val Yinstrument: Setting[Boolean] = BooleanSetting(ForkSetting, "Yinstrument", "Add instrumentation code that counts allocations and closure creations.")
   val YinstrumentDefs: Setting[Boolean] = BooleanSetting(ForkSetting, "Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.")
+  val YimplicitToGiven: Setting[Boolean] = BooleanSetting(ForkSetting, "Yimplicit-to-given", "Allows to rewrite the implicit keywords to their scala-3 given counterparts. Does not adjust imports. Use in conjunction with --rewrite.")
 
   // Deprecated: lifted from -Y to -X
   @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0")

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

@@ -8,6 +8,8 @@ import ContextOps.enter
 import TypeApplications.EtaExpansion
 import collection.mutable
 import config.Printers.typr
+import rewrites.Rewrites.patch
+import util.Spans.Span
 
 /** Operations that are shared between Namer and TreeUnpickler */
 object NamerOps:
@@ -61,12 +63,19 @@ object NamerOps:
    *  This is done by adding a () in front of a leading old style implicit parameter,
    *  or by adding a () as last -- or only -- parameter list if the constructor has
    *  only using clauses as parameters.
+   *
+   * implicitRewritePosition, if included, will point to where `()` should be added if rewriting
+   * with -Yimplicit-to-given
    */
-  def normalizeIfConstructor(paramss: List[List[Symbol]], isConstructor: Boolean)(using Context): List[List[Symbol]] =
+  def normalizeIfConstructor(paramss: List[List[Symbol]], isConstructor: Boolean, implicitRewritePosition: Option[Span] = None)(using Context): List[List[Symbol]] =
     if !isConstructor then paramss
     else paramss match
-      case TypeSymbols(tparams) :: paramss1 => tparams :: normalizeIfConstructor(paramss1, isConstructor)
-      case TermSymbols(vparam :: _) :: _ if vparam.is(Implicit) => Nil :: paramss
+      case TypeSymbols(tparams) :: paramss1 => tparams :: normalizeIfConstructor(paramss1, isConstructor, implicitRewritePosition)
+      case TermSymbols(vparam :: _) :: _ if vparam.is(Implicit) =>
+        implicitRewritePosition match
+          case Some(position) if ctx.settings.YimplicitToGiven.value => patch(position, "()")
+          case _ => ()
+        Nil :: paramss
       case _ =>
         if paramss.forall {
           case TermSymbols(vparams) => vparams.nonEmpty && vparams.head.is(Given)
@@ -81,10 +90,10 @@ object NamerOps:
       case Nil =>
         resultType
       case TermSymbols(params) :: paramss1 =>
-        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)
+        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)
         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,6 +404,10 @@ 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,6 +478,9 @@ 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
 
@@ -4112,13 +4115,16 @@ object Types extends TypeUtils {
     def companion: MethodTypeCompanion
 
     final override def isImplicitMethod: Boolean =
-      companion.eq(ImplicitMethodType) || isContextualMethod
+      companion.eq(ImplicitMethodType) || companion.eq(ImplicitRewrittenToContextualMethodType) || 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))
 
@@ -4250,14 +4256,16 @@ object Types extends TypeUtils {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def companion(isContextual: Boolean = false, isImplicit: Boolean = false): MethodTypeCompanion =
-      if (isContextual) ContextualMethodType
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, implicitToGiven: Boolean = false): MethodTypeCompanion =
+      if (implicitToGiven) ImplicitRewrittenToContextualMethodType
+      else 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/parsing/Parsers.scala

@@ -3588,6 +3588,8 @@ object Parsers {
 
       def paramMods() =
         if in.token == IMPLICIT then
+          if ctx.settings.YimplicitToGiven.value then
+              patch(Span(in.lastOffset - 8, in.lastOffset), "using")
           addParamMod(() => Mod.Implicit())
         else if isIdent(nme.using) then
           if initialMods.is(Given) then

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

@@ -1941,7 +1941,7 @@ class Namer { typer: Typer =>
     if completedTypeParams.forall(_.isType) then
       completer.setCompletedTypeParams(completedTypeParams.asInstanceOf[List[TypeSymbol]])
     completeTrailingParamss(ddef, sym, indexingCtor = false)
-    val paramSymss = normalizeIfConstructor(ddef.paramss.nestedMap(symbolOfTree), isConstructor)
+    val paramSymss = normalizeIfConstructor(ddef.paramss.nestedMap(symbolOfTree), isConstructor, Some(ddef.nameSpan.startPos))
     sym.setParamss(paramSymss)
 
     def wrapMethType(restpe: Type): Type =

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

@@ -53,6 +53,7 @@ import transform.CheckUnused.OriginalName
 
 import scala.annotation.{unchecked as _, *}
 import dotty.tools.dotc.util.chaining.*
+import dotty.tools.dotc.ast.untpd.Mod
 
 object Typer {
 
@@ -2891,6 +2892,20 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
     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 "
+      )
+
     val nnInfo = rhs1.notNullInfo
     vdef1.withNotNullInfo(if sym.is(Lazy) then nnInfo.retractedInfo else nnInfo)
   }
@@ -3003,6 +3018,28 @@ 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 _ =>
+
     postProcessInfo(ddef2, sym)
     //todo: make sure dependent method types do not depend on implicits or by-name params
   }
@@ -4200,6 +4237,10 @@ 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(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,6 +2284,7 @@ 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,6 +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"))
     ).checkRewrites()
   }
 

tests/rewrites/implicit-as-given.check

@@ -0,0 +1,20 @@
+object Def:
+  trait A
+  trait B
+  implicit def conv1(a: A): B = ??? // should not change
+  given conv2: A => B = ???
+  final given nonConv: A = ???
+  given conv3: A => B = ???
+  final given nonConv2: A = ???
+
+  implicit class Extension(a: Int): // should not change
+    def addedMethod(): A = ???
+  implicit class ExtensionWithImplicit(t: String)(using a: Int):
+    def addedMethod(): String = ???
+  class NoNonimplicitParams()(using a: Int)
+
+  def applicationTest(using a: Int): Unit = ???
+  val application = applicationTest(using 0)
+  val implicitArg: Int => Unit = (implicit a => applicationTest) // should not change
+
+  given refined(): (A {type B = Int}) = ???

tests/rewrites/implicit-as-given.scala

@@ -0,0 +1,20 @@
+object Def:
+  trait A
+  trait B
+  implicit def conv1(a: A): B = ??? // should not change
+  implicit def conv2: A => B = ???
+  final implicit def nonConv: A = ???
+  implicit val conv3: A => B = ???
+  final implicit val nonConv2: A = ???
+
+  implicit class Extension(a: Int): // should not change
+    def addedMethod(): A = ???
+  implicit class ExtensionWithImplicit(t: String)(implicit a: Int):
+    def addedMethod(): String = ???
+  class NoNonimplicitParams(implicit a: Int)
+
+  def applicationTest(implicit a: Int): Unit = ???
+  val application = applicationTest(0)
+  val implicitArg: Int => Unit = (implicit a => applicationTest) // should not change
+
+  implicit def refined(): A {type B = Int} = ???