Drop collective extensions from tests and docs

Author: odersky

compiler/test-resources/repl/i8716_i8717

@@ -2,13 +2,13 @@ scala>extension { }
 1 |extension { }
   |^
   |anonymous instance must implement a type or have at least one extension method
-scala> extension as on
-1 | extension as on
+scala> extension as
+1 | extension as
   |                ^
   |                '(' expected, but eof found
-scala> extension as on (s
-1 | extension as on (s
+scala> extension as (s
+1 | extension as (s
   |                   ^
   |                   ':' expected, but eof found
-scala> extension as on (s: String) { def expand = ??? }
+scala> extension as (s: String) { def expand = ??? }
 // defined object as

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

@@ -61,23 +61,6 @@ The synthesized type names are formed from
 Tuples are treated as transparent, i.e. a type `F[(X, Y)]` would get the synthesized name
 `F_X_Y`. Directly implemented function types `A => B` are represented as `A_to_B`. Function types used as arguments to other type constructors are represented as `Function`.
 
-### Anonymous Collective Extensions
-
-Anonymous collective extensions also get compiler synthesized names, which are formed from
-
- - the prefix `extension_`
- - the name of the first defined extension method
- - the simple name of the first parameter type of this extension method
- - the simple name(s) of the toplevel argument type constructors to this type.
-
-For example, the extension
-```scala
-extension on [T] (xs: List[T]) {
-  def second = ...
-}
-```
-gets the synthesized name `extension_second_List_T`.
-
 ### Given Clauses
 
 Given clauses correspond largely to Scala-2's implicit parameter clauses. E.g.

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

@@ -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 on (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 on (x: C):
+    extension (x: C):
       def ff: String = x.f ++ x.f
     end extension
 

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

@@ -21,7 +21,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  extension logarithmOps on (x: Logarithm) {
+  extension (x: Logarithm) {
     def toDouble: Double = math.exp(x)
     def + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
     def * (y: Logarithm): Logarithm = x + y
@@ -36,8 +36,7 @@ Or in other words, within the scope it is treated as type alias, but this is opa
 where in consequence `Logarithm` is seen as an abstract type and has nothing to do with `Double`.
 
 The public API of `Logarithm` consists of the `apply` and `safe` methods defined in the companion object.
-They convert from `Double`s to `Logarithm` values. Moreover, a collective extension `logarithmOps` provides the extension methods `toDouble` that converts the other way,
-and operations `+` and `*` on `Logarithm` values.
+They convert from `Double`s to `Logarithm` values. Moreover, an operation `toDouble` that converts the other way, and operations `+` and `*` are defined as extension methods on `Logarithm` values.
 The following operations would be valid because they use functionality implemented in the `Logarithms` object.
 
 ```scala

tests/neg/anonymous-instance-cannot-be-empty.check

@@ -1,3 +1,3 @@
 object Test {
-  extension on[T] (t: T) { } // error
+  extension [T] (t: T) { } // error
 }

tests/neg/anonymous-instance-cannot-be-empty.scala

@@ -1,5 +1,5 @@
 object Test {
-  extension on[T] (t: T) {
-    def f[U](u: U): T = ??? // error : extension method cannot have type params
+  extension [T] (t: T) {
+    def f[U](u: U): T = ??? // error: extension method cannot have type parameters here, all type parameters go after `extension`
   }
 }

tests/neg/extension-cannot-have-type.check

@@ -1,5 +1,5 @@
 object Test {
-  extension on[T] (t: T) {
+  extension [T] (t: T) {
     extension (c: T) def f: T = ??? // error : No extension method allowed here
   }
 }