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]) = ???
 }