Clarify migration of context bounds

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -222,7 +222,8 @@ object desugar {
     val epbuf = ListBuffer[ValDef]()
     def desugarContextBounds(rhs: Tree): Tree = rhs match {
       case ContextBounds(tbounds, cxbounds) =>
-        epbuf ++= makeImplicitParameters(cxbounds, Implicit, forPrimaryConstructor = isPrimaryConstructor)
+        val iflag = if ctx.settings.strict.value then Given else Implicit
+        epbuf ++= makeImplicitParameters(cxbounds, iflag, forPrimaryConstructor = isPrimaryConstructor)
         tbounds
       case LambdaTypeTree(tparams, body) =>
         cpy.LambdaTypeTree(rhs)(tparams, desugarContextBounds(body))

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

@@ -2654,7 +2654,21 @@ class Typer extends Namer
           else
             tree
         else if (wtp.isContextualMethod)
-          adaptNoArgs(wtp)  // insert arguments implicitly
+          def isContextBoundParams = wtp.stripPoly match
+            case MethodType(EvidenceParamName(_) :: _) => true
+            case _ => false
+          if ctx.settings.migration.value && ctx.settings.strict.value
+             && isContextBoundParams
+          then // Under 3.1 and -migration, don't infer implicit arguments yet for parameters
+               // coming from context bounds. Issue a warning instead and offer a patch.
+            ctx.migrationWarning(
+              em"""Context bounds will map to context parameters.
+                  |A `with` clause is needed to pass explicit arguments to them.
+                  |This code can be rewritten automatically using -rewrite""", tree.sourcePos)
+            patch(Span(tree.span.end), ".with")
+            tree
+          else
+            adaptNoArgs(wtp)  // insert arguments implicitly
         else if (tree.symbol.isPrimaryConstructor && tree.symbol.info.firstParamTypes.isEmpty)
           readapt(tree.appliedToNone) // insert () to primary constructors
         else

docs/docs/reference/contextual/context-bounds-new.md

@@ -22,7 +22,18 @@ Context bounds can be combined with subtype bounds. If both are present, subtype
 def g[T <: B : C](x: T): R = ...
 ```
 
-## Syntax
+### Migration
+
+To ease migration, context bounds in Dotty map in Scala 3.0 to old-style implicit parameters
+for which arguments can be passed either using `.with(...)` or using a normal application.
+From Scala 3.1 on, they will map to context parameters instead, as is described above.
+
+If the source version is `3.1` and the `-migration` command-line option is set, any pairing of an evidence
+context parameter stemming from a context bound with a normal argument will give a migration
+warning. The warning indicates that a `.with(...)` clause should be used instead. The rewrite can be
+done automatically under `-rewrite`.
+
+### Syntax
 
 ```
 TypeParamBounds   ::=  [SubtypeBounds] {ContextBound}

docs/docs/reference/contextual/relationship-implicits.md

@@ -105,11 +105,9 @@ asked for.
 
 ### Context Bounds
 
-Context bounds are the same in both language versions. They expand to the respective forms of implicit parameters.
-
-**Note:** To ease migration, context bounds in Dotty map for a limited time to old-style implicit parameters for which arguments can be passed either with `given` or
-with a normal application. Once old-style implicits are deprecated, context bounds
-will map to given clauses instead.
+Context bounds are the same in both language versions.
+They expand to `implicit` parameters in Scala 2 and also in Scala 3.0.
+They will expand to context parameters from Scala 3.1 on.
 
 ### Extension Methods