Change syntax from extend to extension

Author: odersky

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

@@ -3398,28 +3398,32 @@ object Parsers {
 
     /** GivenDef       ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
      *                   |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-     *                   |  [[id] ‘extends’ ExtParamClause {GivenParamClause} ExtMethods
+     *                   |  [id ‘:’] ‘extension’ ExtParamClause {GivenParamClause} ExtMethods
      *  GivenSig       ::=  [id] [DefTypeParamClause] {GivenParamClause}
      *  ExtParamClause ::=  [DefTypeParamClause] DefParamClause {GivenParamClause}
      *  ExtMethods     ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
      */
     def givenDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
       val hasGivenSig = followingIsGivenSig()
-      val name =
-        if isIdent && (hasGivenSig || in.lookaheadIn(BitSet(EXTENDS))) then ident()
-        else EmptyTermName
+      val (name, isExtension) =
+        if isIdent && hasGivenSig then
+          (ident(), in.token == COLON && in.lookaheadIn(nme.extension))
+        else
+          (EmptyTermName, isIdent(nme.extension))
+
       val gdef = indentRegion(name) {
-        if in.token == EXTENDS then
-          in.nextToken()
+        if isExtension then
+          if (in.token == COLON) in.nextToken()
+          assert(ident() == nme.extension)
           val tparams = typeParamClauseOpt(ParamOwner.Def)
           val extParams = paramClause(0, prefix = true)
           val givenParamss = paramClauses(givenOnly = true)
           possibleTemplateStart()
-          val extMethods = templateBodyOpt(
+          val templ = templateBodyOpt(
             makeConstructor(tparams, extParams :: givenParamss), Nil, Nil)
-          extMethods.body.foreach(checkExtensionMethod)
-          ModuleDef(name, extMethods)
+          templ.body.foreach(checkExtensionMethod)
+          ModuleDef(name, templ)
         else
           var tparams: List[TypeDef] = Nil
           var vparamss: List[List[ValDef]] = Nil

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

@@ -895,14 +895,15 @@ object Scanners {
       nextToken()
 
     /** Is the token following the current one in `tokens`? */
-    def lookaheadIn(tokens: BitSet): Boolean = {
+    def lookaheadIn(follow: BitSet | TermName): Boolean =
       val lookahead = LookaheadScanner()
       while
         lookahead.nextToken()
         lookahead.isNewLine
       do ()
-      tokens.contains(lookahead.token)
-    }
+      follow match
+        case tokens: BitSet => tokens.contains(lookahead.token)
+        case name: TermName => lookahead.token == IDENTIFIER && lookahead.name == name
 
     /** Is the current token in a position where a modifier is allowed? */
     def inModifierPosition(): Boolean = {

docs/docs/internals/syntax.md

@@ -388,9 +388,10 @@ ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
 GivenDef          ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
                     |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                    |  [GivenSig ‘:’] ExtParamClause ExtMethods
+                    |  [[id ‘:’] ‘extension’ ExtParamClause {GivenParamClause}
+                       ExtMethods
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
-ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
+ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]

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

@@ -123,48 +123,54 @@ List(1, 2, 3).second[Int]
 ```
 ### Given Instances for Extension Methods
 
-The `given extends` syntax lets on define given instances that define extension methods and nothing else. Examples:
+`given` extensions are given instances that define extension methods and nothing else. Examples:
 
 ```scala
-given stringOps extends (xs: Seq[String]) {
+given stringOps: extension (xs: Seq[String]) {
   def longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-given extends [T](xs: List[T]) {
+given listOps: extension [T](xs: List[T]) {
   def second = xs.tail.head
   def third: T = xs.tail.tail.head
 }
-```
-If such given instances are anonymous (as in the second clause), their name is synthesized from the name of the first defined extension method.
 
-The extension method definitions above are equivalent to the following standard given instances where
-the implemented parent is `AnyRef` and the parameters after the `extend` clause are repeated in each
-method definition:
+given extension [T](xs: List[T])(given Ordering[T]) {
+  def largest(n: Int) = xs.sort.takeRight(n)
+}
 ```
+If a given extension is anonymous (as in the last clause), its name is synthesized from the name of the first defined extension method.
+
+The extensions above are equivalent to the following regular given instances where the implemented parent is `AnyRef` and the parameters in the `extension` clause are repeated in each extension method definition:
+```scala
 given stringOps: AnyRef {
   def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
-given AnyRef {
+given listOps: AnyRef {
   def [T](xs: List[T]) second = xs.tail.head
   def [T](xs: List[T]) third: T = xs.tail.tail.head
 }
+given AnyRef {
+  def [T](xs: List[T]) largest (given Ordering[T])(n: Int) =
+    xs.sort.takeRight(n)
+}
 ```
 
 ### Syntax
 
-The required syntax extension just adds one clause for extension methods relative
-to the [current syntax](../../internals/syntax.md).
+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] ‘extends’ ExtParamClause {GivenParamClause} ExtMethods
+                       [id ‘:’] ‘extension’ ExtParamClause {GivenParamClause} ExtMethods
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ```

tests/pos/reference/extension-methods.scala

@@ -41,26 +41,36 @@ object Test with
 
   List(1, 2, 3).second[Int]
 
-  given stringOps extends (xs: Seq[String]) {
+  given stringOps: extension (xs: Seq[String]) {
     def longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
     }
   }
 
-  given extends [T](xs: List[T]) with
+  given listOps: extension [T](xs: List[T]) with
     def second = xs.tail.head
     def third: T = xs.tail.tail.head
 
+
+  given extension [T](xs: List[T])(given Ordering[T]) with
+    def largest(n: Int) = xs.sorted.takeRight(n)
+
   given stringOps1: AnyRef {
     def (xs: Seq[String]) longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
     }
   }
-  given AnyRef {
+
+  given listOps1: AnyRef {
     def [T](xs: List[T]) second = xs.tail.head
     def [T](xs: List[T]) third: T = xs.tail.tail.head
   }
 
+  given AnyRef {
+    def [T](xs: List[T]) largest (given Ordering[T])(n: Int) =
+      xs.sorted.takeRight(n)
+  }
+
 end Test