Make explicit arguments for context bounds an error from 3.5

odersky · odersky · commit 02b4ec70422f · 2024-01-06T19:37:39.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -674,7 +674,8 @@ object desugar {
       val nu = vparamss.foldLeft(makeNew(classTypeRef)) { (nu, vparams) =>
         val app = Apply(nu, vparams.map(refOfDef))
         vparams match {
-          case vparam :: _ if vparam.mods.is(Given) => app.setApplyKind(ApplyKind.Using)
+          case vparam :: _ if vparam.mods.is(Given) || vparam.name.is(ContextBoundParamName) =>
+            app.setApplyKind(ApplyKind.Using)
           case _ => app
         }
       }
diff --git a/compiler/src/dotty/tools/dotc/typer/Migrations.scala b/compiler/src/dotty/tools/dotc/typer/Migrations.scala
@@ -0,0 +1,61 @@
+package dotty.tools
+package dotc
+package typer
+
+import core.*
+import ast.*
+import Contexts.*
+import Types.*
+import Flags.*
+import Names.*
+import StdNames.*
+import Symbols.*
+import Trees.*
+import ProtoTypes.*
+import Decorators.*
+import config.MigrationVersion
+import config.Feature.{sourceVersion, migrateTo3}
+import config.SourceVersion.*
+import reporting.*
+import NameKinds.ContextBoundParamName
+import rewrites.Rewrites.patch
+import util.Spans.Span
+
+/** A utility module containing source-dependent deprecation messages
+ *  and migrations
+ */
+object Migrations:
+
+  import tpd.*
+
+  /** Flag & migrate `?` used as a higher-kinded type parameter
+   *  Warning in 3.0-migration, error from 3.0
+   */
+  def migrateKindProjectorQMark(tree: untpd.TypeDef, sym: Symbol)(using Context): Unit =
+    if tree.name eq tpnme.? then
+      val addendum = if sym.owner.is(TypeParam)
+        then ", use `_` to denote a higher-kinded type parameter"
+        else ""
+      val namePos = tree.sourcePos.withSpan(tree.nameSpan)
+      report.errorOrMigrationWarning(
+        em"`?` is not a valid type name$addendum", namePos, MigrationVersion.Scala2to3)
+
+  /** Flag & migrate explicit normal arguments to parameters coming from context bounds
+   *  Warning in 3.4, error in 3.5, rewrite in 3.5-migration.
+   */
+  def migrateContextBoundParams(tree: Tree, tp: Type, pt: FunProto)(using Context): Unit =
+    def isContextBoundParams = tp.stripPoly match
+      case MethodType(ContextBoundParamName(_) :: _) => true
+      case _ => false
+    if sourceVersion.isAtLeast(`3.4`)
+      && isContextBoundParams
+      && pt.applyKind != ApplyKind.Using
+    then
+      def rewriteMsg = Message.rewriteNotice("This code", `3.5-migration`)
+      report.errorOrMigrationWarning(
+        em"""Context bounds will map to context parameters.
+            |A `using` clause is needed to pass explicit arguments to them.$rewriteMsg""",
+        tree.srcPos, MigrationVersion(`3.4`, `3.5`))
+      if sourceVersion.isAtLeast(`3.5-migration`) then
+        patch(Span(pt.args.head.span.start), "using ")
+  end migrateContextBoundParams
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -51,6 +51,7 @@ import NullOpsDecorator.*
 import cc.CheckCaptures
 import config.Config
 import config.MigrationVersion
+import Migrations.*
 
 import scala.annotation.constructorOnly
 import dotty.tools.dotc.rewrites.Rewrites
@@ -3137,13 +3138,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             case tree: untpd.TypeDef =>
               // separate method to keep dispatching method `typedNamed` short which might help the JIT
               def typedTypeOrClassDef: Tree =
-                if tree.name eq tpnme.? then
-                  val addendum = if sym.owner.is(TypeParam)
-                    then ", use `_` to denote a higher-kinded type parameter"
-                    else ""
-                  val namePos = tree.sourcePos.withSpan(tree.nameSpan)
-                  report.errorOrMigrationWarning(
-                    em"`?` is not a valid type name$addendum", namePos, MigrationVersion.Scala2to3)
+                migrateKindProjectorQMark(tree, sym)
                 if tree.isClassDef then
                   typedClassDef(tree, sym.asClass)(using ctx.localContext(tree, sym))
                 else
@@ -3818,24 +3813,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
       case wtp: MethodOrPoly =>
         def methodStr = methPart(tree).symbol.showLocated
-        if (matchingApply(wtp, pt))
+        if matchingApply(wtp, pt) then
+          migrateContextBoundParams(tree, wtp, pt)
           if needsTupledDual(wtp, pt) then adapt(tree, pt.tupledDual, locked)
           else tree
         else if wtp.isContextualMethod then
-          def isContextBoundParams = wtp.stripPoly match
-            case MethodType(ContextBoundParamName(_) :: _) => true
-            case _ => false
-          if sourceVersion == `future-migration` && isContextBoundParams && pt.args.nonEmpty
-          then // Under future-migration, don't infer implicit arguments yet for parameters
-               // coming from context bounds. Issue a warning instead and offer a patch.
-            def rewriteMsg = Message.rewriteNotice("This code", `future-migration`)
-            report.migrationWarning(
-              em"""Context bounds will map to context parameters.
-                  |A `using` clause is needed to pass explicit arguments to them.$rewriteMsg""", tree.srcPos)
-            patch(Span(pt.args.head.span.start), "using ")
-            tree
-          else
-            adaptNoArgs(wtp)  // insert arguments implicitly
+          adaptNoArgs(wtp)  // insert arguments implicitly
         else if (tree.symbol.isPrimaryConstructor && tree.symbol.info.firstParamTypes.isEmpty)
           readapt(tree.appliedToNone) // insert () to primary constructors
         else
@@ -4441,7 +4424,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(using Context): Boolean =
     val isUsingApply = pt.applyKind == ApplyKind.Using
     methType.isContextualMethod == isUsingApply
-    || methType.isImplicitMethod && isUsingApply // for a transition allow `with` arguments for regular implicit parameters
+    || methType.isImplicitMethod && isUsingApply // for a transition allow `using` arguments for regular implicit parameters
 
   /** Check that `tree == x: pt` is typeable. Used when checking a pattern
    *  against a selector of type `pt`. This implementation accounts for
diff --git a/tests/neg/context-bounds-migration.scala b/tests/neg/context-bounds-migration.scala
@@ -0,0 +1,10 @@
+//> using options -Xfatal-warnings
+
+class C[T]
+def foo[X: C] = ()
+
+given [T]: C[T] = C[T]()
+
+def Test =
+  foo(C[Int]())  // error
+  foo(using C[Int]()) // ok
diff --git a/tests/neg/hidden-type-errors.check b/tests/neg/hidden-type-errors.check
@@ -1,3 +1,16 @@
+-- Warning: tests/neg/hidden-type-errors/Test.scala:8:24 ---------------------------------------------------------------
+ 8 |   val x = X.doSomething("XXX") // error
+   |           ^^^^^^^^^^^^^^^^^^^^
+   |           Context bounds will map to context parameters.
+   |           A `using` clause is needed to pass explicit arguments to them.
+   |           This code can be rewritten automatically under -rewrite -source 3.5-migration.
+   |--------------------------------------------------------------------------------------------------------------------
+   |Inline stack trace
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   |This location contains code that was inlined from Macro.scala:15
+15 |      doSomethingImpl('x)
+   |      ^^^^^^^^^^^^^^^^^^^
+    --------------------------------------------------------------------------------------------------------------------
 -- [E007] Type Mismatch Error: tests/neg/hidden-type-errors/Test.scala:8:24 --------------------------------------------
 8 |   val x = X.doSomething("XXX") // error
   |           ^^^^^^^^^^^^^^^^^^^^
@@ -18,3 +31,16 @@
   |
   | The tests were made under the empty constraint
    ---------------------------------------------------------------------------------------------------------------------
+-- Warning: tests/neg/hidden-type-errors/Test.scala:8:24 ---------------------------------------------------------------
+ 8 |   val x = X.doSomething("XXX") // error
+   |           ^^^^^^^^^^^^^^^^^^^^
+   |           Context bounds will map to context parameters.
+   |           A `using` clause is needed to pass explicit arguments to them.
+   |           This code can be rewritten automatically under -rewrite -source 3.5-migration.
+   |--------------------------------------------------------------------------------------------------------------------
+   |Inline stack trace
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   |This location contains code that was inlined from Macro.scala:15
+15 |      doSomethingImpl('x)
+   |      ^^^^^^^^^^^^^^^^^^^
+    --------------------------------------------------------------------------------------------------------------------

Original file line number	Diff line number	Diff line change
`@@ -674,7 +674,8 @@ object desugar {`
`674`	`674`	`val nu = vparamss.foldLeft(makeNew(classTypeRef)) { (nu, vparams) =>`
`675`	`675`	`val app = Apply(nu, vparams.map(refOfDef))`
`676`	`676`	`vparams match {`
`677`		`- case vparam :: _ if vparam.mods.is(Given) => app.setApplyKind(ApplyKind.Using)`
	`677`	`+ case vparam :: _ if vparam.mods.is(Given) \|\| vparam.name.is(ContextBoundParamName) =>`
	`678`	`+ app.setApplyKind(ApplyKind.Using)`
`678`	`679`	`case _ => app`
`679`	`680`	`}`
`680`	`681`	`}`