Make with optional in extension methods

Author: odersky

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

@@ -3544,7 +3544,7 @@ object Parsers {
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val extParams = paramClause(0, prefix = true)
       val givenParamss = paramClauses(givenOnly = true)
-      accept(WITH)
+      possibleTemplateStart()
       if !in.isNestedStart then syntaxError("Extension without extension methods")
       val templ = templateBodyOpt(makeConstructor(tparams, extParams :: givenParamss), Nil, Nil)
       templ.body.foreach(checkExtensionMethod(tparams, _))

docs/docs/internals/syntax.md

@@ -389,9 +389,8 @@ GivenDef          ::=  [GivenSig (‘:’ | <:)] {FunArgTypes ‘=>’}
                     |  [GivenSig ‘:’] {FunArgTypes ‘=>’}
                        ConstrApps [[‘with’] TemplateBody]
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
-ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause}
-                       ‘with’ ExtMethods
-ExtMethods        ::=  ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
+ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause} ExtMethods
+ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 Template          ::=  InheritClauses [[‘with’] TemplateBody]                   Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]

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

@@ -128,19 +128,19 @@ A collective extension defines one or more concrete methods that have the same t
 and prefix parameter. Examples:
 
 ```scala
-extension stringOps of (xs: Seq[String]) with {
+extension stringOps of (xs: Seq[String]) {
   def longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-extension listOps of [T](xs: List[T]) with {
+extension listOps of [T](xs: List[T]) {
   def second = xs.tail.head
   def third: T = xs.tail.tail.head
 }
 
-extension of [T](xs: List[T])(given Ordering[T]) with {
+extension of [T](xs: List[T])(given Ordering[T]) {
   def largest(n: Int) = xs.sorted.takeRight(n)
 }
 ```
@@ -176,6 +176,6 @@ DefSig            ::=  ...
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 TmplDef           ::=  ...
                     |  ‘extension’ ExtensionDef
-ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause} ‘with’ ExtMethods
+ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause} ExtMethods
 ExtMethods        ::=  ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ```

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

@@ -72,7 +72,7 @@ Anonymous collective extensions also get compiler synthesized names, which are f
 
 For example, the extension
 ```scala
-extension of [T] (xs: List[T]) with {
+extension of [T] (xs: List[T]) {
   def second = ...
 }
 ```

tests/neg/extension-methods.scala

@@ -10,7 +10,7 @@ object Test {
   "".l2 // error
   1.l1 // error
 
-  extension of [T](xs: List[T]) with {
+  extension of [T](xs: List[T]) {
     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,9 @@
 object Test {
-  extension a of (x: Int) with
+  extension a of (x: Int) {
     def |+| (y: Int) = x + y
+  }
 
-  extension b of (x: Int) with {
+  extension b of (x: Int) {
     def |+| (y: String) = x + y.length
   }
   assert((1 |+| 2) == 3)  // error ambiguous

tests/neg/i5455.scala

@@ -11,9 +11,10 @@ object Library {
     def toInt(n: Nat): Int = n
 
   }
-  extension of (x: Nat) with
+  extension of (x: Nat) {
     def * (y: Nat): Nat = x * y
     def toInt: Int = x
+  }
 }
 
 object User extends App {

tests/neg/i6801.scala

@@ -1,4 +1,4 @@
-extension myNumericOps of [T](x: T) with {
+extension myNumericOps of [T](x: T) {
   def + (y: T)(given n: Numeric[T]): T = n.plus(x,y)
 }
 def foo[T: Numeric](x: T) = 1f + x // error: no implicit argument of type Numeric[Any]

tests/pos/i7084.scala

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

tests/pos/i7087.scala

@@ -6,7 +6,7 @@ type F[T] = T match {
   case G[a] => String
 }
 
-extension of [T](tup: T) with {
+extension of [T](tup: T) {
   def g(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)
 
-  extension of (xs: FlagSet) with {
+  extension of (xs: FlagSet) {
     def bits: Long = opaques.toBits(xs)
     def | (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 }
-    extension of [T <: Product](gen: Generic[T]) with {
+    extension of [T <: Product](gen: Generic[T]) {
       inline def toRepr (t: T): gen.MirroredElemTypes = Tuple.fromProduct(t).asInstanceOf
     }
   }
 
   object K1 {
     type Generic[F[_]] = Mirror { type Scope = K1.type ; type MirroredType = F ; type MirroredElemTypes[_] }
-    extension of [F[_] <: Product, T](gen: Generic[F]) with {
+    extension of [F[_] <: Product, T](gen: Generic[F]) {
       inline def toRepr (t: F[T]): gen.MirroredElemTypes[T] = Tuple.fromProduct(t).asInstanceOf
     }
   }

tests/pos/reference/extension-methods.scala

@@ -41,7 +41,7 @@ object ExtMethods with
 
   List(1, 2, 3).second[Int]
 
-  extension stringOps of (xs: Seq[String]) with {
+  extension stringOps of (xs: Seq[String]) {
     def longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)

tests/pos/reference/opaque.scala

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

tests/pos/tasty-reflect-opaque-api-proto.scala

@@ -10,7 +10,7 @@ class Reflect(val internal: CompilerInterface) {
   opaque type Term <: Tree = internal.Term
 
   object Tree {
-    extension ops of (tree: Tree) with {
+    extension ops of (tree: Tree) {
       def show: String = ???
     }
   }

tests/run/extmethod-overload.scala

@@ -97,7 +97,7 @@ object Test extends App {
     def (x: Int).yy(y: Int) = x + y
   }
 
-  extension of (x: Int) with {
+  extension of (x: Int) {
     def yy (y: Int) = x - y
   }
 

tests/run/extmethods2.scala

@@ -16,15 +16,15 @@ object Test extends App {
   test(given TC())
 
   object A {
-    extension listOps of [T](xs: List[T]) with {
+    extension listOps of [T](xs: List[T]) {
       def second: T = xs.tail.head
       def third: T = xs.tail.tail.head
       def concat(ys: List[T]) = xs ++ ys
     }
-    extension polyListOps of [T, U](xs: List[T]) with {
+    extension polyListOps of [T, U](xs: List[T]) {
       def zipp(ys: List[U]): List[(T, U)] = xs.zip(ys)
     }
-    extension of (xs: List[Int]) with {
+    extension of (xs: List[Int]) {
       def prod = (1 /: xs)(_ * _)
     }
   }

tests/run/i6902.scala

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

tests/run/instances-anonymous.scala

@@ -8,7 +8,7 @@ object Test extends App {
 
   case class Circle(x: Double, y: Double, radius: Double)
 
-  extension of (c: Circle) with {
+  extension of (c: Circle) {
     def circumference: Double = c.radius * math.Pi * 2
   }
 
@@ -25,13 +25,13 @@ object Test extends App {
   val names = List("hi", "hello", "world")
   assert(names.longestStrings == List("hello", "world"))
 
-  extension of [T](xs: Seq[T]) with {
+  extension of [T](xs: Seq[T]) {
     def second = xs.tail.head
   }
 
   assert(names.longestStrings.second == "world")
 
-  extension of [T](xs: List[List[T]]) with {
+  extension of [T](xs: List[List[T]]) {
     def flattened = xs.foldLeft[List[T]](Nil)(_ ++ _)
   }