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 = ???

tests/neg/missing-implicit1.scala

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

tests/pos/i6900.scala

@@ -21,7 +21,7 @@ object Test1 {
 object Test2 {
 
   // Works with extension method
-  extension of [A, C](a: A) with
+  extension on [A, C](a: A) with
     def foo: C => A = _ => a
 
   1.foo.foo

tests/pos/i7084.scala

@@ -2,7 +2,7 @@ object Test {
 
   type Foo
 
-  extension of (y: Any) {
+  extension on (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) {
+extension on [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) {
+  extension on (xs: FlagSet) {
     def bits: Long = opaques.toBits(xs)
     def | (ys: FlagSet): FlagSet = FlagSet(xs.bits | ys.bits)
   }

tests/pos/matrixOps.scala

@@ -3,7 +3,7 @@ object Test with
   type Matrix = Array[Array[Double]]
   type Vector = Array[Double]
 
-  extension of (m: Matrix) with
+  extension on (m: Matrix) with
     def nRows = m.length
     def nCols = m(0).length
     def row(i: Int): Vector = m(i)

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]) {
+    extension on [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]) {
+    extension on [F[_] <: Product, T](gen: Generic[F]) {
       inline def toRepr (t: F[T]): gen.MirroredElemTypes[T] = Tuple.fromProduct(t).asInstanceOf
     }
   }

tests/pos/reference/delegates.scala

@@ -39,12 +39,12 @@ object Instances extends Common with
         if (fst != 0) fst else xs1.compareTo(ys1)
   end listOrd
 
-  extension stringOps of (xs: Seq[String]) with
+  extension stringOps on (xs: Seq[String]) with
     def longestStrings: Seq[String] =
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
 
-  extension of [T](xs: List[T]) with
+  extension on [T](xs: List[T]) with
     def second = xs.tail.head
     def third = xs.tail.tail.head
 
@@ -133,7 +133,7 @@ object PostConditions with
 
   def result[T](given x: WrappedResult[T]): T = x
 
-  extension of [T](x: T) with
+  extension on [T](x: T) with
     def ensuring(condition: (given WrappedResult[T]) => Boolean): T =
       assert(condition(given x))
       x
@@ -153,12 +153,12 @@ object AnonymousInstances extends Common with
         val fst = x.compareTo(y)
         if (fst != 0) fst else xs1.compareTo(ys1)
 
-  extension of (xs: Seq[String]) with
+  extension on (xs: Seq[String]) with
     def longestStrings: Seq[String] =
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
 
-  extension of [T](xs: List[T]) with
+  extension on [T](xs: List[T]) with
     def second = xs.tail.head
 
   given [From, To]: (c: Convertible[From, To]) => Convertible[List[From], List[To]] with

tests/pos/reference/extension-methods.scala

@@ -41,19 +41,19 @@ object ExtMethods with
 
   List(1, 2, 3).second[Int]
 
-  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]) with
+  extension listOps on [T](xs: List[T]) with
     def second = xs.tail.head
     def third: T = xs.tail.tail.head
 
 
-  extension of [T](xs: List[T])(given Ordering[T]) with
+  extension on [T](xs: List[T])(given Ordering[T]) with
     def largest(n: Int) = xs.sorted.takeRight(n)
 
   given stringOps1: AnyRef {

tests/pos/reference/opaque.scala

@@ -12,7 +12,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  extension of (x: Logarithm) {
+  extension on (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) {
+    extension ops on (tree: Tree) {
       def show: String = ???
     }
   }

tests/run/extension-specificity.scala

@@ -1,10 +1,10 @@
 class A
 class B extends A
 
-extension a of (x: A) with
+extension a on (x: A) with
   def foo: Int = 1
 
-extension b of (x: B) with
+extension b on (x: B) with
   def foo: Int = 2
 
 @main def Test =

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) {
+  extension on (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]) {
+    extension listOps on [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]) {
+    extension polyListOps on [T, U](xs: List[T]) {
       def zipp(ys: List[U]): List[(T, U)] = xs.zip(ys)
     }
-    extension of (xs: List[Int]) {
+    extension on (xs: List[Int]) {
       def prod = (1 /: xs)(_ * _)
     }
   }

tests/run/i6902.scala

@@ -1,6 +1,6 @@
 object Test {
-  extension of [A](a: A) { def <<< : A = a }
-  extension of (b: Int) { def <<<< : Int = b }
+  extension on [A](a: A) { def <<< : A = a }
+  extension on (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) {
+  extension on (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]) {
+  extension on [T](xs: Seq[T]) {
     def second = xs.tail.head
   }
 
   assert(names.longestStrings.second == "world")
 
-  extension of [T](xs: List[List[T]]) {
+  extension on [T](xs: List[List[T]]) {
     def flattened = xs.foldLeft[List[T]](Nil)(_ ++ _)
   }
 

tests/run/instances.scala

@@ -8,27 +8,27 @@ object Test extends App {
 
   case class Circle(x: Double, y: Double, radius: Double)
 
-  extension circleOps of (c: Circle) with
+  extension circleOps on (c: Circle) with
     def circumference: Double = c.radius * math.Pi * 2
 
   val circle = new Circle(1, 1, 2.0)
 
   assert(circle.circumference == circleOps.circumference(circle))
 
-  extension stringOps of (xs: Seq[String]) with
+  extension stringOps on (xs: Seq[String]) with
     def longestStrings: Seq[String] =
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
 
   val names = List("hi", "hello", "world")
   assert(names.longestStrings == List("hello", "world"))
 
-  extension of [T](xs: Seq[T]) with
+  extension on [T](xs: Seq[T]) with
     def second = xs.tail.head
 
   assert(names.longestStrings.second == "world")
 
-  extension listListOps of [T](xs: List[List[T]]) with
+  extension listListOps on [T](xs: List[List[T]]) with
     def flattened = xs.foldLeft[List[T]](Nil)(_ ++ _)
 
   // A right associative op. Note: can't use given extension for this!