Update tests to use prefix parameter syntax for extension methods

Author: odersky

tests/neg/extension-methods.scala

@@ -1,7 +1,7 @@
 object Test {
 
   implicit object O {
-    def l1(this x: String) = x.length
+    def (x: String) l1 = x.length
     def l1(x: Int) = x * x
     def l2(x: String) = x.length
   }

tests/pos/opaque-propability-xm.scala

@@ -19,17 +19,17 @@ object prob {
     implicit val ordering: Ordering[Probability] =
       implicitly[Ordering[Double]]
 
-    def unary_~(this p1: Probability): Probability = Certain - p1
-    def &(this p1: Probability)(p2: Probability): Probability = p1 * p2
-    def |(this p1: Probability)(p2: Probability): Probability = p1 + p2 - (p1 * p2)
+    def (p1: Probability) unary_~ : Probability = Certain - p1
+    def (p1: Probability) & (p2: Probability): Probability = p1 * p2
+    def (p1: Probability) | (p2: Probability): Probability = p1 + p2 - (p1 * p2)
 
-    def isImpossible(this p1: Probability): Boolean = p1 == Never
-    def isCertain(this p1: Probability): Boolean = p1 == Certain
+    def (p1: Probability) isImpossible: Boolean = p1 == Never
+    def (p1: Probability) isCertain: Boolean = p1 == Certain
 
     import scala.util.Random
 
-    def sample(this p1: Probability)(r: Random = Random): Boolean = r.nextDouble <= p1
-    def toDouble(this p1: Probability): Double = p1
+    def (p1: Probability) sample (r: Random = Random): Boolean = r.nextDouble <= p1
+    def (p1: Probability) toDouble: Double = p1
   }
 
   val caughtTrain = Probability.unsafe(0.3)

tests/pos/opaque-xm1.scala

@@ -1,23 +1,23 @@
 object Test extends App {
 
   implicit object O {
-    def em(this x: Int): Boolean = x > 0
+    def (x: Int) em: Boolean = x > 0
   }
 
   assert(1.em == O.em(1))
 
   case class Circle(x: Double, y: Double, radius: Double)
 
   implicit object CircleOps {
-    def circumference(this c: Circle): Double = c.radius * math.Pi * 2
+    def (c: Circle) circumference: Double = c.radius * math.Pi * 2
   }
 
   val circle = new Circle(1, 1, 2.0)
 
   assert(circle.circumference == CircleOps.circumference(circle))
 
   implicit object StringOps {
-    def longestStrings(this xs: Seq[String]): Seq[String] = {
+    def (xs: Seq[String]) longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
     }
@@ -26,28 +26,28 @@ object Test extends App {
   assert(names.longestStrings == List("hello", "world"))
 
   implicit object SeqOps {
-    def second[T](this xs: Seq[T]) = xs.tail.head
+    def (xs: Seq[T]) second[T] = xs.tail.head
   }
 
   assert(names.longestStrings.second == "world")
 
   implicit object ListListOps {
-    def flattened[T](this xs: List[List[T]]) = xs.foldLeft[List[T]](Nil)(_ ++ _)
+    def (xs: List[List[T]]) flattened[T] = xs.foldLeft[List[T]](Nil)(_ ++ _)
   }
 
   assert(List(names, List("!")).flattened == names :+ "!")
   assert(Nil.flattened == Nil)
 
   trait SemiGroup[T] {
-    def combine(this x: T)(y: T): T
+    def (x: T) combine (y: T): T
   }
   trait Monoid[T] extends SemiGroup[T] {
     def unit: T
   }
 
   // An instance declaration:
   implicit object StringMonoid extends Monoid[String] {
-    def combine(this x: String)(y: String): String = x.concat(y)
+    def (x: String) combine (y: String): String = x.concat(y)
     def unit: String = ""
   }
 
@@ -58,20 +58,20 @@ object Test extends App {
   println(sum(names))
 
   trait Ord[T] {
-    def compareTo(this x: T)(y: T): Int
-    def < (this x: T)(y: T) = x.compareTo(y) < 0
-    def > (this x: T)(y: T) = x.compareTo(y) > 0
+    def (x: T) compareTo (y: T): Int
+    def (x: T) < (y: T) = x.compareTo(y) < 0
+    def (x: T) > (y: T) = x.compareTo(y) > 0
     val minimum: T
   }
 
   implicit object IntOrd extends Ord[Int] {
-    def compareTo(this x: Int)(y: Int) =
+    def (x: Int) compareTo (y: Int) =
       if (x < y) -1 else if (x > y) +1 else 0
     val minimum = Int.MinValue
   }
 
   class ListOrd[T: Ord] extends Ord[List[T]] {
-    def compareTo(this xs: List[T])(ys: List[T]): Int = (xs, ys) match {
+    def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
       case (Nil, Nil) => 0
       case (Nil, _) => -1
       case (_, Nil) => +1
@@ -93,25 +93,25 @@ object Test extends App {
   println(max(List(1, 2, 3), List(2)))
 
   trait Functor[F[_]] {
-    def map[A, B](this x: F[A])(f: A => B): F[B]
+    def (x: F[A]) map [A, B](f: A => B): F[B]
   }
 
   trait Monad[F[_]] extends Functor[F] {
-    def flatMap[A, B](this x: F[A])(f: A => F[B]): F[B]
-    def map[A, B](this x: F[A])(f: A => B) = x.flatMap(f `andThen` pure)
+    def (x: F[A]) flatMap [A, B](f: A => F[B]): F[B]
+    def (x: F[A]) map [A, B](f: A => B) = x.flatMap(f `andThen` pure)
 
     def pure[A](x: A): F[A]
   }
 
   implicit object ListMonad extends Monad[List] {
-    def flatMap[A, B](this xs: List[A])(f: A => List[B]): List[B] =
+    def (xs: List[A]) flatMap [A, B](f: A => List[B]): List[B] =
       xs.flatMap(f)
     def pure[A](x: A): List[A] =
       List(x)
   }
 
   class ReaderMonad[Ctx] extends Monad[[X] => Ctx => X] {
-    def flatMap[A, B](this r: Ctx => A)(f: A => Ctx => B): Ctx => B =
+    def (r: Ctx => A) flatMap [A, B](f: A => Ctx => B): Ctx => B =
       ctx => f(r(ctx))(ctx)
     def pure[A](x: A): Ctx => A =
       ctx => x

tests/run/extension-methods.scala

@@ -11,8 +11,8 @@ object Test extends App {
 
     // These should be inline but that does not work currently. Try again
     // once inliner is moved to ReifyQuotes
-    def length[A](this ia: IArray[A]): Int = (ia: Array[A]).length
-    def apply[A](this ia: IArray[A])(i: Int): A = (ia: Array[A])(i)
+    def (ia: IArray[A]) length[A]: Int = (ia: Array[A]).length
+    def (ia: IArray[A]) apply[A] (i: Int): A = (ia: Array[A])(i)
 
     // return a sorted copy of the array
     def sorted[A <: AnyRef : math.Ordering](ia: IArray[A]): IArray[A] = {