Under -source future, warn if old given and context bound syntax is used

odersky · odersky · commit 3fd727d2cb6f · 2024-09-28T18:17:20.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
@@ -30,6 +30,7 @@ enum MigrationVersion(val warnFrom: SourceVersion, val errorFrom: SourceVersion)
   case ImportRename extends MigrationVersion(future, future)
   case ParameterEnclosedByParenthesis extends MigrationVersion(future, future)
   case XmlLiteral extends MigrationVersion(future, future)
+  case GivenSyntax extends MigrationVersion(future, never)
 
   require(warnFrom.ordinal <= errorFrom.ordinal)
 
diff --git a/compiler/src/dotty/tools/dotc/config/SourceVersion.scala b/compiler/src/dotty/tools/dotc/config/SourceVersion.scala
@@ -16,6 +16,8 @@ enum SourceVersion:
   // !!! Keep in sync with scala.runtime.stdlibPatches.language !!!
   case `future-migration`, `future`
 
+  case `never`    // needed for MigrationVersion.errorFrom if we never want to issue an error
+
   val isMigrating: Boolean = toString.endsWith("-migration")
 
   def stable: SourceVersion =
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2240,7 +2240,16 @@ object Parsers {
         in.nextToken()
         if in.token == LBRACE && sourceVersion.isAtLeast(`3.6`)
         then inBraces(commaSeparated(() => contextBound(pname)))
-        else contextBound(pname) :: contextBounds(pname)
+        else
+          val bound = contextBound(pname)
+          val rest =
+            if in.isColon then
+              report.errorOrMigrationWarning(
+                em"Multiple context bounds should be enclosed in `{ ... }`",
+                in.sourcePos(), MigrationVersion.GivenSyntax)
+              contextBounds(pname)
+            else Nil
+          bound :: rest
       else if in.token == VIEWBOUND then
         report.errorOrMigrationWarning(
           em"view bounds `<%' are no longer supported, use a context bound `:' instead",
@@ -4261,6 +4270,9 @@ object Parsers {
             in.nextToken()
             newSignature()
           else if hasEmbeddedColon then
+            report.errorOrMigrationWarning(
+              em"This old given syntax is no longer supported; use `=>` instead of `:`",
+              in.sourcePos(), MigrationVersion.GivenSyntax)
             newSyntaxAllowed = false
             val tparamsOld = typeParamClauseOpt(ParamOwner.Given)
             newLineOpt()
@@ -4294,6 +4306,11 @@ object Parsers {
           // old-style abstract given
           if name.isEmpty then
             syntaxError(em"Anonymous given cannot be abstract, or maybe you want to define a concrete given and are missing a `()` argument?", in.lastOffset)
+          if newSyntaxAllowed then
+            report.errorOrMigrationWarning(
+              em"""This defines an abstract given, which is no longer supported. Use a `deferred` given instead.
+                  |Or, if you intend to define a concrete given, follow the type with `()` arguments.""",
+              in.sourcePos(in.lastOffset), MigrationVersion.GivenSyntax)
           DefDef(name, adjustDefParams(joinParams(tparams, vparamss)), parents.head, EmptyTree)
         else
           // structural instance
@@ -4483,6 +4500,9 @@ object Parsers {
 
     /** with Template, with EOL <indent> interpreted */
     def withTemplate(constr: DefDef, parents: List[Tree]): Template =
+      report.errorOrMigrationWarning(
+          em"Given member definitions starting with `with` are no longer supported; use `{...}` or `:` followed by newline instead",
+          in.sourcePos(), MigrationVersion.GivenSyntax)
       accept(WITH)
       val (self, stats) = templateBody(parents, rewriteWithColon = false)
       Template(constr, parents, Nil, self, stats)
diff --git a/tests/neg/context-bounds-migration-future.check b/tests/neg/context-bounds-migration-future.check
@@ -4,3 +4,7 @@
   |  method foo does not take more parameters
   |
   | longer explanation available when compiling with `-explain`
+-- Warning: tests/neg/context-bounds-migration-future.scala:6:6 --------------------------------------------------------
+6 |given [T]: C[T] = C[T]()
+  |      ^
+  |      This old given syntax is no longer supported; use `=>` instead of `:`
diff --git a/tests/neg/infix.scala b/tests/neg/infix.scala
@@ -8,7 +8,7 @@ class C:
   def +(x: Int): Int = ???
 
 object C:
-  given AnyRef with
+  given AnyRef:
     extension (x: C)
       infix def iop (y: Int) = ???
       def mop (y: Int) = ???
diff --git a/tests/neg/tracked.check b/tests/neg/tracked.check
@@ -22,10 +22,10 @@
 17 |  tracked type T = Int // error // error
    |          ^^^^
    |          end of statement expected but 'type' found
--- Error: tests/neg/tracked.scala:20:29 --------------------------------------------------------------------------------
-20 |  given g2(using tracked val x: Int): C = C(x) // error
-   |                 ^^^^^^^^^^^^^^^^^^
-   |                 method parameter x may not be a `val`
+-- Error: tests/neg/tracked.scala:20:25 --------------------------------------------------------------------------------
+20 |  given g2: (tracked val x: Int) => C = C(x) // error
+   |             ^^^^^^^^^^^^^^^^^^
+   |             method parameter x may not be a `val`
 -- Error: tests/neg/tracked.scala:4:21 ---------------------------------------------------------------------------------
 4 |class C2(tracked var x: Int) // error
   |                     ^
diff --git a/tests/neg/tracked.scala b/tests/neg/tracked.scala
@@ -17,4 +17,4 @@ object D:
   tracked type T = Int // error // error
 
 object E:
-  given g2(using tracked val x: Int): C = C(x) // error
+  given g2: (tracked val x: Int) => C = C(x) // error
diff --git a/tests/warn/abstract-givens-new.check b/tests/warn/abstract-givens-new.check
@@ -1 +1,5 @@
-
+-- Warning: tests/warn/abstract-givens-new.scala:7:22 ------------------------------------------------------------------
+7 |  given intC: Int is C // warn
+  |                      ^
+  |                     This defines an abstract given, which is no longer supported. Use a `deferred` given instead.
+  |                     Or, if you intend to define a concrete given, follow the type with `()` arguments.
diff --git a/tests/warn/abstract-givens-new.scala b/tests/warn/abstract-givens-new.scala
@@ -4,7 +4,7 @@ class C:
 
 trait T:
   given Int is C // ok
-  given intC: Int is C // ok for now, will be warning
+  given intC: Int is C // warn
   given intC2: (Int is C)() // ok
   given intC3: Int is C {} // also ok
 
diff --git a/tests/warn/old-givens.check b/tests/warn/old-givens.check
@@ -0,0 +1,25 @@
+-- Warning: tests/warn/old-givens.scala:8:20 ---------------------------------------------------------------------------
+8 |  given intC: C[Int] // warn
+  |                    ^
+  |                    This defines an abstract given, which is no longer supported. Use a `deferred` given instead.
+  |                    Or, if you intend to define a concrete given, follow the type with `()` arguments.
+-- Warning: tests/warn/old-givens.scala:11:8 ---------------------------------------------------------------------------
+11 |  given [T]: Ord[T] with  // warn // warn
+   |        ^
+   |        This old given syntax is no longer supported; use `=>` instead of `:`
+-- Warning: tests/warn/old-givens.scala:11:20 --------------------------------------------------------------------------
+11 |  given [T]: Ord[T] with  // warn // warn
+   |                    ^
+   |Given member definitions starting with `with` are no longer supported; use `{...}` or `:` followed by newline instead
+-- Warning: tests/warn/old-givens.scala:14:8 ---------------------------------------------------------------------------
+14 |  given [T](using Ord[T]): Ord[List[T]] with // warn // warn
+   |        ^
+   |        This old given syntax is no longer supported; use `=>` instead of `:`
+-- Warning: tests/warn/old-givens.scala:14:40 --------------------------------------------------------------------------
+14 |  given [T](using Ord[T]): Ord[List[T]] with // warn // warn
+   |                                        ^
+   |Given member definitions starting with `with` are no longer supported; use `{...}` or `:` followed by newline instead
+-- Warning: tests/warn/old-givens.scala:17:15 --------------------------------------------------------------------------
+17 |  def f[T: Ord : C]() = ???  // warn
+   |               ^
+   |               Multiple context bounds should be enclosed in `{ ... }`
diff --git a/tests/warn/old-givens.scala b/tests/warn/old-givens.scala
@@ -0,0 +1,18 @@
+//> using options -source future
+trait Ord[T]:
+  def compare(x: T, y: T): Boolean
+
+class C[T]
+
+trait T:
+  given intC: C[Int] // warn
+  given intC2: C[Int] () // OK
+
+  given [T]: Ord[T] with  // warn // warn
+    def compare(x: T, y: T): Boolean = ???
+
+  given [T](using Ord[T]): Ord[List[T]] with // warn // warn
+    def compare(x: List[T], y: List[T]): Boolean = ???
+
+  def f[T: Ord : C]() = ???  // warn
+

Original file line number	Diff line number	Diff line change
`@@ -4,3 +4,7 @@`
`4`	`4`	`\| method foo does not take more parameters`
`5`	`5`	`\|`
`6`	`6`	\| longer explanation available when compiling with `-explain`
	`7`	`+-- Warning: tests/neg/context-bounds-migration-future.scala:6:6 --------------------------------------------------------`
	`8`	`+6 \|given [T]: C[T] = C[T]()`
	`9`	`+ \| ^`
	`10`	+ \| This old given syntax is no longer supported; use `=>` instead of `:`