Update tests and docs to new extension syntax

Author: odersky

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -530,7 +530,7 @@ trait Inferencing { this: Typer =>
          *  is in i7558.scala:
          *
          *      type Tr[+V1, +O1 <: V1]
-         *      def [V2, O2 <: V2](tr: Tr[V2, O2]) sl: Tr[V2, O2] = ???
+         *      extension [V2, O2 <: V2](tr: Tr[V2, O2]) def sl: Tr[V2, O2] = ???
          *      def as[V3, O3 <: V3](tr: Tr[V3, O3]) : Tr[V3, O3] = tr.sl
          *
          *   Here we interpolate at some point V2 and O2 given the constraint

docs/docs/contributing/debugging.md

@@ -88,7 +88,7 @@ But you can also do:
 assertPositioned(tree.reporting(s"Tree is: $result"))
 ```
 
-`def (a: A).reporting(f: WrappedResult[T] ?=> String, p: Printer = Printers.default): A` is defined on all types. The function `f` can be written without the argument since it is a context function`. The `result` variable is a part of the `WrapperResult` – a tiny framework powering the `reporting` function. Basically, whenever you are using `reporting` on an object `A`, you can use the `result: A` variable from this function and it will be equal to the object you are calling `reporting` on.
+`extension (a: A) def reporting(f: WrappedResult[T] ?=> String, p: Printer = Printers.default): A` is defined on all types. The function `f` can be written without the argument since it is a context function`. The `result` variable is a part of the `WrapperResult` – a tiny framework powering the `reporting` function. Basically, whenever you are using `reporting` on an object `A`, you can use the `result: A` variable from this function and it will be equal to the object you are calling `reporting` on.
 
 ## Printing out trees after phases
 To print out the trees you are compiling after the FrontEnd (scanner, parser, namer, typer) phases:

docs/docs/reference/contextual/context-functions.md

@@ -16,7 +16,7 @@ the same way methods with context parameters are applied. For instance:
   given ec as ExecutionContext = ...
 
   def f(x: Int): ExecutionContext ?=> Int = ...
-  
+
   // could be written as follows with the type alias from above
   // def f(x: Int): Executable[Int] = ...
 
@@ -125,7 +125,7 @@ object PostConditions {
 
   def result[T](using r: WrappedResult[T]): T = r
 
-  def [T] (x: T).ensuring(condition: WrappedResult[T] ?=> Boolean): T = {
+  extension [T](x: T) def ensuring(condition: WrappedResult[T] ?=> Boolean): T = {
     assert(condition(using x))
     x
   }

docs/docs/reference/contextual/derivation-macro.md

@@ -120,7 +120,8 @@ Alternatively and what is shown below is that we can call the `eqv` method
 directly. The `eqGen` can trigger the derivation.
 
 ```scala
-inline def [T](x: =>T) === (y: =>T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
+extension [T](x: =>T)
+  inline def === (y: =>T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
 
 implicit inline def eqGen[T]: Eq[T] = ${ Eq.derived[T] }
 ```
@@ -216,7 +217,8 @@ object Eq {
 }
 
 object Macro3 {
-  inline def [T](x: =>T) === (y: =>T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
+  extension [T](x: =>T)
+    inline def === (y: =>T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
 
   implicit inline def eqGen[T]: Eq[T] = ${ Eq.derived[T] }
 }

docs/docs/reference/contextual/givens.md

@@ -9,8 +9,8 @@ that serve for synthesizing arguments to [context parameters](./using-clauses.ht
 ```scala
 trait Ord[T] {
   def compare(x: T, y: T): Int
-  def (x: T) < (y: T) = compare(x, y) < 0
-  def (x: T) > (y: T) = compare(x, y) > 0
+  extension (x: T) def < (y: T) = compare(x, y) < 0
+  extension (x: T) def > (y: T) = compare(x, y) > 0
 }
 
 given intOrd as Ord[Int] {

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

@@ -111,7 +111,7 @@ will map to with clauses instead.
 
 Extension methods have no direct counterpart in Scala 2, but they can be simulated with implicit classes. For instance, the extension method
 ```scala
-def (c: Circle).circumference: Double = c.radius * math.Pi * 2
+extension (c: Circle) def circumference: Double = c.radius * math.Pi * 2
 ```
 could be simulated to some degree by
 ```scala

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

@@ -156,7 +156,7 @@ A `List` can be turned into a monad via this `given` instance:
 given listMonad as Monad[List]:
   def pure[A](x: A): List[A] =
     List(x)
-  extension def [A, B](xs: List[A])
+  extension [A, B](xs: List[A])
     def flatMap(f: A => List[B]): List[B] =
       xs.flatMap(f) // rely on the existing `flatMap` method of `List`
 ```

docs/docs/reference/dropped-features/package-objects.md

@@ -22,7 +22,7 @@ def b = a._2
 case class C()
 
 implicit object Cops {
-  def (x: C).pair(y: C) = (x, y)
+  extension (x: C) def pair(y: C) = (x, y)
 }
 ```
 There may be several source files in a package containing such toplevel definitions, and source files can freely mix toplevel value, method, and type definitions with classes and objects.

docs/docs/reference/metaprogramming/macros.md

@@ -717,7 +717,7 @@ This might be used to then perform an implicit search as in:
 
 
 ```scala
-inline def (inline sc: StringContext).showMe(inline args: Any*): String = ${ showMeExpr('sc, 'args) }
+extension (inline sc: StringContext) inline def showMe(inline args: Any*): String = ${ showMeExpr('sc, 'args) }
 
 private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using QuoteContext): Expr[String] = {
   argsExpr match {

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

@@ -29,15 +29,15 @@ object Logarithms {
 }
 ```
 
-This introduces `Logarithm` as a new abstract type, which is implemented as `Double`. 
+This introduces `Logarithm` as a new abstract type, which is implemented as `Double`.
 The fact that `Logarithm` is the same as `Double` is only known in the scope where
 `Logarithm` is defined which in the above example corresponds to the object `Logarithms`.
-Or in other words, within the scope it is treated as type alias, but this is opaque to the outside world 
+Or in other words, within the scope it is treated as type alias, but this is opaque to the outside world
 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. 
+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. 
+and operations `+` and `*` on `Logarithm` values.
 The following operations would be valid because they use functionality implemented in the `Logarithms` object.
 
 ```scala
@@ -68,10 +68,10 @@ object Access {
   opaque type PermissionChoice = Int
   opaque type Permission <: Permissions & PermissionChoice = Int
 
-  def (x: Permissions) & (y: Permissions): Permissions = x | y
-  def (x: PermissionChoice) | (y: PermissionChoice): PermissionChoice = x | y
-  def (granted: Permissions).is(required: Permissions) = (granted & required) == required
-  def (granted: Permissions).isOneOf(required: PermissionChoice) = (granted & required) != 0
+  extension (x: Permissions) def & (y: Permissions): Permissions = x | y
+  extension (x: PermissionChoice) def | (y: PermissionChoice): PermissionChoice = x | y
+  extension (granted: Permissions) def is(required: Permissions) = (granted & required) == required
+  extension (granted: Permissions) def isOneOf(required: PermissionChoice) = (granted & required) != 0
 
   val NoPermission: Permission = 0
   val Read: Permission = 1