Drop extension keyword

Author: odersky

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

@@ -3322,6 +3322,22 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
+    /** Are the next tokens a prefix of a DefParam? */
+    def isDefParam() =
+      val lookahead = in.LookaheadScanner()
+      if lookahead.token == LPAREN then
+        lookahead.nextToken()
+        if lookahead.token == AT then true
+        else if lookahead.token == IDENTIFIER then
+          if lookahead.name == nme.inline then
+            lookahead.nextToken()
+          if lookahead.token == IDENTIFIER then
+            lookahead.nextToken()
+            lookahead.token == COLON
+          else false
+        else false
+      else false
+
     /** OLD:
      *  GivenDef       ::=  [id] [DefTypeParamClause] GivenBody
      *  GivenBody      ::=  [‘as ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
@@ -3338,11 +3354,7 @@ object Parsers {
       var mods1 = addMod(mods, instanceMod)
       var isExtension = false
       val name =
-        if isIdent(nme.extension) then
-          in.nextToken()
-          isExtension = true
-          EmptyTermName
-        else if newStyle && allowOldGiven && isIdent(nme.as) then EmptyTermName
+        if newStyle && allowOldGiven && isIdent(nme.as) then EmptyTermName
         else if isIdent then ident()
         else EmptyTermName
       indentRegion(name) {
@@ -3359,12 +3371,13 @@ object Parsers {
             tokenSeparated(COMMA, constrApp)
           else if in.token == COLON then
             in.nextToken()
-            if isIdent(nme.extension) then
+            if in.token == LBRACE
+               || in.token == LBRACKET
+               || in.token == LPAREN && isDefParam() then
               if tparams.nonEmpty then
-                syntaxError(i"no type parameters allowed before `extension`", tparams.head.span)
+                syntaxError(i"no type parameters allowed for extension", tparams.head.span)
               if leadingParamss.nonEmpty then
-                syntaxError(i"no parameters allowed before `extension`", leadingParamss.head.head.span)
-              in.nextToken()
+                syntaxError(i"no parameters allowed for extension", leadingParamss.head.head.span)
               parseParams()
               Nil
             else tokenSeparated(COMMA, constrApp)

docs/docs/internals/syntax.md

@@ -389,7 +389,7 @@ ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
 GivenDef          ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
                     |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                    |  ‘extension’ [id ‘:’] [ExtParamClause] TemplateBody
+                    |  [id ‘:’] [ExtParamClause] TemplateBody
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)

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

@@ -84,39 +84,36 @@ So `circle.circumference` translates to `CircleOps.circumference(circle)`, provi
 
 ### 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 the special identifier
-`extension`. E.g.,
+Given instances that define extension methods can also be defined without a parent clause. E.g.,
 
 ```scala
-given stringOps: extension {
+given stringOps: {
   def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-given extension {
+given {
   def (xs: List[T]) second[T] = xs.tail.head
 }
 ```
-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.
+If an extensions is anonymous (as in the second clause), its name is synthesized from the name of the first defined extension method.
 
 ### 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: extension {
+given 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 in front of the opening brace. The following version is a shorthand for the code above.
 ```scala
-given listOps: extension[T](xs: List[T]) {
+given listOps: [T](xs: List[T]) {
   def second: T = xs.tail.head
   def third: T = xs.tail.tail.head
 }
@@ -176,6 +173,6 @@ Here are the required syntax extensions compared to the
 DefSig            ::=  ...
                     |  ‘(’ DefParam ‘)’ [nl] id [DefTypeParamClause] DefParamClauses
 GivenDef          ::=  ...
-                    |  [id ‘:’] ‘extension’ ExtParamClause TemplateBody
+                    |  [id ‘:’] [ExtParamClause] TemplateBody
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
 ```

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

@@ -68,7 +68,7 @@ Anonymous given instances that define extension methods without also implementin
 get their name from the name of the first extension method and the toplevel type
 constructor of its first parameter. For example, the given extension
 ```scala
-  given extension {
+  given {
     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 extension {
+    given {
       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: extension {
+  given 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)

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

tests/neg/extmethod-overload.scala

@@ -1,8 +1,8 @@
 object Test {
-  given A: extension {
+  given A: {
     def (x: Int) |+| (y: Int) = x + y
   }
-  given B: extension {
+  given B: {
     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 extension {
+  given {
     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 extension {
+  given {
     def (y: Any) g given Foo: Any = ???
   }
 

tests/pos/i7087.scala

@@ -6,7 +6,7 @@ type F[T] = T match {
   case G[a] => String
 }
 
-given extension {
+given {
   def (tup: T) g[T] given (Foo: F[T]) = ???
 }
 

tests/pos/implicit-scope.scala

@@ -9,7 +9,7 @@ object A {
   type FlagSet = opaques.FlagSet
   def FlagSet(bits: Long): FlagSet = opaques.FlagSet(bits)
 
-  given extension {
+  given {
     def (xs: FlagSet) bits: Long = opaques.toBits(xs)
     def (xs: FlagSet) | (ys: FlagSet): FlagSet = FlagSet(xs.bits | ys.bits)
   }

tests/pos/mirror-implicit-scope.scala

@@ -3,14 +3,14 @@ import scala.deriving._
 object Test {
   object K0 {
     type Generic[T] = Mirror { type Scope = K0.type ; type MirroredType = T ; type MirroredElemTypes }
-    given extension {
+    given {
       inline def (gen: Generic[T]) toRepr[T <: Product](t: T): gen.MirroredElemTypes = Tuple.fromProduct(t).asInstanceOf
     }
   }
 
   object K1 {
     type Generic[F[_]] = Mirror { type Scope = K1.type ; type MirroredType = F ; type MirroredElemTypes[_] }
-    given extension {
+    given {
       inline def (gen: Generic[F]) toRepr[F[_] <: Product, T](t: F[T]): gen.MirroredElemTypes[T] = Tuple.fromProduct(t).asInstanceOf
     }
   }

tests/pos/reference/delegates.scala

@@ -48,14 +48,14 @@ object Instances extends Common {
     }
   }
 
-  given stringOps: extension {
+  given stringOps: {
     def (xs: Seq[String]) longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
     }
   }
 
-  given extension {
+  given {
     def (xs: List[T]) second[T] = xs.tail.head
   }
 
@@ -152,14 +152,14 @@ object Instances extends Common {
 object PostConditions {
   opaque type WrappedResult[T] = T
 
-  private given WrappedResult: extension {
+  private given WrappedResult: {
     def apply[T](x: T): WrappedResult[T] = x
     def (x: WrappedResult[T]) unwrap[T]: T = x
   }
 
   def result[T] given (wrapped: WrappedResult[T]): T = wrapped.unwrap
 
-  given extension {
+  given {
     def (x: T) ensuring[T] (condition: given WrappedResult[T] => Boolean): T = {
       assert(condition given WrappedResult(x))
       x
@@ -184,14 +184,14 @@ object AnonymousInstances extends Common {
     }
   }
 
-  given extension {
+  given {
     def (xs: Seq[String]) longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
     }
   }
 
-  given extension {
+  given {
     def (xs: List[T]) second[T] = xs.tail.head
   }
 

tests/pos/reference/opaque.scala

@@ -12,7 +12,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  given extension {
+  given {
     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: extension {
+    given Foo: {
       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 extension {
+  given {
     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 extension { def (b: Int) <<<< : Int = b }
+  given { def (b: Int) <<<< : Int = b }
 
   def main(args: Array[String]): Unit = {
     1.<<<

tests/run/instances-anonymous.scala

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

tests/run/instances.scala

@@ -8,15 +8,15 @@ object Test extends App {
 
   case class Circle(x: Double, y: Double, radius: Double)
 
-  given circleOps: extension {
+  given circleOps: {
     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 stringOps: extension {
+  given stringOps: {
     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 seqOps: extension {
+  given seqOps: {
     def (xs: Seq[T]) second[T] = xs.tail.head
   }
 
   assert(names.longestStrings.second == "world")
 
-  given listListOps: extension {
+  given listListOps: {
     def (xs: List[List[T]]) flattened[T] = xs.foldLeft[List[T]](Nil)(_ ++ _)
   }
 
   // A right associative op
-  given prepend: extension {
+  given prepend: {
     def (x: T) ::[T] (xs: Seq[T]) = x +: xs
   }
   val ss: Seq[Int] = List(1, 2, 3)