Change to new extension method syntax

It's

    given extension { ... }

or

    given extension ops: { ... }

Author: odersky

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

@@ -434,6 +434,7 @@ object StdNames {
     val eval: N                 = "eval"
     val eqlAny: N               = "eqlAny"
     val ex: N                   = "ex"
+    val extension: N            = "extension"
     val experimental: N         = "experimental"
     val f: N                    = "f"
     val false_ : N              = "false"

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

@@ -33,6 +33,9 @@ object Parsers {
   import reporting.diagnostic.Message
   import reporting.diagnostic.messages._
 
+  private inline val allowOldGiven = true
+  private inline val allowOldExtension = true
+
   case class OpInfo(operand: Tree, operator: Ident, offset: Offset)
 
   class ParensCounters {
@@ -795,7 +798,7 @@ object Parsers {
      *   - continue a statement (e.g. `else`, catch`)?
      */
     def followedByToken(query: Token): Boolean = {
-      val lookahead = in.lookaheadScanner
+      val lookahead = in.LookaheadScanner()
       var braces = 0
       while (true) {
         val token = lookahead.token
@@ -815,7 +818,7 @@ object Parsers {
 
     /** A the generators of a for-expression enclosed in (...)? */
     def parensEncloseGenerators: Boolean = {
-      val lookahead = in.lookaheadScanner
+      val lookahead = in.LookaheadScanner()
       var parens = 1
       lookahead.nextToken()
       while (parens != 0 && lookahead.token != EOF) {
@@ -891,7 +894,7 @@ object Parsers {
           }
           else recur(operand())
         }
-        else if (in.token == GIVEN && !isType) {
+        else if (in.token == GIVEN && allowOldGiven && !isType) {
           val top1 = reduceStack(base, top, minInfixPrec, leftAssoc = true, nme.WITHkw, isType)
           assert(opStack `eq` base)
           recur(applyGiven(top1, operand))
@@ -2122,7 +2125,7 @@ object Parsers {
      */
     def parArgumentExprss(fn: Tree): Tree = {
       def isLegalAnnotArg: Boolean = {
-        val lookahead = in.lookaheadScanner
+        val lookahead = in.LookaheadScanner()
         (lookahead.token == LPAREN) && {
           lookahead.nextToken()
           if (lookahead.token == RPAREN)
@@ -2580,8 +2583,13 @@ object Parsers {
     /** ClosureMods ::=  { ‘implicit’ | ‘erased’ | ‘given’}
      *  FunTypeMods ::=  { ‘erased’ | ‘given’}
      */
-    val closureMods: BitSet = BitSet(GIVEN, IMPLICIT, ERASED)
-    val funTypeMods: BitSet = BitSet(GIVEN, ERASED)
+    val closureMods: BitSet =
+      if allowOldGiven then BitSet(GIVEN, IMPLICIT, ERASED)
+      else BitSet(IMPLICIT)
+
+    val funTypeMods: BitSet =
+      if allowOldGiven then BitSet(GIVEN, ERASED)
+      else BitSet()
 
     /** Wrap annotation or constructor in New(...).<init> */
     def wrapNew(tpt: Tree): Select = Select(New(tpt), nme.CONSTRUCTOR)
@@ -2765,7 +2773,7 @@ object Parsers {
                      ofInstance: Boolean = false): List[List[ValDef]] = {
 
       def followingIsParamClause: Boolean = {
-        val lookahead = in.lookaheadScanner
+        val lookahead = in.LookaheadScanner()
         lookahead.nextToken()
         paramIntroTokens.contains(lookahead.token) && {
           lookahead.token != IDENTIFIER ||
@@ -2792,7 +2800,7 @@ object Parsers {
        */
       def followingIsInstanceDef =
         (ofClass || ofInstance) && {
-          val lookahead = in.lookaheadScanner // skips newline on startup
+          val lookahead = in.LookaheadScanner() // skips newline on startup
           lookahead.nextToken()  // skip the `given`
           if (lookahead.token == LBRACKET) true
           else {
@@ -2818,9 +2826,9 @@ object Parsers {
         var initialMods = EmptyModifiers
         val isNewLine = in.token == NEWLINE
         newLineOptWhenFollowedBy(LPAREN)
-        if (in.token == NEWLINE && in.next.token == GIVEN && !followingIsInstanceDef)
+        if (in.token == NEWLINE && in.next.token == GIVEN && allowOldGiven && !followingIsInstanceDef)
           in.nextToken()
-        if (in.token == GIVEN) {
+        if (in.token == GIVEN && allowOldGiven) {
           in.nextToken()
           initialMods |= Given
         }
@@ -3322,31 +3330,52 @@ object Parsers {
      *  NEW:
      *  GivenDef       ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
      *                   |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-     *                // |  [id ‘:’] [ExtParamClause] TemplateBody   (not yet implemented)
+     *                   |  ‘extension’ [id ‘:’] [ExtParamClause] TemplateBody
      *  ExtParamClause ::=  [DefTypeParamClause] DefParamClause {GivenParamClause}
      *  GivenSig       ::=  [id] [DefTypeParamClause] {GivenParamClause}
      */
     def instanceDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
-      val name = if (isIdent && !(newStyle && isIdent(nme.as))) ident() else EmptyTermName
-      indentRegion(name) {
-        val tparams = typeParamClauseOpt(ParamOwner.Def)
-        var leadingParamss =
-          if (in.token == LPAREN)
-            try paramClause(prefix = true) :: Nil
-            finally {
-              possibleTemplateStart()
-              if (!in.isNestedStart) syntaxErrorOrIncomplete("`{' expected")
+
+      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`
+              in.nextToken()
+              tokenSeparated(COMMA, constrApp)
             }
-          else Nil
-        val parents =
-          if (!newStyle && in.token == FOR || isIdent(nme.as)) { // for the moment, accept both `given for` and `given as`
-            in.nextToken()
-            tokenSeparated(COMMA, constrApp)
-          }
-          else Nil
-        val vparamss = paramClauses(ofInstance = true)
-        val instDef =
+            else Nil
+          val vparamss = paramClauses(ofInstance = true)
           if (in.token == EQUALS && parents.length == 1 && parents.head.isType) {
             in.nextToken()
             mods1 |= Final
@@ -3365,15 +3394,16 @@ object Parsers {
             if (tparams.isEmpty && vparamss1.isEmpty || leadingParamss.nonEmpty) ModuleDef(name, templ)
             else TypeDef(name.toTypeName, templ)
           }
-        finalizeDef(instDef, mods1, start)
+        }
       }
+
+      val gdef = if isIdent(nme.extension) then extensionDef() else regularDef()
+      finalizeDef(gdef, mods1, start)
     }
 
 /* -------- TEMPLATES ------------------------------------------- */
 
     /** SimpleConstrApp  ::=  AnnotType {ParArgumentExprs}
-     *  ConstrApp        ::=  SimpleConstrApp
-     *                     |  ‘(’ SimpleConstrApp {‘given’ (PrefixExpr | ParArgumentExprs)} ‘)’
      */
     val constrApp: () => Tree = () => {
 
@@ -3393,7 +3423,7 @@ object Parsers {
       def givenArgs(t: Tree): Tree =
         if (in.token == GIVEN) givenArgs(applyGiven(t, prefixExpr)) else t
 
-      if (in.token == LPAREN)
+      if (allowOldGiven && in.token == LPAREN)
         inParens {
           val t = toplevelTyp()
           if (isAnnotType(t))

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

@@ -140,7 +140,7 @@ object Scanners {
     val keepComments = !ctx.settings.YdropComments.value
 
     /** A switch whether operators at the start of lines can be infix operators */
-    private var allowLeadingInfixOperators = true
+    private[Scanners] var allowLeadingInfixOperators = true
 
     val isScala2Mode: Boolean = ctx.scala2Setting
 
@@ -326,7 +326,7 @@ object Scanners {
      */
     private def handleEndMarkers(width: IndentWidth): Unit =
       if (next.token == IDENTIFIER && next.name == nme.end && width == currentRegion.indentWidth) {
-        val lookahead = lookaheadScanner
+        val lookahead = LookaheadScanner()
         lookahead.nextToken() // skip the `end`
 
         def handle(tag: EndMarkerTag) = {
@@ -378,7 +378,7 @@ object Scanners {
       && ch == ' '
       && !pastBlankLine
       && {
-        val lookahead = lookaheadScanner
+        val lookahead = LookaheadScanner()
         lookahead.allowLeadingInfixOperators = false
           // force a NEWLINE a after current token if it is on its own line
         lookahead.nextToken()
@@ -865,18 +865,25 @@ object Scanners {
 
 // Lookahead ---------------------------------------------------------------
 
-    /** A new Scanner that starts at the current token offset */
-    def lookaheadScanner: Scanner = new Scanner(source, offset) {
+    class LookaheadScanner extends Scanner(source, offset) {
       override val indentSyntax = false
       override protected def printState() = {
         print("la:")
         super.printState()
       }
+
+      final def skipParens(opening: Token): Unit = {
+        nextToken()
+        while token != EOF && token != opening + 1 do
+          if (token == opening) skipParens(opening)
+          else nextToken()
+        nextToken()
+      }
     }
 
     /** Is the token following the current one in `tokens`? */
     def lookaheadIn(tokens: BitSet): Boolean = {
-      val lookahead = lookaheadScanner
+      val lookahead = LookaheadScanner()
       while ({
         lookahead.nextToken()
         lookahead.token == NEWLINE || lookahead.token == NEWLINES
@@ -887,7 +894,7 @@ object Scanners {
 
     /** Is the current token in a position where a modifier is allowed? */
     def inModifierPosition(): Boolean = {
-      val lookahead = lookaheadScanner
+      val lookahead = LookaheadScanner()
       while ({
         lookahead.nextToken()
         lookahead.token == NEWLINE || lookahead.token == NEWLINES || lookahead.isSoftModifier

docs/docs/internals/syntax.md

@@ -389,13 +389,14 @@ ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
 GivenDef          ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
                     |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                    |  [GivenSig ‘:’] [DefTypeParamClause] DefParamClause TemplateBody
+                    |  ‘extension’ [id ‘:’] [ExtParamClause] TemplateBody
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
+ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
                     |  ConstrApp {‘,’ ConstrApp}
-ConstrApp         ::=  AnnotType {ArgumentExprs}                                Apply(tp, args)
+ConstrApp         ::=  AnnotType {ParArgumentExprs}                             Apply(tp, args)
 ConstrExpr        ::=  SelfInvocation
                     |  ‘{’ SelfInvocation {semi BlockStat} ‘}’
 SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}

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

@@ -84,36 +84,40 @@ So `circle.circumference` translates to `CircleOps.circumference(circle)`, provi
 
 ### Given Instances for Extension Methods
 
-Given instances that define extension methods can also be defined without an `as` clause. E.g.,
+Given instances that define extension methods can also be defined without a parent clause. In this case the `given` is followed  by
+`extension`. E.g.,
 
 ```scala
-given StringOps {
+given extension stringOps: {
   def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-given {
+given extension {
   def (xs: List[T]) second[T] = xs.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.
+If given extensions are anonymous (as in the second clause), their name is synthesized from the name of the first defined extension method.
 
-### Given Instances with Collective Parameters
+Note: `extension` is a soft keyword, it can be used elsewhere
+as a normal identifier.
 
-If a given instance has several extension methods one can pull out the left parameter section
+### 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 ListOps {
+given extension listOps: {
   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 into the given instance itself. The following version is a shorthand for the code above.
+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 ListOps[T](xs: List[T]) {
+given extension listOps: [T](xs: List[T]) {
   def second: T = xs.tail.head
   def third: T = xs.tail.tail.head
 }
@@ -170,8 +174,8 @@ As usual, type parameters of the extension method follow the defined method name
 The required syntax extension just adds one clause for extension methods relative
 to the [current syntax](../../internals/syntax.md).
 ```
-DefSig            ::=  ...
-                    |  ‘(’ DefParam ‘)’ [nl] id [DefTypeParamClause] DefParamClauses
-GivenBody         ::=  ...
+GivenDef          ::=  ...
+                    |  ‘extension’ [id ‘:’] ExtParamClause TemplateBody
+ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
                     |  ‘(’ DefParam ‘)’ TemplateBody
 ```

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

@@ -66,9 +66,9 @@ The synthesized type names are formed from
 
 Anonymous given instances that define extension methods without also implementing a type
 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
+constructor of its first parameter. For example, the given extension
 ```scala
-  given {
+  given extension {
     def (xs: List[T]) second[T] = ...
   }
 ```

docs/docs/reference/metaprogramming/macros.md

@@ -251,7 +251,7 @@ The `toExpr` extension method is defined in package `quoted`:
 ```scala
     package quoted
 
-    given ExprOps {
+    given extension {
       def (x: T) toExpr[T: Liftable] given QuoteContext: Expr[T] = summon[Liftable[T]].toExpr(x)
       ...
     }

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

@@ -20,7 +20,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  given LogarithmOps {
+  given extension logarithmOps: {
     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)
@@ -57,7 +57,7 @@ But the following operations would lead to type errors:
   l / l2                  // error: `/` is not a member fo Logarithm
 ```
 
-Aside: the `any2stringadd => _` import suppression is necessary since otherwise the universal `+` operation in `Predef` would take precedence over the `+` extension method in `LogarithmOps`. We plan to resolve this wart by eliminating `any2stringadd`.
+Aside: the `any2stringadd => _` import suppression is necessary since otherwise the universal `+` operation in `Predef` would take precedence over the `+` extension method in `logarithmOps`. We plan to resolve this wart by eliminating `any2stringadd`.
 
 ### Bounds For Opaque Type Aliases
 

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 arrayOps {
+  given extension arrayOps: {
 
     /** The selection operation on an immutable array.
       *