Drop : for collective extensions

Author: odersky

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

@@ -3646,12 +3646,12 @@ object Parsers {
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val extParams = paramClause(0, prefix = true)
       val givenParamss = paramClauses(givenOnly = true)
-      newLinesOpt()
       val methods =
         if isDefIntro(modifierTokens) then
           extMethod() :: Nil
         else
-          possibleTemplateStart()
+          in.observeIndented()
+          newLineOptWhenFollowedBy(LBRACE)
           if in.isNestedStart then inDefScopeBraces(extMethods())
           else { syntaxError("Extension without extension methods"); Nil }
       val result = ExtMethods(tparams, extParams :: givenParamss, methods)

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

@@ -95,7 +95,7 @@ left-hand parameter type. In this case one can "pull out" the common parameters
 a single extension and enclose all methods in braces or an indented region following a '`:`'.
 Example:
 ```scala
-extension (ss: Seq[String]):
+extension (ss: Seq[String])
 
   def longestStrings: Seq[String] =
     val maxLength = ss.map(_.length).max
@@ -118,9 +118,9 @@ extension (ss: Seq[String])
 extension (ss: Seq[String])
   def longestString: String = ss.longestStrings.head
 ```
-Collective extensions also can take type parameters and have using clauses. Example:
+Collective extensions also can take type parameters and have using clauses. Example
 ```scala
-extension [T](xs: List[T])(using Ordering[T]):
+extension [T](xs: List[T])(using Ordering[T])
   def smallest(n: Int): List[T] = xs.sorted.take(n)
   def smallestIndices(n: Int): List[Int] =
     val limit = smallest(n).max
@@ -184,7 +184,7 @@ object List:
     def flatten: List[T] = xs.foldLeft(Nil: List[T])(_ ++ _)
 
   given [T: Ordering] as Ordering[List[T]]:
-    extension (xs: List[T]):
+    extension (xs: List[T])
       def < (ys: List[T]): Boolean = ...
 end List
 

docs/docs/reference/contextual/type-classes.md

@@ -139,7 +139,7 @@ trait Monad[F[_]] extends Functor[F]:
   /** The unit value for a monad */
   def pure[A](x: A): F[A]
 
-  extension [A, B](x: F[A]):
+  extension [A, B](x: F[A])
     /** The fundamental composition operation */
     def flatMap(f: A => F[B]): F[B]
 

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

@@ -94,7 +94,7 @@ at the toplevel, inside braces `{...}`, but not inside parentheses `(...)`, patt
 
 ### Optional Braces Around Template Bodies
 
-The Scala grammar uses the term _template body_ for the definitions of a class, trait, object, given instance or extension that are normally enclosed in braces. The braces around a template body can also be omitted by means of the following rule:
+The Scala grammar uses the term _template body_ for the definitions of a class, trait, object, given instance or extension that are normally enclosed in braces. The braces around a template body can also be omitted by means of the following rule
 
 If at the point where a template body can start there is a `:` that occurs at the end
 of a line, and that is followed by at least one indented statement, the recognized
@@ -123,7 +123,7 @@ type T = A:
 given [T] with Ord[T] as Ord[List[T]]:
   def compare(x: List[T], y: List[T]) = ???
 
-extension (xs: List[Int]):
+extension (xs: List[Int])
   def second: Int = xs.tail.head
 
 new A:
@@ -256,7 +256,7 @@ For instance, the following end markers are all legal:
       end given
     end C
 
-    extension (x: C):
+    extension (x: C)
       def ff: String = x.f ++ x.f
     end extension
 

tests/neg-custom-args/infix.scala

@@ -8,7 +8,7 @@ class C:
 
 object C:
   given AnyRef:
-    extension (x: C):
+    extension (x: C)
       @infix def iop (y: Int) = ???
       def mop (y: Int) = ???
       def ++ (y: Int) = ???

tests/neg/i6779.check

@@ -8,9 +8,8 @@
    |                           ^
    |                           Found:    F[T]
    |                           Required: F[G[T]]
--- [E006] Not Found Error: tests/neg/i6779.scala:13:27 -----------------------------------------------------------------
-13 |def g3[T](x: T): F[G[T]] = f(x)(using summon[Stuff]) // error
-   |                           ^
-   |                           Not found: f
-
-longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i6779.scala:13:41 -------------------------------------------------------------
+13 |def g3[T](x: T): F[G[T]] = extension_f(x)(using summon[Stuff]) // error
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                           Found:    F[T]
+   |                           Required: F[G[T]]

tests/neg/i6900.scala

@@ -1,7 +1,7 @@
 object Test2 {
 
   // Works with extension method
-  extension [A](a: A):
+  extension [A](a: A)
     def foo[C]: C => A = _ => a   // error: extension method cannot have type parameters
 
   1.foo.foo

tests/neg/i7529.scala

@@ -1,4 +1,4 @@
-extension [A](a: A):
+extension [A](a: A)
 
   @nonsense    // error: not found: nonsense
   def foo = ???

tests/neg/i8050.scala

@@ -1,5 +1,5 @@
 object stuff:
   def exec(dir: Int) = ???
 
-extension (a: Int):
+extension (a: Int)
   inline def exec: Unit = stuff.exec("aaa") // error

tests/neg/missing-implicit1.scala

@@ -7,7 +7,7 @@ object testObjectInstance:
   object instances {
     given zipOption as Zip[Option] = ???
     given traverseList as Traverse[List] = ???
-    extension [T](xs: List[T]):
+    extension [T](xs: List[T])
       def second: T = xs.tail.head
     extension [T](xs: List[T]) def first: T = xs.head
   }