New syntax for collective extension methods

It's now:
```scala
extension listOps of [T](xs: List[T]) with {
  def second = xs.tail.head
  def third: T = xs.tail.tail.head
}
```
instead of
```scala
given listOps: [T](xs: List[T]) extended with {
  ...
}

Author: odersky

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

@@ -529,6 +529,7 @@ object StdNames {
     val notify_ : N             = "notify"
     val null_ : N               = "null"
     val nullExpr: N             = "nullExpr"
+    val of: N                   = "of"
     val ofDim: N                = "ofDim"
     val opaque: N               = "opaque"
     val open: N                 = "open"

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

@@ -188,7 +188,7 @@ object Parsers {
 /* -------------- TOKEN CLASSES ------------------------------------------- */
 
     def isIdent = in.isIdent
-    def isIdent(name: Name) = in.token == IDENTIFIER && in.name == name
+    def isIdent(name: Name) = in.isIdent(name)
     def isSimpleLiteral = simpleLiteralTokens contains in.token
     def isLiteral = literalTokens contains in.token
     def isNumericLit = numericLitTokens contains in.token
@@ -216,10 +216,11 @@ object Parsers {
       in.canStartExprTokens.contains(in.token) && !in.isSoftModifierInModifierPosition
 
     def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName] = Set.empty): Boolean =
-      in.token == AT ||
-      (defIntroTokens `contains` in.token) ||
-      (allowedMods `contains` in.token) ||
-      in.isSoftModifierInModifierPosition && !excludedSoftModifiers.contains(in.name)
+      in.token == AT
+      || defIntroTokens.contains(in.token)
+      || allowedMods.contains(in.token)
+      || in.isSoftModifierInModifierPosition && !excludedSoftModifiers.contains(in.name)
+      || isIdent(nme.extension) && followingIsExtension()
 
     def isStatSep: Boolean = in.isNewLine || in.token == SEMI
 
@@ -944,6 +945,13 @@ object Parsers {
         lookahead.skipParens()
       lookahead.token == COLON || lookahead.token == SUBTYPE
 
+    def followingIsExtension() =
+      val lookahead = in.LookaheadScanner()
+      lookahead.nextToken()
+      if lookahead.isIdent && !lookahead.isIdent(nme.of) then
+        lookahead.nextToken()
+      lookahead.isIdent(nme.of)
+
 /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
     var opStack: List[OpInfo] = Nil
@@ -3275,6 +3283,7 @@ object Parsers {
      *            |  [‘case’] ‘object’ ObjectDef
      *            |  ‘enum’ EnumDef
      *            |  ‘given’ GivenDef
+     *            |  ‘extension’ ExtensionDef
      */
     def tmplDef(start: Int, mods: Modifiers): Tree =
       in.token match {
@@ -3293,8 +3302,11 @@ object Parsers {
         case GIVEN =>
           givenDef(start, mods, atSpan(in.skipToken()) { Mod.Given() })
         case _ =>
-          syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
-          EmptyTree
+          if isIdent(nme.extension) && followingIsExtension() then
+            extensionDef(start, mods)
+          else
+            syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
+            EmptyTree
       }
 
     /** ClassDef ::= id ClassConstr TemplateOpt
@@ -3522,6 +3534,23 @@ object Parsers {
       finalizeDef(gdef, mods1, start)
     }
 
+    /** ExtensionDef  ::=  [id] ‘of’ ExtParamClause {GivenParamClause} ‘with’ ExtMethods
+     */
+    def extensionDef(start: Offset, mods: Modifiers): ModuleDef =
+      in.nextToken()
+      val name = if isIdent && !isIdent(nme.of) then ident() else EmptyTermName
+      if !isIdent(nme.of) then syntaxErrorOrIncomplete("`of` expected")
+      if isIdent(nme.of) then in.nextToken()
+      val tparams = typeParamClauseOpt(ParamOwner.Def)
+      val extParams = paramClause(0, prefix = true)
+      val givenParamss = paramClauses(givenOnly = true)
+      accept(WITH)
+      if !in.isNestedStart then syntaxError("Extension without extension methods")
+      val templ = templateBodyOpt(makeConstructor(tparams, extParams :: givenParamss), Nil, Nil)
+      templ.body.foreach(checkExtensionMethod(tparams, _))
+      val edef = ModuleDef(name, templ)
+      finalizeDef(edef, addFlag(mods, Given), start)
+
 /* -------- TEMPLATES ------------------------------------------- */
 
     /** SimpleConstrApp  ::=  AnnotType {ParArgumentExprs}
@@ -3681,7 +3710,7 @@ object Parsers {
     def templateStatSeq(): (ValDef, List[Tree]) = checkNoEscapingPlaceholders {
       var self: ValDef = EmptyValDef
       val stats = new ListBuffer[Tree]
-      if (isExprIntro) {
+      if (isExprIntro && !isDefIntro(modifierTokens)) {
         val first = expr1()
         if (in.token == ARROW) {
           first match {
@@ -3707,10 +3736,10 @@ object Parsers {
           stats ++= importClause(IMPORT, Import)
         else if (in.token == EXPORT)
           stats ++= importClause(EXPORT, Export.apply)
-        else if (isExprIntro)
-          stats += expr1()
         else if (isDefIntro(modifierTokensOrCase))
           stats +++= defOrDcl(in.offset, defAnnotsMods(modifierTokens))
+        else if (isExprIntro)
+          stats += expr1()
         else if (!isStatSep) {
           exitOnError = mustStartStat
           syntaxErrorOrIncomplete("illegal start of definition")

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

@@ -1017,6 +1017,7 @@ object Scanners {
 
     def isNewLine = token == NEWLINE || token == NEWLINES
     def isIdent = token == IDENTIFIER || token == BACKQUOTED_IDENT
+    def isIdent(name: Name) = token == IDENTIFIER && this.name == name
 
     def isNestedStart = token == LBRACE || token == INDENT
     def isNestedEnd = token == RBRACE || token == OUTDENT

docs/blog/_posts/2019-12-20-21th-dotty-milestone-release.md

@@ -183,7 +183,7 @@ given extension (s: String) { ... }
 ```
 or
 ```scala
-given listOps: [T](xs: List[T]) extended with { ... }
+extension listOps of [T](xs: List[T]) with { ... }
 
 given (s: String) extended with { ... }
 ```

