Change named extension syntax

Change from
```
given extension foo: { ... }
```
to
```
given foo: extension { ... }
```
The new syntax is more regular and pleasing to the eye. It avoids
the unusual `: { ... }` symbol combination.

Author: odersky

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

@@ -3336,52 +3336,46 @@ object Parsers {
      */
     def instanceDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
-
-      def extensionDef() = {
-        in.nextToken()
-        val name =
-          if isIdent then
-            val id = ident()
-            accept(COLON)
-            id
-          else EmptyTermName
-        indentRegion(name) {
-          // TODO: accept type params here
-          val leadingParamss = if in.token == LPAREN then paramClause(prefix = true) :: Nil else Nil
-          // TODO: accept given params here
-          possibleTemplateStart()
-          val templ = templateBodyOpt(makeConstructor(Nil, leadingParamss), Nil, Nil)
-          ModuleDef(name, templ)
-        }
-      }
-
-      def regularDef() = {
-        val name =
-          if isIdent && !(newStyle && allowOldGiven && isIdent(nme.as)) then ident()
-          else EmptyTermName
-        indentRegion(name) {
-          val tparams = typeParamClauseOpt(ParamOwner.Def)
-          var leadingParamss =
-            if (in.token == LPAREN && allowOldExtension)
-              try paramClause(prefix = true) :: Nil
-              finally {
-                possibleTemplateStart()
-                if (!in.isNestedStart) syntaxErrorOrIncomplete("`{' expected")
-              }
-            else Nil
-          val parents =
-            if (!newStyle && in.token == FOR || isIdent(nme.as)) { // for the moment, accept both `given for` and `given as`
+      var isExtension = false
+      val name =
+        if isIdent(nme.extension) then
+          in.nextToken()
+          isExtension = true
+          EmptyTermName
+        else if newStyle && allowOldGiven && isIdent(nme.as) then EmptyTermName
+        else if isIdent then ident()
+        else EmptyTermName
+      indentRegion(name) {
+        var tparams: List[TypeDef] = Nil
+        var leadingParamss: List[List[ValDef]] = Nil
+        def parseParams() =
+          tparams = typeParamClauseOpt(ParamOwner.Def)
+          if in.token == LPAREN then leadingParamss = paramClause(prefix = true) :: Nil
+        if !isExtension then parseParams()
+        val parents =
+          if isExtension then Nil
+          else if allowOldGiven && (!newStyle && in.token == FOR || isIdent(nme.as)) then // for the moment, accept both `given for` and `given as`
+            in.nextToken()
+            tokenSeparated(COMMA, constrApp)
+          else if in.token == COLON then
+            in.nextToken()
+            if isIdent(nme.extension) then
+              if tparams.nonEmpty then
+                syntaxError(i"no type parameters allowed before `extension`", tparams.head.span)
+              if leadingParamss.nonEmpty then
+                syntaxError(i"no parameters allowed before `extension`", leadingParamss.head.head.span)
               in.nextToken()
-              tokenSeparated(COMMA, constrApp)
-            }
-            else Nil
-          val vparamss = paramClauses(ofInstance = true)
-          if (in.token == EQUALS && parents.length == 1 && parents.head.isType) {
+              parseParams()
+              Nil
+            else tokenSeparated(COMMA, constrApp)
+          else Nil
+        val vparamss = paramClauses(ofInstance = true)
+        val gdef =
+          if (in.token == EQUALS && parents.length == 1 && parents.head.isType) then
             in.nextToken()
             mods1 |= Final
             DefDef(name, tparams, vparamss, parents.head, expr())
-          }
-          else {
+          else
             possibleTemplateStart()
             val (tparams1, vparamss1) =
               if (leadingParamss.nonEmpty)
@@ -3393,12 +3387,8 @@ object Parsers {
             val templ = templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil)
             if (tparams.isEmpty && vparamss1.isEmpty || leadingParamss.nonEmpty) ModuleDef(name, templ)
             else TypeDef(name.toTypeName, templ)
-          }
-        }
+        finalizeDef(gdef, mods1, start)
       }
-
-      val gdef = if isIdent(nme.extension) then extensionDef() else regularDef()
-      finalizeDef(gdef, mods1, start)
     }
 
 /* -------- TEMPLATES ------------------------------------------- */

docs/docs/reference/contextual/extension-methods.md

@@ -82,13 +82,13 @@ and where `T` is the expected type. The following two rewritings are tried in or
 So `circle.circumference` translates to `CircleOps.circumference(circle)`, provided
 `circle` has type `Circle` and `CircleOps` is given  (i.e. it is visible at the point of call or it is defined in the companion object of `Circle`).
 
-### Given Instances for Extension Methods
+### Given Instances Defining Only Extension Methods
 
-Given instances that define extension methods can also be defined without a parent clause. In this case the `given` is followed  by
+Given instances that define extension methods can also be defined without a parent clause. In this case the `given` is followed  by the special identifier
 `extension`. E.g.,
 
 ```scala
-given extension stringOps: {
+given stringOps: extension {
   def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
@@ -101,23 +101,22 @@ given extension {
 ```
 If given extensions are anonymous (as in the second clause), their name is synthesized from the name of the first defined extension method.
 
-Note: `extension` is a soft keyword, it can be used elsewhere
-as a normal identifier.
+Note: `extension` is a soft keyword, it can be used elsewhere as a normal identifier.
 
 ### Given Extensions with Collective Parameters
 
 If a given extension defines several extension methods one can pull out the left parameter section
 as well as any type parameters of these extension methods into the given instance itself.
 For instance, here is a given instance with two extension methods.
 ```scala
-given extension listOps: {
+given listOps: extension {
   def (xs: List[T]) second[T]: T = xs.tail.head
   def (xs: List[T]) third[T]: T = xs.tail.tail.head
 }
 ```
 The repetition in the parameters can be avoided by moving the parameters in front of the opening brace. The following version is a shorthand for the code above.
 ```scala
-given extension listOps: [T](xs: List[T]) {
+given listOps: extension[T](xs: List[T]) {
   def second: T = xs.tail.head
   def third: T = xs.tail.tail.head
 }
@@ -171,11 +170,12 @@ As usual, type parameters of the extension method follow the defined method name
 
 ### Syntax
 
-The required syntax extension just adds one clause for extension methods relative
-to the [current syntax](../../internals/syntax.md).
+Here are the required syntax extensions compared to the
+[current syntax](../../internals/syntax.md).
 ```
+DefSig            ::=  ...
+                    |  ‘(’ DefParam ‘)’ [nl] id [DefTypeParamClause] DefParamClauses
 GivenDef          ::=  ...
-                    |  ‘extension’ [id ‘:’] ExtParamClause TemplateBody
+                    |  [id ‘:’] ‘extension’ ExtParamClause TemplateBody
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
-                    |  ‘(’ DefParam ‘)’ TemplateBody
 ```

docs/docs/reference/other-new-features/opaques.md

@@ -20,7 +20,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  given extension logarithmOps: {
+  given logarithmOps: extension {
     def (x: Logarithm) toDouble: Double = math.exp(x)
     def (x: Logarithm) + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
     def (x: Logarithm) * (y: Logarithm): Logarithm = Logarithm(x + y)

library/src-bootstrapped/scala/IArray.scala

@@ -8,7 +8,7 @@ object opaques {
   opaque type IArray[+T] = Array[_ <: T]
 
   /** Defines extension methods for immutable arrays */
-  given extension arrayOps: {
+  given arrayOps: extension {
 
     /** The selection operation on an immutable array.
       *

tests/neg/extmethod-overload.scala

@@ -1,8 +1,8 @@
 object Test {
-  given extension A: {
+  given A: extension {
     def (x: Int) |+| (y: Int) = x + y
   }
-  given extension B: {
+  given B: extension {
     def (x: Int) |+| (y: String) = x + y.length
   }
   assert((1 |+| 2) == 3)  // error ambiguous

tests/neg/i5455.scala

@@ -11,7 +11,7 @@ object Library {
     def toInt(n: Nat): Int = n
 
   }
-  given NatOps {
+  given extension {
     def (x: Nat) * (y: Nat): Nat = x * y
     def (x: Nat) toInt: Int = x
   }

tests/pos/i7084.scala

@@ -2,7 +2,7 @@ object Test {
 
   type Foo
 
-  given A {
+  given extension {
     def (y: Any) g given Foo: Any = ???
   }
 

tests/pos/reference/delegates.scala

@@ -48,7 +48,7 @@ object Instances extends Common {
     }
   }
 
-  given extension stringOps: {
+  given stringOps: extension {
     def (xs: Seq[String]) longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
@@ -152,7 +152,7 @@ object Instances extends Common {
 object PostConditions {
   opaque type WrappedResult[T] = T
 
-  private given extension WrappedResult: {
+  private given WrappedResult: extension {
     def apply[T](x: T): WrappedResult[T] = x
     def (x: WrappedResult[T]) unwrap[T]: T = x
   }

tests/pos/reference/opaque.scala

@@ -12,7 +12,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  given LogarithmOps {
+  given extension {
     def (x: Logarithm) toDouble: Double = math.exp(x)
     def (x: Logarithm) + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
     def (x: Logarithm) * (y: Logarithm): Logarithm = Logarithm(x + y)

tests/run/extmethod-overload.scala

@@ -22,7 +22,7 @@ object Test extends App {
   // Test with extension methods in given object
   object test1 {
 
-    given Foo {
+    given Foo: extension {
       def (x: Int) |+| (y: Int) = x + y
       def (x: Int) |+| (y: String) = x + y.length
 
@@ -97,7 +97,7 @@ object Test extends App {
     def (x: Int) yy (y: Int) = x + y
   }
 
-  given {
+  given extension {
     def (x: Int) yy (y: Int) = x - y
   }
 

tests/run/i6902.scala

@@ -1,6 +1,6 @@
 object Test {
   given [A] { def (a: A) <<< : A = a }
-  given { def (b: Int) <<<< : Int = b }
+  given extension { def (b: Int) <<<< : Int = b }
 
   def main(args: Array[String]): Unit = {
     1.<<<

tests/run/instances.scala

@@ -8,15 +8,15 @@ object Test extends App {
 
   case class Circle(x: Double, y: Double, radius: Double)
 
-  given extension circleOps: {
+  given circleOps: extension {
     def (c: Circle) circumference: Double = c.radius * math.Pi * 2
   }
 
   val circle = new Circle(1, 1, 2.0)
 
   assert(circle.circumference == circleOps.circumference(circle))
 
-  given extension stringOps: {
+  given stringOps: extension {
     def (xs: Seq[String]) longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
@@ -25,18 +25,18 @@ object Test extends App {
   val names = List("hi", "hello", "world")
   assert(names.longestStrings == List("hello", "world"))
 
-  given extension seqOps: {
+  given seqOps: extension {
     def (xs: Seq[T]) second[T] = xs.tail.head
   }
 
   assert(names.longestStrings.second == "world")
 
-  given extension listListOps: {
+  given listListOps: extension {
     def (xs: List[List[T]]) flattened[T] = xs.foldLeft[List[T]](Nil)(_ ++ _)
   }
 
   // A right associative op
-  given extension prepend: {
+  given prepend: extension {
     def (x: T) ::[T] (xs: Seq[T]) = x +: xs
   }
   val ss: Seq[Int] = List(1, 2, 3)