Change more tests to new extended with syntax

Author: odersky

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

@@ -3546,15 +3546,13 @@ object Parsers {
           (EmptyValDef, Nil)
       Template(constr, parents, derived, self, stats)
 
-    def templateBody(): (ValDef, List[Tree]) = {
+    def templateBody(): (ValDef, List[Tree]) =
       val r = inDefScopeBraces { templateStatSeq() }
-      if (in.token == WITH) {
+      if in.token == WITH then
         syntaxError(EarlyDefinitionsNotSupported())
         in.nextToken()
         template(emptyConstructor)
-      }
       r
-    }
 
 /* -------- STATSEQS ------------------------------------------- */
 

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

@@ -65,7 +65,7 @@ Anonymous given instances that define extension methods
 get their name from the name of the first extension method and the toplevel type
 constructor of its first parameter. For example, the given instance
 ```scala
-given extension [T] (xs: List[T]) {
+given [T] (xs: List[T]) extended with {
   def second = ...
 }
 ```

tests/neg/extension-methods.scala

@@ -10,7 +10,7 @@ object Test {
   "".l2 // error
   1.l1 // error
 
-  given extension [T](xs: List[T]) {
+  given [T](xs: List[T]) extended with {
     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/i6900.scala

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

tests/pos/i6900.scala

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

tests/pos/i7084.scala

@@ -2,7 +2,7 @@ object Test {
 
   type Foo
 
-  given extension (y: Any) {
+  given (y: Any) extended with {
     def g(given Foo): Any = ???
   }
 

tests/pos/i7087.scala

@@ -6,7 +6,7 @@ type F[T] = T match {
   case G[a] => String
 }
 
-given extension [T](tup: T) {
+given [T](tup: T) extended with {
   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)
 
-  given extension (xs: FlagSet) {
+  given (xs: FlagSet) extended with {
     def bits: Long = opaques.toBits(xs)
     def | (ys: FlagSet): FlagSet = FlagSet(xs.bits | ys.bits)
   }

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

tests/pos/reference/delegates.scala

@@ -133,7 +133,7 @@ object PostConditions with
 
   def result[T](given x: WrappedResult[T]): T = x
 
-  given extension [T](x: T)
+  given [T](x: T) extended 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)
 
-  given extension (xs: Seq[String])
+  given (xs: Seq[String]) extended with
     def longestStrings: Seq[String] =
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
 
-  given extension [T](xs: List[T])
+  given [T](xs: List[T]) extended with
     def second = xs.tail.head
 
   given [From, To](given c: Convertible[From, To]) : Convertible[List[From], List[To]] with

tests/pos/reference/opaque.scala

@@ -12,7 +12,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  given extension (x: Logarithm) {
+  given (x: Logarithm) extended with {
     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/run/extmethod-overload.scala

@@ -97,7 +97,7 @@ object Test extends App {
     def (x: Int) yy (y: Int) = x + y
   }
 
-  given extension (x: Int) {
+  given (x: Int) extended with {
     def yy (y: Int) = x - y
   }
 

tests/run/extmethods2.scala

@@ -24,7 +24,7 @@ object Test extends App {
     given polyListOps: [T, U](xs: List[T]) extended with {
       def zipp(ys: List[U]): List[(T, U)] = xs.zip(ys)
     }
-    given extension (xs: List[Int]) {
+    given (xs: List[Int]) extended with {
       def prod = (1 /: xs)(_ * _)
     }
   }

tests/run/i6902.scala

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

tests/run/instances.scala

@@ -23,7 +23,7 @@ object Test extends App {
   val names = List("hi", "hello", "world")
   assert(names.longestStrings == List("hello", "world"))
 
-  given extension [T](xs: Seq[T]) with
+  given [T](xs: Seq[T]) extended with
     def second = xs.tail.head
 
   assert(names.longestStrings.second == "world")