docs/docs/internals/syntax.md

@@ -103,7 +103,7 @@ yield
 ### Soft keywords
 
 ```
-as        derives   inline    opaque    open
+derives   extension inline    opaque    open
 ~         *         |         &         +         -
 ```
 
@@ -378,7 +378,7 @@ TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
                     |  ‘enum’ EnumDef
                     |  ‘given’ GivenDef
-                    |  Export
+                    |  ‘extension’ ExtensionDef
 ClassDef          ::=  id ClassConstr [Template]                                ClassDef(mods, name, tparams, templ)
 ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses        with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat
 ConstrMods        ::=  {Annotation} [AccessModifier]
@@ -388,11 +388,11 @@ GivenDef          ::=  [GivenSig (‘:’ | <:)] {FunArgTypes ‘=>’}
                        AnnotType ‘=’ Expr
                     |  [GivenSig ‘:’] {FunArgTypes ‘=>’}
                        ConstrApps [[‘with’] TemplateBody]
-                    |  [id ‘:’] ExtParamClause {GivenParamClause}
-                       ‘extended’ ‘with’ ExtMethods
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
+ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause}
+                       ‘with’ ExtMethods
+ExtMethods        ::=  ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
-ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 Template          ::=  InheritClauses [[‘with’] TemplateBody]                   Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {(‘,’ | ‘with’) ConstrApp}

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

@@ -80,7 +80,7 @@ So `circle.circumference` translates to `CircleOps.circumference(circle)`, provi
 
 ### Operators
 
-The extension method syntax also applies to the definition of operators. 
+The extension method syntax also applies to the definition of operators.
 In this case it is allowed and preferable to omit the period between the leading parameter list
 and the operator. In each case the definition syntax mirrors the way the operator is applied.
 Examples:
@@ -122,24 +122,25 @@ If an extension method has type parameters, they come immediately after the `def
 ```scala
 List(1, 2, 3).second[Int]
 ```
-### Given Instances for Extension Methods
+### Collective Extensions
 
-`given` extensions are given instances that define extension methods and nothing else. Examples:
+A collective extension defines one or more concrete methods that have the same type parameters
+and prefix parameter. Examples:
 
 ```scala
-given stringOps: (xs: Seq[String]) extended with {
+extension stringOps of (xs: Seq[String]) with {
   def longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-given listOps: [T](xs: List[T]) extended with {
+extension listOps of [T](xs: List[T]) with {
   def second = xs.tail.head
   def third: T = xs.tail.tail.head
 }
 
-given [T](xs: List[T])(given Ordering[T]) extended with {
+extension of [T](xs: List[T])(given Ordering[T]) with {
   def largest(n: Int) = xs.sorted.takeRight(n)
 }
 ```
@@ -163,15 +164,18 @@ given given_largest_of_List_T: AnyRef {
 }
 ```
 
+`extension` and `of` are soft keywords. They can also be used as a regular identifiers.
+
 ### Syntax
 
 Here are the syntax changes for extension methods and given extensions relative
 to the [current syntax](../../internals/syntax.md). `extension` is a soft keyword, recognized only after a `given`. It can be used as an identifier everywhere else.
 ```
 DefSig            ::=  ...
                     |  ExtParamClause [nl] [‘.’] id DefParamClauses
-GivenDef          ::=  ...
-                       [id ‘:’] ‘extension’ ExtParamClause {GivenParamClause} ExtMethods
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
-ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
+TmplDef           ::=  ...
+                    |  ‘extension’ ExtensionDef
+ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause} ‘with’ ExtMethods
+ExtMethods        ::=  ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ```

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

@@ -65,7 +65,7 @@ Anonymous given instances that define extension methods
 get their name from the name of the first extension method and the toplevel type
 constructor of its first parameter. For example, the given instance
 ```scala
-given [T] (xs: List[T]) extended with {
+extension of [T] (xs: List[T]) with {
   def second = ...
 }
 ```

tests/neg/extension-methods.scala

@@ -10,7 +10,7 @@ object Test {
   "".l2 // error
   1.l1 // error
 
-  given [T](xs: List[T]) extended with {
+  extension of [T](xs: List[T]) with {
     def (x: Int).f1: T = ???  // error: No extension method allowed here, since collective parameters are given
     def f2[T]: T = ???        // error: T is already defined as type T
     def f3(xs: List[T]) = ??? // error: xs is already defined as value xs

tests/neg/extmethod-overload.scala

@@ -1,8 +1,8 @@
 object Test {
-  given a: (x: Int) extended with
+  extension a of (x: Int) with
     def |+| (y: Int) = x + y
 
-  given b: (x: Int) extended with {
+  extension b of (x: Int) with {
     def |+| (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 (x: Nat) extended with
+  extension of (x: Nat) with
     def * (y: Nat): Nat = x * y
     def toInt: Int = x
 }