deprecate Pair and Triple

40 files changed, 212 insertions, 208 deletions

diff --git a/test/files/jvm/typerep.scala b/test/files/jvm/typerep.scala
index 1d6f0b7907..4f900d98d7 100644
--- a/test/files/jvm/typerep.scala
+++ b/test/files/jvm/typerep.scala
@@ -86,7 +86,7 @@ object testArrays {
 
 object testTuples {
   println(getType((3, "abc")))
-  println(getType(Triple('a', 'b', "c")))
+  println(getType(('a', 'b', "c")))
   println(getType(((3, "abc"), (4, "xyz"))))
   println(getType(((Some('b'), 3), (Some('a'), 4))))
   //println(getType(((Some('b'), 3), (None, 4))))
diff --git a/test/files/neg/patmatexhaust.scala b/test/files/neg/patmatexhaust.scala
index aa7dac7d7d..f937197829 100644
--- a/test/files/neg/patmatexhaust.scala
+++ b/test/files/neg/patmatexhaust.scala
@@ -22,9 +22,9 @@ class TestSealedExhaustive { // compile only
 
     def ma3(x:Mult) = (x,x) match { // not exhaustive
       case (Kult(_), Qult())    => // Kult missing
-      //case Pair(Kult(_), Kult(_))    =>
+      //case (Kult(_), Kult(_))    =>
       case (Qult(), Kult(_))    => // Qult missing
-      //case Pair(Qult(), Qult())    =>
+      //case (Qult(), Qult())    =>
     }
 
     def ma3u(x:Mult) = ((x,x) : @unchecked) match { // not exhaustive, but not checked!
diff --git a/test/files/neg/t414.scala b/test/files/neg/t414.scala
index 1662b9a105..86646d13c2 100644
--- a/test/files/neg/t414.scala
+++ b/test/files/neg/t414.scala
@@ -1,5 +1,5 @@
 case class Empty[a]() extends IntMap[a];
-case class Node[a](left: IntMap[a], keyVal: Pair[Int, a], right: IntMap[a]) extends IntMap[a];
+case class Node[a](left: IntMap[a], keyVal: Tuple2[Int, a], right: IntMap[a]) extends IntMap[a];
 abstract class IntMap[a] {
         def lookup(key: Int): a = this match {
                 case Empty =>
diff --git a/test/files/neg/t5702-neg-bad-and-wild.check b/test/files/neg/t5702-neg-bad-and-wild.check
index ff9e5e5703..a52136dbf8 100644
--- a/test/files/neg/t5702-neg-bad-and-wild.check
+++ b/test/files/neg/t5702-neg-bad-and-wild.check
@@ -23,6 +23,6 @@ t5702-neg-bad-and-wild.scala:23: error: bad simple pattern: bad use of _* (a seq
     val K(ns @ _*, x) = k // bad use of _* (a sequence pattern must be the last pattern)
                  ^
 t5702-neg-bad-and-wild.scala:24: error: bad simple pattern: bad use of _* (sequence pattern not allowed)
-    val (b, _ * ) = Pair(5,6) // bad use of _* (sequence pattern not allowed)
+    val (b, _ * ) = (5,6) // bad use of _* (sequence pattern not allowed)
                 ^
 9 errors found
diff --git a/test/files/neg/t5702-neg-bad-and-wild.scala b/test/files/neg/t5702-neg-bad-and-wild.scala
index 3833a002b1..aadda37da7 100644
--- a/test/files/neg/t5702-neg-bad-and-wild.scala
+++ b/test/files/neg/t5702-neg-bad-and-wild.scala
@@ -21,7 +21,7 @@ object Test {
 //gowild.scala:14: error: star patterns must correspond with varargs parameters
     val K(is @ _*) = k
     val K(ns @ _*, x) = k // bad use of _* (a sequence pattern must be the last pattern)
-    val (b, _ * ) = Pair(5,6) // bad use of _* (sequence pattern not allowed)
+    val (b, _ * ) = (5,6) // bad use of _* (sequence pattern not allowed)
 // no longer complains
 //bad-and-wild.scala:15: error: ')' expected but '}' found.
   }
diff --git a/test/files/neg/t997.scala b/test/files/neg/t997.scala
index e8d10f4317..1198738f24 100644
--- a/test/files/neg/t997.scala
+++ b/test/files/neg/t997.scala
@@ -1,5 +1,5 @@
 // An extractor with 2 results
-object Foo { def unapply(x : String)  = Some(Pair(x, x)) }
+object Foo { def unapply(x : String)  = Some((x, x)) }
 
 object Test extends App {
 
diff --git a/test/files/neg/wellkinded_wrongarity.check b/test/files/neg/wellkinded_wrongarity.check
index 1dc38db5c1..b9f033b453 100644
--- a/test/files/neg/wellkinded_wrongarity.check
+++ b/test/files/neg/wellkinded_wrongarity.check
@@ -1,4 +1,4 @@
-wellkinded_wrongarity.scala:5: error: Pair takes two type parameters, expected: one
-object mp extends Monad[Pair]
+wellkinded_wrongarity.scala:5: error: Tuple2 takes two type parameters, expected: one
+object mp extends Monad[Tuple2]
                         ^
 one error found
diff --git a/test/files/neg/wellkinded_wrongarity.scala b/test/files/neg/wellkinded_wrongarity.scala
index 2bb0e2ce8a..39c7601d53 100644
--- a/test/files/neg/wellkinded_wrongarity.scala
+++ b/test/files/neg/wellkinded_wrongarity.scala
@@ -2,4 +2,4 @@
 
 class Monad[m[x]]
 
-object mp extends Monad[Pair]
+object mp extends Monad[Tuple2]
diff --git a/test/files/pos/bounds.scala b/test/files/pos/bounds.scala
index cfea4626c3..26bc84a1b9 100644
--- a/test/files/pos/bounds.scala
+++ b/test/files/pos/bounds.scala
@@ -1,11 +1,11 @@
 trait Map[A, +C] {
-  def ++ [B1 >: C] (kvs: Iterable[Pair[A, B1]]): Map[A, B1] = this
-  def ++ [B1 >: C] (kvs: Iterator[Pair[A, B1]]): Map[A, B1] = this
+  def ++ [B1 >: C] (kvs: Iterable[Tuple2[A, B1]]): Map[A, B1] = this
+  def ++ [B1 >: C] (kvs: Iterator[Tuple2[A, B1]]): Map[A, B1] = this
 }
 
 class ListMap[A, +B] extends Map[A, B] {}
 
 object ListMap {
   def empty[X, Y] = new ListMap[X, Y]
-  def apply[A1, B2](elems: Pair[A1, B2]*): Map[A1, B2] = empty[A1,B2].++(elems.iterator)
+  def apply[A1, B2](elems: Tuple2[A1, B2]*): Map[A1, B2] = empty[A1,B2].++(elems.iterator)
 }
diff --git a/test/files/pos/patmat.scala b/test/files/pos/patmat.scala
index 4e652b146e..51b879abf2 100644
--- a/test/files/pos/patmat.scala
+++ b/test/files/pos/patmat.scala
@@ -3,8 +3,8 @@
 
 object ZipFun {
   //just compilation
-  def zipFun[a, b](xs: List[a], ys: List[b]): List[Pair[a, b]] = (Pair(xs, ys): @unchecked) match {
-    // !!! case Pair(List(), _), Pair(_, List()) => List()
+  def zipFun[a, b](xs: List[a], ys: List[b]): List[Tuple2[a, b]] = ((xs, ys): @unchecked) match {
+    // !!! case (List(), _), (_, List()) => List()
     case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1)
   }
 }
diff --git a/test/files/pos/spec-doubledef-new.scala b/test/files/pos/spec-doubledef-new.scala
index ad9c6399a5..589ceb33b2 100644
--- a/test/files/pos/spec-doubledef-new.scala
+++ b/test/files/pos/spec-doubledef-new.scala
@@ -19,12 +19,12 @@ abstract class B[T, @specialized(scala.Int) U : TypeTag, @specialized(scala.Int)
     val u: U
     val v: V
 
-    def f(t: T, v2: V): Pair[U, V] = {
+    def f(t: T, v2: V): Tuple2[U, V] = {
         val m: Array[U] = null
         if (m.isEmpty) {
-            Pair(u, v)
+            (u, v)
         } else {
-            Pair(u, v2)
+            (u, v2)
         }
     }
 }
\ No newline at end of file
diff --git a/test/files/pos/spec-doubledef-old.scala b/test/files/pos/spec-doubledef-old.scala
index 86b0d857d3..bde259e4fa 100644
--- a/test/files/pos/spec-doubledef-old.scala
+++ b/test/files/pos/spec-doubledef-old.scala
@@ -17,12 +17,12 @@ abstract class B[T, @specialized(scala.Int) U : Manifest, @specialized(scala.Int
     val u: U
     val v: V
 
-    def f(t: T, v2: V): Pair[U, V] = {
+    def f(t: T, v2: V): Tuple2[U, V] = {
         val m: Array[U] = null
         if (m.isEmpty) {
-            Pair(u, v)
+            (u, v)
         } else {
-            Pair(u, v2)
+            (u, v2)
         }
     }
 }
diff --git a/test/files/pos/t0064.scala b/test/files/pos/t0064.scala
index c2ce4bf6d0..1eeca8dcad 100644
--- a/test/files/pos/t0064.scala
+++ b/test/files/pos/t0064.scala
@@ -1,6 +1,6 @@
 object B {
   def main(Args:Array[String]) = {
-    val Pair(_,x) = Pair(1,2);
+    val (_,x) = (1,2);
     x + 1;
   }
 }
diff --git a/test/files/pos/t247.scala b/test/files/pos/t247.scala
index e976404e61..fdcafeb2c6 100644
--- a/test/files/pos/t247.scala
+++ b/test/files/pos/t247.scala
@@ -16,11 +16,11 @@ class Tree[KEY,Entry](order:Order[KEY]) {
   def size =0;
 }
 
-class TreeMap[KEY,VALUE](_factory:TreeMapFactory[KEY]) extends Tree[KEY,Pair[KEY,VALUE]](_factory.order) with scala.collection.DefaultMap[KEY, VALUE] with Map[KEY, VALUE] {
+class TreeMap[KEY,VALUE](_factory:TreeMapFactory[KEY]) extends Tree[KEY,Tuple2[KEY,VALUE]](_factory.order) with scala.collection.DefaultMap[KEY, VALUE] with Map[KEY, VALUE] {
   val factory = _factory
   val order = _factory.order;
   def this(newOrder:Order[KEY]) = this(new TreeMapFactory[KEY](newOrder));
   def get(key:KEY) = null;
-  def iterator:Iterator[Pair[KEY,VALUE]] = null;
+  def iterator:Iterator[Tuple2[KEY,VALUE]] = null;
   override def size = super[Tree].size
 }
diff --git a/test/files/pos/t443.scala b/test/files/pos/t443.scala
index 5b5e3ea828..cdaefe9ecd 100644
--- a/test/files/pos/t443.scala
+++ b/test/files/pos/t443.scala
@@ -1,10 +1,10 @@
 object Test {
 
-  def lookup(): Option[Pair[String, String]] =
-    ((null: Option[Pair[String, String]]) : @unchecked) match {
-      case Some(Pair(_, _)) =>
+  def lookup(): Option[Tuple2[String, String]] =
+    ((null: Option[Tuple2[String, String]]) : @unchecked) match {
+      case Some((_, _)) =>
 	if (true)
-	  Some(Pair(null, null))
+	  Some((null, null))
 	else
 	  lookup() match {
 	    case Some(_) => Some(null)
diff --git a/test/files/pos/t4579.scala b/test/files/pos/t4579.scala
index 8951ec011f..cd1553f02a 100644
--- a/test/files/pos/t4579.scala
+++ b/test/files/pos/t4579.scala
@@ -190,10 +190,10 @@ object LispCaseClasses extends Lisp {
 
     def extendEnv(env: Environment,
                   ps: List[String], args: List[Data]): Environment =
-      Pair(ps, args) match {
-        case Pair(List(), List()) =>
+      (ps, args) match {
+        case (List(), List()) =>
           env
-        case Pair(p :: ps1, arg :: args1) =>
+        case (p :: ps1, arg :: args1) =>
           extendEnv(env.extend(p, arg), ps1, args1)
         case _ =>
           lispError("wrong number of arguments")
@@ -381,10 +381,10 @@ object LispAny extends Lisp {
 
     def extendEnv(env: Environment,
                   ps: List[String], args: List[Data]): Environment =
-      Pair(ps, args) match {
-        case Pair(List(), List()) =>
+      (ps, args) match {
+        case (List(), List()) =>
           env
-        case Pair(p :: ps1, arg :: args1) =>
+        case (p :: ps1, arg :: args1) =>
           extendEnv(env.extend(p, arg), ps1, args1)
         case _ =>
           lispError("wrong number of arguments")
diff --git a/test/files/pos/t5120.scala b/test/files/pos/t5120.scala
index 6731af14e4..86d4470bd5 100644
--- a/test/files/pos/t5120.scala
+++ b/test/files/pos/t5120.scala
@@ -5,9 +5,9 @@ class Test {
   class ScopedKey[T]
   class Value[T]
 
-  class Compiled[T](val settings: Seq[Pair[T]])
+  class Compiled[T](val settings: Seq[Tuple2[T]])
 
-  case class Pair[T](k: ScopedKey[T], v: ScopedKey[T])
+  case class Tuple2[T](k: ScopedKey[T], v: ScopedKey[T])
 
   def transform[T](x: T) = x
 
diff --git a/test/files/pos/tcpoly_bounds1.scala b/test/files/pos/tcpoly_bounds1.scala
index 5874cc664d..63263cb152 100644
--- a/test/files/pos/tcpoly_bounds1.scala
+++ b/test/files/pos/tcpoly_bounds1.scala
@@ -1,7 +1,7 @@
-class Foo[t[x]<: Pair[Int, x]]
+class Foo[t[x]<: Tuple2[Int, x]]
 
 //
-class MyPair[z](a: Int, b: z) extends Pair[Int, z](a,b)
+class MyPair[z](a: Int, b: z) extends Tuple2[Int, z](a,b)
 
 object foo extends Foo[MyPair]
 
diff --git a/test/files/pos/typealiases.scala b/test/files/pos/typealiases.scala
index d03b521f77..93d1dce4dc 100644
--- a/test/files/pos/typealiases.scala
+++ b/test/files/pos/typealiases.scala
@@ -14,7 +14,7 @@ trait Test[T] {
 object main extends Test[Int] {
   val pair1 = (1,1)
 
-  implicit def topair(x: Int): Pair[Int, Int] = (x,x)
+  implicit def topair(x: Int): Tuple2[Int, Int] = (x,x)
   val pair2: MyPair[Int] = 1
   val x: Short = 1
 }
diff --git a/test/files/pos/unapplyNeedsMemberType.scala b/test/files/pos/unapplyNeedsMemberType.scala
index b423257e04..3a96e189af 100644
--- a/test/files/pos/unapplyNeedsMemberType.scala
+++ b/test/files/pos/unapplyNeedsMemberType.scala
@@ -19,7 +19,7 @@ class Join[a] extends Gunk[a] {
   def append(s1: Seq, s2: Seq): Seq = s1 // mock implementation
 
   def unapply_Cons(s: Any) = s match {
-    case App(Cons(x, xs), ys) => Some(Pair(x, append(xs, ys)))
+    case App(Cons(x, xs), ys) => Some((x, append(xs, ys)))
     case _ => null
   }
 }
diff --git a/test/files/pos/valdefs.scala b/test/files/pos/valdefs.scala
index 85ffa132b7..c8f78cd2bf 100644
--- a/test/files/pos/valdefs.scala
+++ b/test/files/pos/valdefs.scala
@@ -11,6 +11,6 @@ object test {
     }
 
     abstract class Sub2() extends Base() {
-      override val Pair(x, y) = Pair("abc", 2.0);
+      override val (x, y) = ("abc", 2.0);
     }
 }
diff --git a/test/files/positions/ExcludedPrefix1.scala b/test/files/positions/ExcludedPrefix1.scala
index f3562c37f0..b3182eae78 100644
--- a/test/files/positions/ExcludedPrefix1.scala
+++ b/test/files/positions/ExcludedPrefix1.scala
@@ -35,7 +35,7 @@ object ExcludedPrefix1 {
   (i,
    j) = (0, 0)
 
-  val Pair(
+  val (
    k,
    l) = (0, 0)
 }
diff --git a/test/files/positions/Overlap4.scala b/test/files/positions/Overlap4.scala
index 0049293954..f54837295b 100644
--- a/test/files/positions/Overlap4.scala
+++ b/test/files/positions/Overlap4.scala
@@ -1,3 +1,3 @@
 object Overlap4 {
-  val Pair(a, b) = (0, 0)
+  val (a, b) = (0, 0)
 }
diff --git a/test/files/positions/Scaladoc7.scala b/test/files/positions/Scaladoc7.scala
index 6175222e3f..0198d4d6ac 100644
--- a/test/files/positions/Scaladoc7.scala
+++ b/test/files/positions/Scaladoc7.scala
@@ -2,5 +2,5 @@ object Scaladoc7 {
   /**
    * Foo
    */
-  val Pair(i, j) = (1, 2)
+  val (i, j) = (1, 2)
 }
diff --git a/test/files/presentation/callcc-interpreter.check b/test/files/presentation/callcc-interpreter.check
index f031c52c86..1f868097ca 100644
--- a/test/files/presentation/callcc-interpreter.check
+++ b/test/files/presentation/callcc-interpreter.check
@@ -1,8 +1,8 @@
 reload: CallccInterpreter.scala
 
-askTypeCompletion at CallccInterpreter.scala(51,38)
+askTypeCompletion at CallccInterpreter.scala(51,34)
 ================================================================================
-[response] askTypeCompletion at (51,38)
+[response] askTypeCompletion at (51,34)
 retrieved 59 members
 abstract trait Term extends AnyRef
 abstract trait Value extends AnyRef
@@ -83,8 +83,8 @@ def showM(m: callccInterpreter.M[callccInterpreter.Value]): String = m.in.apply(
 askType at CallccInterpreter.scala(50,30)
 ================================================================================
 [response] askTypeAt (50,30)
-def add(a: callccInterpreter.Value, b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] = scala.this.Predef.Pair.apply[callccInterpreter.Value, callccInterpreter.Value](a, b) match {
-  case scala.this.Predef.Pair.unapply[callccInterpreter.Value, callccInterpreter.Value](<unapply-selector>) <unapply> ((n: Int)callccInterpreter.Num((m @ _)), (n: Int)callccInterpreter.Num((n @ _))) => this.unitM[callccInterpreter.Num](callccInterpreter.this.Num.apply(m.+(n)))
+def add(a: callccInterpreter.Value, b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] = scala.Tuple2.apply[callccInterpreter.Value, callccInterpreter.Value](a, b) match {
+  case (_1: callccInterpreter.Value, _2: callccInterpreter.Value)(callccInterpreter.Value, callccInterpreter.Value)((n: Int)callccInterpreter.Num((m @ _)), (n: Int)callccInterpreter.Num((n @ _))) => this.unitM[callccInterpreter.Num](callccInterpreter.this.Num.apply(m.+(n)))
   case _ => callccInterpreter.this.unitM[callccInterpreter.Wrong.type](callccInterpreter.this.Wrong)
 }
 ================================================================================
diff --git a/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala b/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala
index ce3b996b96..d498fe0b17 100644
--- a/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala
+++ b/test/files/presentation/callcc-interpreter/src/CallccInterpreter.scala
@@ -40,15 +40,15 @@ object callccInterpreter {
     override def toString() = "<function>"
   }
 
-  type Environment = List[Pair[Name, Value]]
+  type Environment = List[Tuple2[Name, Value]]
 
   def lookup(x: Name, e: Environment): M[Value] = e match {
     case List() => unitM(Wrong)
-    case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
+    case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
   }
 
-  def add(a: Value, b: Value) /*?*/ = Pair(a, b) match {
-    case Pair(Num(m), Num(n)) => this./*!*/unitM(Num(m + n))
+  def add(a: Value, b: Value) /*?*/ = (a, b) match {
+    case (Num(m), Num(n)) => this./*!*/unitM(Num(m + n))
     case _ => unitM(Wrong)
   }
 
@@ -60,16 +60,20 @@ object callccInterpreter {
   def interp(t: Term, e: Environment): M[Value] = t match {
     case Var(x) => lookup(x, e)
     case Con(n) => unitM(Num(n))
-    case Add(l, r) => for (val a <- interp(l, e);
-			   val b <- interp(r, e);
-			   val c <- add(a, b))
-                      yield c
-    case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e)))
-    case App(f, t) => for (val a <- interp(f, e);
-			   val b <- interp(t, e);
-			   val c <- apply(a, b))
-		      yield c
-    case Ccc(x, t) => callCC(k => interp(t, Pair(x, Fun(k)) :: e))
+    case Add(l, r) =>
+      for {
+        a <- interp(l, e)
+        b <- interp(r, e)
+        c <- add(a, b)
+      } yield c
+    case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e)))
+    case App(f, t) =>
+      for {
+        a <- interp(f, e)
+        b <- interp(t, e)
+        c <- apply(a, b)
+      } yield c
+    case Ccc(x, t) => callCC(k => interp(t, (x, Fun(k)) :: e))
   }
 
   def test(t: Term): String = showM(interp(t, List()))
diff --git a/test/files/run/Course-2002-05.scala b/test/files/run/Course-2002-05.scala
index e6764b92c8..80317bc757 100644
--- a/test/files/run/Course-2002-05.scala
+++ b/test/files/run/Course-2002-05.scala
@@ -3,15 +3,15 @@
 //############################################################################
 
 object M0 {
-  def partition[a](xs: List[a], pred: a => Boolean): Pair[List[a], List[a]] = {
+  def partition[a](xs: List[a], pred: a => Boolean): Tuple2[List[a], List[a]] = {
     if (xs.isEmpty)
-      Pair(List(),List())
+      (List(),List())
     else {
       val tailPartition = partition(xs.tail, pred);
       if (pred(xs.head))
-        Pair(xs.head :: tailPartition._1, tailPartition._2)
+        (xs.head :: tailPartition._1, tailPartition._2)
       else
-        Pair(tailPartition._1, xs.head :: tailPartition._2)
+        (tailPartition._1, xs.head :: tailPartition._2)
     }
   }
 
@@ -49,9 +49,9 @@ object M0 {
 //############################################################################
 
 object M1 {
-  def partition[a](xs: List[a], pred: a => Boolean): Pair[List[a], List[a]] = {
-    xs.foldRight[Pair[List[a], List[a]]](Pair(List(), List())) {
-      (x, p) => if (pred (x)) Pair(x :: p._1, p._2) else Pair(p._1, x :: p._2)
+  def partition[a](xs: List[a], pred: a => Boolean): Tuple2[List[a], List[a]] = {
+    xs.foldRight[Tuple2[List[a], List[a]]]((List(), List())) {
+      (x, p) => if (pred (x)) (x :: p._1, p._2) else (p._1, x :: p._2)
     }
   }
 
@@ -136,7 +136,7 @@ object M3 {
         def adjoinRow(placement: Placement): List[Placement] =
           range(1, n)
             .filter (column => isSafe(column, placement))
-            .map (column => Pair(row, column) :: placement);
+            .map (column => (row, column) :: placement);
 
         placeQueens(row - 1) flatMap adjoinRow
       }
diff --git a/test/files/run/Course-2002-06.scala b/test/files/run/Course-2002-06.scala
index e4fb86a966..908a934041 100644
--- a/test/files/run/Course-2002-06.scala
+++ b/test/files/run/Course-2002-06.scala
@@ -55,7 +55,7 @@ abstract class Graphics(_width: Double, _height: Double) {
   }
 
   /** Draw a list of segments on the picture.*/
-  def drawSegments(frm: Frame)(segments: List[Pair[Vector, Vector]]): Unit =
+  def drawSegments(frm: Frame)(segments: List[Tuple2[Vector, Vector]]): Unit =
     if (segments.isEmpty) ()
     else {
       drawSegment(frm)(segments.head._1, segments.head._2);
diff --git a/test/files/run/Course-2002-07.scala b/test/files/run/Course-2002-07.scala
index 055ff74d81..2d9457653f 100644
--- a/test/files/run/Course-2002-07.scala
+++ b/test/files/run/Course-2002-07.scala
@@ -181,10 +181,10 @@ object M4 {
 
 object M5 {
 
-  def zipFun[a,b](xs:List[a], ys:List[b]):List[Pair[a,b]] = Pair(xs,ys) match {
-    case Pair(List(), _) => List()
-    case Pair(_, List()) => List()
-    case Pair(x :: xs1, y :: ys1) => Pair(x, y) :: zipFun(xs1, ys1)
+  def zipFun[a,b](xs:List[a], ys:List[b]):List[Tuple2[a,b]] = (xs,ys) match {
+    case (List(), _) => List()
+    case (_, List()) => List()
+    case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1)
   }
 
   def test_zipFun[a,b](xs: List[a], ys: List[b]) = {
@@ -216,9 +216,9 @@ object M5 {
 
 object M6 {
 
-  def zipFun[a,b](xs:List[a], ys:List[b]):List[Pair[a,b]] = (Pair(xs,ys): @unchecked) match {
-    // !!! case Pair(List(), _), Pair(_, List()) => List()
-    case Pair(x :: xs1, y :: ys1) => Pair(x, y) :: zipFun(xs1, ys1)
+  def zipFun[a,b](xs:List[a], ys:List[b]):List[Tuple2[a,b]] = ((xs,ys): @unchecked) match {
+    // !!! case (List(), _), (_, List()) => List()
+    case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1)
   }
 
   def test_zipFun[a,b](xs: List[a], ys: List[b]) = {
@@ -374,9 +374,9 @@ object M9 {
 
 object MA {
 
-  def lookup[k,v](xs: List[Pair[k,v]], k: k): v = xs match {
+  def lookup[k,v](xs: List[Tuple2[k,v]], k: k): v = xs match {
     case List() => sys.error("no value for " + k)
-    case Pair(k1,v1) :: xs1 => if (k1 == k) v1 else lookup(xs1, k)
+    case (k1,v1) :: xs1 => if (k1 == k) v1 else lookup(xs1, k)
   }
 
   trait Expr {
@@ -437,8 +437,8 @@ object MA {
     val g1 = g0 derive x;
     Console.println("g (x) = " + g0);
     Console.println("g'(x) = " + g1);
-    Console.println("g (3) = " + evalvars(List(Pair("x",3)))(g0));
-    Console.println("g'(3) = " + evalvars(List(Pair("x",3)))(g1));
+    Console.println("g (3) = " + evalvars(List(("x",3)))(g0));
+    Console.println("g'(3) = " + evalvars(List(("x",3)))(g1));
 
     Console.println;
   }
@@ -453,26 +453,26 @@ object Utils {
     if (y == 1) x else if (y % 2 == 0) power0(x*x,y/2) else x*power0(x, y-1);
 
   def power(x: Int, y: Int): Int = (x,y) match {
-    case Pair(0,0) => sys.error("power(0,0)")
-    case Pair(0,_) => 0
-    case Pair(1,_) => 1
-    case Pair(_,0) => 1
-    case Pair(_,1) => x
-    case Pair(_,2) => x*x
-    case Pair(_,_) => if (y < 0) 1/power0(x,y) else power0(x,y)
+    case (0,0) => sys.error("power(0,0)")
+    case (0,_) => 0
+    case (1,_) => 1
+    case (_,0) => 1
+    case (_,1) => x
+    case (_,2) => x*x
+    case (_,_) => if (y < 0) 1/power0(x,y) else power0(x,y)
   }
 
   def lookup(entries: List[(String,Int)], key: String): Int = entries match {
     case List()                       => sys.error("no value for " + key)
-    case Pair(k,v) :: _ if (k == key) => v
+    case (k,v) :: _ if (k == key) => v
     case _ :: rest                    => lookup(rest, key)
   }
 
   def compare(xs: List[String], ys: List[String]): Int = (xs, ys) match {
-    case Pair(List(), List()) =>  0
-    case Pair(List(), _     ) => -1
-    case Pair(_     , List()) => +1
-    case Pair(x::xs , y::ys ) => {
+    case (List(), List()) =>  0
+    case (List(), _     ) => -1
+    case (_     , List()) => +1
+    case (x::xs , y::ys ) => {
       val diff = x.compareTo(y);
       if (diff != 0) diff else compare(xs,ys)
     }
@@ -508,18 +508,18 @@ object MB {
 
     private def +<  (that: Expr): Boolean = (this +<? that) <  0;
     private def +<= (that: Expr): Boolean = (this +<? that) <= 0;
-    private def +<? (that: Expr): Int = Pair(this,that) match {
-      case Pair(Add(_,_), _       ) =>  0
-      case Pair(_       , Add(_,_)) =>  0
-      case Pair(_       , _       ) => compare(this.vars,that.vars)
+    private def +<? (that: Expr): Int = (this,that) match {
+      case (Add(_,_), _       ) =>  0
+      case (_       , Add(_,_)) =>  0
+      case (_       , _       ) => compare(this.vars,that.vars)
     }
 
-    def + (that: Expr): Expr = if (that +<= this) Pair(this,that) match {
-      case Pair(_         , Lit(0)    )                  => this
-      case Pair(Lit(l)    , Lit(r)    )                  => Lit(l + r)
-      case Pair(_         , Add(rl,rr))                  => (this + rl) + rr
-      case Pair(Add(ll,lr), _         ) if (lr +<= that) => ll + (that + lr)
-      case Pair(_         , _         )                  => {
+    def + (that: Expr): Expr = if (that +<= this) (this,that) match {
+      case (_         , Lit(0)    )                  => this
+      case (Lit(l)    , Lit(r)    )                  => Lit(l + r)
+      case (_         , Add(rl,rr))                  => (this + rl) + rr
+      case (Add(ll,lr), _         ) if (lr +<= that) => ll + (that + lr)
+      case (_         , _         )                  => {
         val l = this.term;
         val r = that.term;
         if (l equ r) Lit(this.count + that.count) * r else Add(this, that)
@@ -528,41 +528,41 @@ object MB {
 
     private def *<  (that: Expr): Boolean = (this *<? that) <  0;
     private def *<= (that: Expr): Boolean = (this *<? that) <= 0;
-    private def *<? (that: Expr): Int = Pair(this,that) match {
-      case Pair(Mul(_,_), _       ) =>  0
-      case Pair(_       , Mul(_,_)) =>  0
-      case Pair(Add(_,_), Add(_,_)) =>  0
-      case Pair(Add(_,_), _       ) => -1
-      case Pair(_       , Add(_,_)) => +1
-      case Pair(Lit(_)  , Lit(_)  ) =>  0
-      case Pair(Lit(_)  , _       ) => -1
-      case Pair(_       , Lit(_)  ) => +1
-      case Pair(Var(l)  , Var(r)  ) => l.compareTo(r)
-      case Pair(Var(_)  , Pow(r,_)) => if (this *<= r) -1 else +1
-      case Pair(Pow(l,_), Var(_)  ) => if (l *<  that) -1 else +1
-      case Pair(Pow(l,_), Pow(r,_)) => l *<? r
+    private def *<? (that: Expr): Int = (this,that) match {
+      case (Mul(_,_), _       ) =>  0
+      case (_       , Mul(_,_)) =>  0
+      case (Add(_,_), Add(_,_)) =>  0
+      case (Add(_,_), _       ) => -1
+      case (_       , Add(_,_)) => +1
+      case (Lit(_)  , Lit(_)  ) =>  0
+      case (Lit(_)  , _       ) => -1
+      case (_       , Lit(_)  ) => +1
+      case (Var(l)  , Var(r)  ) => l.compareTo(r)
+      case (Var(_)  , Pow(r,_)) => if (this *<= r) -1 else +1
+      case (Pow(l,_), Var(_)  ) => if (l *<  that) -1 else +1
+      case (Pow(l,_), Pow(r,_)) => l *<? r
     }
 
-    def * (that: Expr): Expr = if (this *<= that) Pair(this,that) match {
-      case Pair(Lit(0)    , _         )                    => this
-      case Pair(Lit(1)    , _         )                    => that
-      case Pair(Mul(ll,lr), r         )                    => ll * (lr * r)
-      case Pair(Add(ll,lr), r         )                    => ll * r + lr * r
-      case Pair(Lit(l)    , Lit(r)    )                    => Lit(l * r)
-      case Pair(Var(_)    , Var(_)    ) if (this equ that) => Pow(this,2)
-      case Pair(Var(_)    , Pow(r,n)  ) if (this equ r)    => Pow(this,n + 1)
-      case Pair(Pow(ll,lr), Pow(rl,rr)) if (ll equ rl)     => Pow(ll,lr + rr)
-      case Pair(l         , Mul(rl,rr)) if (rl *<= l)      => (rl * l) * rr
-      case Pair(_         , _         )                    => Mul(this,that)
+    def * (that: Expr): Expr = if (this *<= that) (this,that) match {
+      case (Lit(0)    , _         )                    => this
+      case (Lit(1)    , _         )                    => that
+      case (Mul(ll,lr), r         )                    => ll * (lr * r)
+      case (Add(ll,lr), r         )                    => ll * r + lr * r
+      case (Lit(l)    , Lit(r)    )                    => Lit(l * r)
+      case (Var(_)    , Var(_)    ) if (this equ that) => Pow(this,2)
+      case (Var(_)    , Pow(r,n)  ) if (this equ r)    => Pow(this,n + 1)
+      case (Pow(ll,lr), Pow(rl,rr)) if (ll equ rl)     => Pow(ll,lr + rr)
+      case (l         , Mul(rl,rr)) if (rl *<= l)      => (rl * l) * rr
+      case (_         , _         )                    => Mul(this,that)
     } else that * this;
 
     def ^ (that: Int): Expr = (this,that) match {
-      case Pair(_       ,1) => this
-      case Pair(Lit(i)  ,n) => Lit(power(i,n))
-      case Pair(Var(_)  ,n) => Pow(this,n)
-      case Pair(Add(_,_),n) => this * (this ^ (n - 1))
-      case Pair(Mul(l,r),n) => (l ^ n) * (r ^ n)
-      case Pair(Pow(e,m),n) => Pow(e,m + n)
+      case (_       ,1) => this
+      case (Lit(i)  ,n) => Lit(power(i,n))
+      case (Var(_)  ,n) => Pow(this,n)
+      case (Add(_,_),n) => this * (this ^ (n - 1))
+      case (Mul(l,r),n) => (l ^ n) * (r ^ n)
+      case (Pow(e,m),n) => Pow(e,m + n)
     }
 
     def derive(v: Var): Expr = this match {
@@ -581,12 +581,12 @@ object MB {
       case Pow(l, r) => power(l.evaluate(vars), r)
     }
 
-    def equ(that: Expr): Boolean = Pair(this,that) match {
-      case Pair(Lit(l)    ,Lit(r))     => l == r
-      case Pair(Var(l)    ,Var(r))     => l == r
-      case Pair(Add(ll,lr),Add(rl,rr)) => (ll equ rl) && (lr equ rr)
-      case Pair(Mul(ll,lr),Mul(rl,rr)) => (ll equ rl) && (lr equ rr)
-      case Pair(Pow(ll,lr),Pow(rl,rr)) => (ll equ rl) && (lr == rr)
+    def equ(that: Expr): Boolean = (this,that) match {
+      case (Lit(l)    ,Lit(r))     => l == r
+      case (Var(l)    ,Var(r))     => l == r
+      case (Add(ll,lr),Add(rl,rr)) => (ll equ rl) && (lr equ rr)
+      case (Mul(ll,lr),Mul(rl,rr)) => (ll equ rl) && (lr equ rr)
+      case (Pow(ll,lr),Pow(rl,rr)) => (ll equ rl) && (lr == rr)
       case _ => false
     }
 
@@ -667,7 +667,7 @@ object MB {
     Console.println;
 
     def check(n: String, f: Expr, x: Int, e: Int) {
-      val a: Int = f.evaluate(List(Pair("x",x)));
+      val a: Int = f.evaluate(List(("x",x)));
       val s: String = if (a == e) "ok" else "KO(" + e + ")";
       Console.println(n + "(" + x + ") = " + a + " " + s);
     }
diff --git a/test/files/run/Course-2002-08.scala b/test/files/run/Course-2002-08.scala
index 38b8363661..5e21edaba3 100644
--- a/test/files/run/Course-2002-08.scala
+++ b/test/files/run/Course-2002-08.scala
@@ -163,7 +163,7 @@ object M5 {
   }
 
   abstract class Simulation() {
-    private type Agenda = List[Pair[Int, Action]];
+    private type Agenda = List[Tuple2[Int, Action]];
     private var agenda: Agenda = List();
     private var curtime = 0;
     def currentTime: Int = curtime;
@@ -171,17 +171,17 @@ object M5 {
     def afterDelay(delay: Int)(action: Action): Unit = {
       def insert(ag: Agenda, time: Int): Agenda = ag match {
         case List() =>
-          List(Pair(time, action))
-        case Pair(t, act) :: ag1 =>
-          if (time < t) Pair(time, action) :: ag
-          else Pair(t, act) :: insert(ag1, time)
+          List((time, action))
+        case (t, act) :: ag1 =>
+          if (time < t) (time, action) :: ag
+          else (t, act) :: insert(ag1, time)
       }
       agenda = insert(agenda, curtime + delay)
     }
 
     private def next: Unit = agenda match {
       case List() => ()
-      case Pair(time, action) :: ag1 => {
+      case (time, action) :: ag1 => {
         agenda = ag1;
         curtime = time;
         action();
@@ -413,7 +413,7 @@ object M5 {
 class Simulator() {
 
   type Action = () => Unit;
-  type Agenda = List[Pair[Int, Action]];
+  type Agenda = List[Tuple2[Int, Action]];
 
   private var agenda: Agenda = List();
   private var curtime = 0;
@@ -421,17 +421,17 @@ class Simulator() {
   def afterDelay(delay: Int)(action: Action) = {
     def insert(ag: Agenda, time: Int): Agenda = ag match {
       case List() =>
-        List(Pair(time, action))
-      case Pair(t, act) :: ag1 =>
-        if (time < t) Pair(time, action) :: ag
-        else Pair(t, act) :: insert(ag1, time)
+        List((time, action))
+      case (t, act) :: ag1 =>
+        if (time < t) (time, action) :: ag
+        else (t, act) :: insert(ag1, time)
     }
     agenda = insert(agenda, curtime + delay)
   }
 
   def next: Unit = agenda match {
     case List() => ()
-    case Pair(time, action) :: rest => {
+    case (time, action) :: rest => {
       agenda = rest;
       curtime = time;
       action();
@@ -567,8 +567,8 @@ class Main() extends CircuitSimulator() {
     demux(in, ctrl.reverse, out.reverse);
 
     probe("in", in);
-    for (Pair(x,c) <- range(0,n) zip ctrl) { probe("ctrl" + x, c) }
-    for (Pair(x,o) <- range(0,outNum) zip out) { probe("out" + x, o) }
+    for ((x,c) <- range(0,n) zip ctrl) { probe("ctrl" + x, c) }
+    for ((x,o) <- range(0,outNum) zip out) { probe("out" + x, o) }
 
     in.setSignal(true);
     run;
diff --git a/test/files/run/Course-2002-09.scala b/test/files/run/Course-2002-09.scala
index 87f91111d8..704f2ec0aa 100644
--- a/test/files/run/Course-2002-09.scala
+++ b/test/files/run/Course-2002-09.scala
@@ -13,11 +13,11 @@ object NoConstraint extends Constraint {
 }
 
 class Adder(a1: Quantity,a2: Quantity,sum: Quantity) extends Constraint {
-  def newValue = Triple(a1.getValue, a2.getValue, sum.getValue) match {
-    case Triple(Some(x1), Some(x2), _      ) => sum.setValue(x1 + x2, this)
-    case Triple(Some(x1), _       , Some(r)) => a2.setValue(r - x1, this)
-    case Triple(_       , Some(x2), Some(r)) => a1.setValue(r - x2, this)
-    case _                                   =>
+  def newValue = (a1.getValue, a2.getValue, sum.getValue) match {
+    case (Some(x1), Some(x2), _      ) => sum.setValue(x1 + x2, this)
+    case (Some(x1), _       , Some(r)) => a2.setValue(r - x1, this)
+    case (_       , Some(x2), Some(r)) => a1.setValue(r - x2, this)
+    case _                             =>
   }
   def dropValue: Unit = {
     a1.forgetValue(this); a2.forgetValue(this); sum.forgetValue(this);
@@ -29,13 +29,13 @@ class Adder(a1: Quantity,a2: Quantity,sum: Quantity) extends Constraint {
 
 class Multiplier(m1: Quantity, m2: Quantity, prod: Quantity)
                 extends Constraint {
-  def newValue = Triple(m1.getValue, m2.getValue, prod.getValue) match {
-    case Triple(Some(0d), _       , _      ) => prod.setValue(0, this);
-    case Triple(_       , Some(0d), _      ) => prod.setValue(0, this);
-    case Triple(Some(x1), Some(x2), _      ) => prod.setValue(x1 * x2, this)
-    case Triple(Some(x1), _       , Some(r)) => m2.setValue(r / x1, this)
-    case Triple(_,        Some(x2), Some(r)) => m1.setValue(r / x2, this)
-    case _                                   =>
+  def newValue = (m1.getValue, m2.getValue, prod.getValue) match {
+    case (Some(0d), _       , _      ) => prod.setValue(0, this);
+    case (_       , Some(0d), _      ) => prod.setValue(0, this);
+    case (Some(x1), Some(x2), _      ) => prod.setValue(x1 * x2, this)
+    case (Some(x1), _       , Some(r)) => m2.setValue(r / x1, this)
+    case (_,        Some(x2), Some(r)) => m1.setValue(r / x2, this)
+    case _                             =>
   }
   def dropValue: Unit = {
     m1.forgetValue(this); m2.forgetValue(this); prod.forgetValue(this);
@@ -46,11 +46,11 @@ class Multiplier(m1: Quantity, m2: Quantity, prod: Quantity)
 }
 
 class Squarer(square: Quantity, root: Quantity) extends Constraint {
-  def newValue: Unit = Pair(square.getValue, root.getValue) match {
-    case Pair(Some(x), _      )if (x < 0) => sys.error("Square of negative number")
-    case Pair(Some(x), _      )           => root.setValue(Math.sqrt(x), this)
-    case Pair(_      , Some(x))           => square.setValue(x*x, this)
-    case _                                =>
+  def newValue: Unit = (square.getValue, root.getValue) match {
+    case (Some(x), _      )if (x < 0) => sys.error("Square of negative number")
+    case (Some(x), _      )           => root.setValue(Math.sqrt(x), this)
+    case (_      , Some(x))           => square.setValue(x*x, this)
+    case _                            =>
   }
   def dropValue: Unit = {
     square.forgetValue(this); root.forgetValue(this);
@@ -60,9 +60,9 @@ class Squarer(square: Quantity, root: Quantity) extends Constraint {
 }
 
 class Eq(a: Quantity, b: Quantity) extends Constraint {
-  def newValue = (Pair(a.getValue, b.getValue): @unchecked) match {
-    case Pair(Some(x), _      ) => b.setValue(x, this);
-    case Pair(_      , Some(y)) => a.setValue(y, this);
+  def newValue = ((a.getValue, b.getValue): @unchecked) match {
+    case (Some(x), _      ) => b.setValue(x, this);
+    case (_      , Some(y)) => a.setValue(y, this);
   }
   def dropValue {
     a.forgetValue(this); b.forgetValue(this);
diff --git a/test/files/run/Course-2002-13.scala b/test/files/run/Course-2002-13.scala
index 4bd3614fb0..a596a33873 100644
--- a/test/files/run/Course-2002-13.scala
+++ b/test/files/run/Course-2002-13.scala
@@ -74,18 +74,18 @@ object Terms {
 
   val NoTerm = Con("<none>", List());
 
-  def unify1(x: Term, y: Term, s: Subst): Option[Subst] = Pair(x, y) match {
-    case Pair(Var(a), Var(b)) if (a == b) =>
+  def unify1(x: Term, y: Term, s: Subst): Option[Subst] = (x, y) match {
+    case (Var(a), Var(b)) if (a == b) =>
       Some(s)
-    case Pair(Var(a), _) => lookup(s, a) match {
+    case (Var(a), _) => lookup(s, a) match {
       case Some(x1) => unify(x1, y, s)
       case None => if (y.tyvars contains a) None else Some(Binding(a, y) :: s)
     }
-    case Pair(_, Var(b)) => lookup(s, b) match {
+    case (_, Var(b)) => lookup(s, b) match {
       case Some(y1) => unify(x, y1, s)
       case None => if (x.tyvars contains b) None else Some(Binding(b, x) :: s)
     }
-    case Pair(Con(a, xs), Con(b, ys)) if (a == b) =>
+    case (Con(a, xs), Con(b, ys)) if (a == b) =>
       unify(xs, ys, s)
     case _ => None
   }
@@ -96,9 +96,9 @@ object Terms {
     ss
   }
 
-  def unify(xs: List[Term], ys: List[Term], s: Subst): Option[Subst] = Pair(xs, ys) match {
-    case Pair(List(), List()) => Some(s)
-    case Pair(x :: xs1, y :: ys1) =>
+  def unify(xs: List[Term], ys: List[Term], s: Subst): Option[Subst] = (xs, ys) match {
+    case (List(), List()) => Some(s)
+    case (x :: xs1, y :: ys1) =>
       unify(x, y, s) match {
 	case Some(s1) => unify(xs1, ys1, s1)
 	case None => None
diff --git a/test/files/run/bugs.scala b/test/files/run/bugs.scala
index ba8449c299..02849b5817 100644
--- a/test/files/run/bugs.scala
+++ b/test/files/run/bugs.scala
@@ -46,7 +46,7 @@ object Bug135Test {
 
   def test(args: Array[String]) {
     val myMap:TreeMap[Int, String] = new TreeMap
-    val map1 = myMap + Pair(42, "The answer")
+    val map1 = myMap + ((42, "The answer"))
     println(map1.get(42))
   }
 
diff --git a/test/files/run/map_test.scala b/test/files/run/map_test.scala
index 1ea864ed58..b76dfb4577 100644
--- a/test/files/run/map_test.scala
+++ b/test/files/run/map_test.scala
@@ -20,7 +20,7 @@ object Test extends App {
     val map2 = map1.updated(17,"A small random number")
     val map3 = map2.updated(666,"A bigger random number")
     val map4 = map3.updated(4711,"A big random number")
-    map1 == myMap + Pair(42, "The answer")
+    map1 == myMap + ((42, "The answer"))
     var i = 0
     var map = map4
     while(i < 43) {
diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala
index b212e10f8d..3c0d00dc6c 100644
--- a/test/files/run/patmatnew.scala
+++ b/test/files/run/patmatnew.scala
@@ -46,7 +46,7 @@ object Test {
   object SimpleUnapply {
     def run() { // from sortedmap, old version
       List((1, 2)).head match {
-        case kv@Pair(key, _) => kv.toString + " " + key.toString
+        case kv@(key, _) => kv.toString + " " + key.toString
       }
 
     }
@@ -400,9 +400,9 @@ object Test {
   // these are exhaustive matches
   //   should not generate any warnings
   def f[A](z: (Option[A], Option[A])) = z match {
-    case Pair(None, Some(x)) => 1
-    case Pair(Some(x), None) => 2
-    case Pair(Some(x), Some(y)) => 3
+    case (None, Some(x)) => 1
+    case (Some(x), None) => 2
+    case (Some(x), Some(y)) => 3
     case _ => 4
   }
 
@@ -419,9 +419,9 @@ object Test {
   }
 
   def h[A](x: (Option[A], Option[A])) = x match {
-    case Pair(None, _: Some[_]) => 1
-    case Pair(_: Some[_], None) => 2
-    case Pair(_: Some[_], _: Some[_]) => 3
+    case (None, _: Some[_]) => 1
+    case (_: Some[_], None) => 2
+    case (_: Some[_], _: Some[_]) => 3
     case _ => 4
   }
 
@@ -539,17 +539,17 @@ object Test {
     case class Operator(x: Int);
     val EQ = new Operator(2);
 
-    def analyze(x: Pair[Operator, Int]) = x match {
-      case Pair(EQ, 0) => "0"
-      case Pair(EQ, 1) => "1"
-      case Pair(EQ, 2) => "2"
+    def analyze(x: Tuple2[Operator, Int]) = x match {
+      case (EQ, 0) => "0"
+      case (EQ, 1) => "1"
+      case (EQ, 2) => "2"
     }
     def run() {
-      val x = Pair(EQ, 0);
+      val x = (EQ, 0);
       assertEquals("0", analyze(x)); // should print "0"
-      val y = Pair(EQ, 1);
+      val y = (EQ, 1);
       assertEquals("1", analyze(y)); // should print "1"
-      val z = Pair(EQ, 2);
+      val z = (EQ, 2);
       assertEquals("2", analyze(z)); // should print "2"
     }
   }
diff --git a/test/files/run/t3888.scala b/test/files/run/t3888.scala
index 19771041fc..8701b42ff0 100644
--- a/test/files/run/t3888.scala
+++ b/test/files/run/t3888.scala
@@ -24,6 +24,6 @@ object Test {
   }
 }
 
-class P extends Pair(1, 1) {
+class P extends Tuple2(1, 1) {
   override def equals(x: Any) = true
 }
diff --git a/test/files/run/tailcalls.scala b/test/files/run/tailcalls.scala
index e5d8891cc7..1653b14de9 100644
--- a/test/files/run/tailcalls.scala
+++ b/test/files/run/tailcalls.scala
@@ -169,7 +169,7 @@ class TailCall[S](s: S) {
     aux[T](x, y);
   }
   final def g3[T](x: Int, y: Int, zs: List[T]): Int = {
-    def aux[U](n: Int, v: Int, ls: List[Pair[T,U]]): Int =
+    def aux[U](n: Int, v: Int, ls: List[Tuple2[T,U]]): Int =
       if (n == 0) v else aux(n - 1, v - 1, ls);
     aux(x, y, Nil);
   }
diff --git a/test/files/run/tcpoly_parseridioms.check b/test/files/run/tcpoly_parseridioms.check
index ab829e0a0e..8bd0a086d6 100644
--- a/test/files/run/tcpoly_parseridioms.check
+++ b/test/files/run/tcpoly_parseridioms.check
@@ -4,8 +4,8 @@ It would fail on the following input: ParseResult()
                                   ^
 tcpoly_parseridioms.scala:17: warning: match may not be exhaustive.
 It would fail on the following input: ParseResult()
-      def apply(in: Input): ParseResult[Pair[T, U]] = a(in) match {
-                                                       ^
+      def apply(in: Input): ParseResult[Tuple2[T, U]] = a(in) match {
+                                                         ^
 tcpoly_parseridioms.scala:30: warning: match may not be exhaustive.
 It would fail on the following input: ParseResult()
       case Failure(_, _) => b(in) match {
diff --git a/test/files/run/tcpoly_parseridioms.scala b/test/files/run/tcpoly_parseridioms.scala
index c8bcf693a1..d22f68b558 100644
--- a/test/files/run/tcpoly_parseridioms.scala
+++ b/test/files/run/tcpoly_parseridioms.scala
@@ -13,10 +13,10 @@ trait Parsers {
   }
 
   // sequence
-  def sq[T, U](a: => Parser[T], b: => Parser[U]): Parser[Pair[T, U]] =  new Parser[Pair[T, U]] {
-      def apply(in: Input): ParseResult[Pair[T, U]] = a(in) match {
+  def sq[T, U](a: => Parser[T], b: => Parser[U]): Parser[Tuple2[T, U]] =  new Parser[Tuple2[T, U]] {
+      def apply(in: Input): ParseResult[Tuple2[T, U]] = a(in) match {
         case Success(next, x) => b(next) match {
-          case Success(next2, y) => Success(next2, Pair(x,y))
+          case Success(next2, y) => Success(next2, (x,y))
           case Failure(_, msg) => Failure(in, msg)
         }
         case Failure(_, msg) => Failure(in, msg)
@@ -49,7 +49,7 @@ trait Parsers {
     }
   }
 
-  def apply_++[s, tt](fun: Parser[s => tt], arg: Parser[s]): Parser[tt] = lift[Pair[s=>tt, s], tt]({case Pair(f, a) => f(a)})(sq(fun, arg))
+  def apply_++[s, tt](fun: Parser[s => tt], arg: Parser[s]): Parser[tt] = lift[Tuple2[s=>tt, s], tt]({case (f, a) => f(a)})(sq(fun, arg))
 
   def success[u](v: u): Parser[u] = new Parser[u] {
     def apply(in: Input) = Success(in, v)
diff --git a/test/files/run/withIndex.scala b/test/files/run/withIndex.scala
index 910b1f1f9e..ebf1941c95 100644
--- a/test/files/run/withIndex.scala
+++ b/test/files/run/withIndex.scala
@@ -11,7 +11,7 @@ object Test {
     Console.println(str.zipWithIndex.toList)
     assert {
       ary.zipWithIndex match {
-        case _: Array[Pair[_,_]] => true
+        case _: Array[Tuple2[_,_]] => true
         case _ => false
       }
     }