Syntax change: "extension on" instead of "extension of"

"extension on" is more precise. The thing after the "of/on" is a parameter.
The definition is not an extension "of" this parameter (what does that even
mean?), but rather an extension of the parameter's underlying type.

Note that Dart also uses "extension on".

Author: odersky

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -529,8 +529,8 @@ object StdNames {
     val notify_ : N             = "notify"
     val null_ : N               = "null"
     val nullExpr: N             = "nullExpr"
-    val of: N                   = "of"
     val ofDim: N                = "ofDim"
+    val on: N                   = "on"
     val opaque: N               = "opaque"
     val open: N                 = "open"
     val ordinal: N              = "ordinal"

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

@@ -948,9 +948,9 @@ object Parsers {
     def followingIsExtension() =
       val lookahead = in.LookaheadScanner()
       lookahead.nextToken()
-      if lookahead.isIdent && !lookahead.isIdent(nme.of) then
+      if lookahead.isIdent && !lookahead.isIdent(nme.on) then
         lookahead.nextToken()
-      lookahead.isIdent(nme.of)
+      lookahead.isIdent(nme.on)
 
 /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
@@ -3538,9 +3538,9 @@ object Parsers {
      */
     def extensionDef(start: Offset, mods: Modifiers): ModuleDef =
       in.nextToken()
-      val name = if isIdent && !isIdent(nme.of) then ident() else EmptyTermName
-      if !isIdent(nme.of) then syntaxErrorOrIncomplete("`of` expected")
-      if isIdent(nme.of) then in.nextToken()
+      val name = if isIdent && !isIdent(nme.on) then ident() else EmptyTermName
+      if !isIdent(nme.on) then syntaxErrorOrIncomplete("`on` expected")
+      if isIdent(nme.on) then in.nextToken()
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val extParams = paramClause(0, prefix = true)
       val givenParamss = paramClauses(givenOnly = true)

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]) {
+extension stringOps on (xs: Seq[String]) {
   def longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-extension listOps of [T](xs: List[T]) {
+extension listOps on [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]) {
+extension on [T](xs: List[T])(given Ordering[T]) {
   def largest(n: Int) = xs.sorted.takeRight(n)
 }
 ```
@@ -164,18 +164,19 @@ given extension_largest_List_T: AnyRef {
 }
 ```
 
-`extension` and `of` are soft keywords. They can also be used as a regular identifiers.
+`extension` and `on` are soft keywords. They can also be used as a regular identifiers.
 
 ### Syntax
 
 Here are the syntax changes for extension methods and given extensions relative
-to the [current syntax](../../internals/syntax.md). `extension` is a soft keyword, recognized only after a `given`. It can be used as an identifier everywhere else.
+to the [current syntax](../../internals/syntax.md). `extension` is a soft keyword, recognized only in tandem with `on`. It can be used as an identifier everywhere else.
+
 ```
 DefSig            ::=  ...
                     |  ExtParamClause [nl] [‘.’] id DefParamClauses
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 TmplDef           ::=  ...
                     |  ‘extension’ ExtensionDef
-ExtensionDef      ::=  [id] ‘of’ ExtParamClause {GivenParamClause} ExtMethods
+ExtensionDef      ::=  [id] ‘on’ 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]) {
+extension on [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]) {
+  extension on [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,9 +1,9 @@
 object Test {
-  extension a of (x: Int) {
+  extension a on (x: Int) {
     def |+| (y: Int) = x + y
   }
 
-  extension b of (x: Int) {
+  extension b on (x: Int) {
     def |+| (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
 
   }
-  extension of (x: Nat) {
+  extension on (x: Nat) {
     def * (y: Nat): Nat = x * y
     def toInt: Int = x
   }

tests/neg/i6801.scala

@@ -1,4 +1,4 @@
-extension myNumericOps of [T](x: T) {
+extension myNumericOps on [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/neg/i6900.scala

@@ -1,7 +1,7 @@
 object Test2 {
 
   // Works with extension method
-  extension of [A](a: A) with
+  extension on [A](a: A) with
     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 fooOps of [A](a: A) with
+extension fooOps on [A](a: A) with
 
   @nonsense    // error: not found: nonsense
   def foo = ???