Implement new given syntax

Author: odersky

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

@@ -22,7 +22,7 @@ object Flags {
 
   type Flag = opaques.Flag
 
-  given FlagOps {
+  given /*FlagOps*/ {
 
     def (x: FlagSet) bits: Long = opaques.toBits(x)
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -872,11 +872,14 @@ object Scanners {
         super.printState()
       }
 
-      final def skipParens(opening: Token): Unit = {
+      /** Skip matching pairs of `(...)` or `[...]` parentheses.
+       *  @pre  The current token is `(` or `[`
+       */
+      final def skipParens(): Unit = {
+        val opening = token
         nextToken()
         while token != EOF && token != opening + 1 do
-          if (token == opening) skipParens(opening)
-          else nextToken()
+          if token == opening then skipParens() else nextToken()
         nextToken()
       }
     }

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -270,6 +270,17 @@ object Tokens extends TokensCommon {
     statCtdTokens | BitSet(COLONEOL, EQUALS, ARROW, LARROW, WHILE, TRY, FOR)
       // `if` is excluded because it often comes after `else` which makes for awkward indentation rules
 
+  /** Faced with the choice between a type and a formal parameter, the following
+   *  tokens determine it's a formal parameter.
+   */
+  final val startParamTokens: BitSet = modifierTokens | BitSet(VAL, VAR, AT)
+
+  /** Faced with the choice of a type `(...)` or a parameter or given type list
+   *  in `(...)`, the following tokens after the opening `(` determine it's
+   *  a parameter or given type list.
+   */
+  final val startParamOrGivenTypeTokens: BitSet = startParamTokens | BitSet(GIVEN, ERASED)
+
   final val scala3keywords = BitSet(ENUM, ERASED, GIVEN, IMPLIED)
 
   final val softModifierNames = Set(nme.inline, nme.opaque)

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -86,15 +86,15 @@ private[quoted] object Matcher {
       case _ => notMatched
     }
 
-    private given TreeListOps {
+    private given /*TreeListOps*/ {
 
       /** Check that all trees match with =?= and concatenate the results with && */
       def (scrutinees: List[Tree]) =?= (patterns: List[Tree]) given Context, Env: Matching =
         matchLists(scrutinees, patterns)(_ =?= _)
 
     }
-    
-    private given TreeOps {
+
+    private given /*TreeOps*/ {
 
       /** Check that the trees match and return the contents from the pattern holes.
        *  Return None if the trees do not match otherwise return Some of a tuple containing all the contents in the holes.
@@ -294,7 +294,7 @@ private[quoted] object Matcher {
       }
     }
 
-    private given PatternOps {
+    private given /*PatternOps*/ {
 
       /** Check that the pattern trees match and return the contents from the pattern holes.
        *  Return a tuple with the new environment containing the bindings defined in this pattern and a matching.

library/src/scala/internal/quoted/Matcher.scala

@@ -1,4 +1,4 @@
-delegate MyNumericOps[T] {
+given MyNumericOps[T]: {
   def (x: T) +(y: T) given (n: Numeric[T]): T = n.plus(x,y)
 }
 def foo[T: Numeric](x: T) = 1f + x // error: no implicit argument of type Numeric[Any]

tests/neg/erased-implicit-b.scala

@@ -1,5 +1,5 @@
 object Test {
-  given bla[A] { def (a: A) foo[C]: C => A = _ => a }
+  given bla[A]: { def (a: A) foo[C]: C => A = _ => a }
 
   1.foo.foo
   1.foo.foo[String]

tests/neg/i6801.scala

@@ -1,3 +1,3 @@
 class X
 object X extends X
-given `as` as X = X
+given `as` : X = X

tests/pos/i6900.scala

@@ -10,7 +10,7 @@ class Reflect(val internal: CompilerInterface) {
   opaque type Term <: Tree = internal.Term
 
   object Tree {
-    given Ops (tree: Tree) {
+    given Ops: (tree: Tree) {
       def show: String = ???
     }
   }