Removed Pair(...), Triple(...).

48 files changed, 591 insertions, 520 deletions

diff --git a/src/compiler/scala/tools/nsc/CompileClient.scala b/src/compiler/scala/tools/nsc/CompileClient.scala
index bb24ad2d30..7c3a664641 100644
--- a/src/compiler/scala/tools/nsc/CompileClient.scala
+++ b/src/compiler/scala/tools/nsc/CompileClient.scala
@@ -35,7 +35,7 @@ object CompileClient {
     pathsList.map(absFileName).mkString("", sep, "")
   }
 
-  private def normalize(args: Array[String]): Pair[String, String] = {
+  private def normalize(args: Array[String]): (String, String) = {
     var i = 0
     val vmArgs = new StringBuilder
     var serverAdr = ""
@@ -70,7 +70,7 @@ object CompileClient {
         }
       }
     }
-    Pair(vmArgs.toString, serverAdr)
+    (vmArgs.toString, serverAdr)
   }
 
   // used by class ant.FastScalac to skip exit statement in Ant.
@@ -81,7 +81,7 @@ object CompileClient {
       else
         ("-d" :: "." :: args0.toList).toArray
 
-    val Pair(vmArgs, serverAdr) = normalize(args)
+    val (vmArgs, serverAdr) = normalize(args)
     if (version) {
       Console.println(versionMsg)
       return 0
diff --git a/src/compiler/scala/tools/nsc/CompileSocket.scala b/src/compiler/scala/tools/nsc/CompileSocket.scala
index 0fa020d4d3..0f9147de8a 100644
--- a/src/compiler/scala/tools/nsc/CompileSocket.scala
+++ b/src/compiler/scala/tools/nsc/CompileSocket.scala
@@ -55,13 +55,13 @@ object CompileSocket {
   /** The temporary directory in which the port identification file is stored */
   private val tmpDir = {
     val totry = List(
-        Pair("scala.home", List("var", "scala-devel")),
-        Pair("user.home", List("tmp")),
-        Pair("java.io.tmpdir", Nil))
+        ("scala.home", List("var", "scala-devel")),
+        ("user.home", List("tmp")),
+        ("java.io.tmpdir", Nil))
 
     /** Expand a property-extensions pair into a complete File object */
-    def expand(trial: Pair[String, List[String]]): Option[File] = {
-      val Pair(topdirProp, extensions) = trial
+    def expand(trial: (String, List[String])): Option[File] = {
+      val (topdirProp, extensions) = trial
       val topdir = System.getProperty(topdirProp)
       if (topdir eq null)
         return None
diff --git a/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala b/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala
index 4503abf241..cf6e6672db 100644
--- a/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala
+++ b/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala
@@ -36,7 +36,7 @@ extends Settings(error) {
   class DefinesSetting
   extends Setting("-D<prop>", "set a Java property")
   {
-    private val props = new Queue[Pair[String, String]]
+    private val props = new Queue[(String, String)]
 
     def value = props.toList
 
@@ -49,9 +49,9 @@ extends Settings(error) {
           val eqidx = stripD.indexOf('=')
           val addition =
             if(eqidx < 0)
-              Pair(stripD, "")
+              (stripD, "")
             else
-              Pair(stripD.substring(0, eqidx), stripD.substring(eqidx+1))
+              (stripD.substring(0, eqidx), stripD.substring(eqidx+1))
           props += addition
           rest
         }
@@ -63,7 +63,7 @@ extends Settings(error) {
     /** Apply the specified properties to the current JVM */
     def applyToCurrentJVM = {
       val systemProps = getProperties
-      for(val Pair(key, value) <- props.toList)
+      for(val (key, value) <- props.toList)
         systemProps.setProperty(key, value)
     }
 
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 016d84f6b1..8d8297afd1 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -507,7 +507,7 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable
         showDef(newTermName(settings.Xshowobj.value), true)
 
       if (reporter.hasErrors) {
-        for (val Pair(sym, file) <- symSource.elements) {
+        for (val (sym, file) <- symSource.elements) {
           sym.reset(new loaders.SourcefileLoader(file))
           if (sym.isTerm) sym.moduleClass.reset(loaders.moduleClassLoader)
         }
@@ -520,7 +520,7 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable
           warning("there were unchecked warnings; re-run with -unchecked for details")
         }
       }
-      for (val Pair(sym, file) <- symSource.elements) resetPackageClass(sym.owner)
+      for (val (sym, file) <- symSource.elements) resetPackageClass(sym.owner)
       //units foreach (.clear())
       informTime("total", startTime)
     }
diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala
index c8115cf7b4..c66590c359 100644
--- a/src/compiler/scala/tools/nsc/Interpreter.scala
+++ b/src/compiler/scala/tools/nsc/Interpreter.scala
@@ -282,7 +282,7 @@ class Interpreter(val settings: Settings, reporter: Reporter, out: PrintWriter)
     if (!req.compile)
       return IR.Error  // an error happened during compilation, e.g. a type error
 
-    val Pair(interpreterResultString, succeeded) = req.loadAndRun
+    val (interpreterResultString, succeeded) = req.loadAndRun
 
     if (printResults || !succeeded) {
       // print the result
@@ -553,20 +553,20 @@ class Interpreter(val settings: Settings, reporter: Reporter, out: PrintWriter)
     }
 
     /** load and run the code using reflection */
-    def loadAndRun: Pair[String, Boolean] = {
+    def loadAndRun: (String, Boolean) = {
       val interpreterResultObject: Class =
         Class.forName(resultObjectName, true, classLoader)
       val resultValMethod: java.lang.reflect.Method =
         interpreterResultObject.getMethod("result", null)
       try {
-        Pair(resultValMethod.invoke(interpreterResultObject, null).toString(),
+        (resultValMethod.invoke(interpreterResultObject, null).toString(),
              true)
       } catch {
         case e => {
           def caus(e: Throwable): Throwable =
             if (e.getCause eq null) e else caus(e.getCause)
             val orig = caus(e)
-            Pair(stringFrom(str => orig.printStackTrace(str)),
+            (stringFrom(str => orig.printStackTrace(str)),
                  false)
         }
       }
diff --git a/src/compiler/scala/tools/nsc/InterpreterLoop.scala b/src/compiler/scala/tools/nsc/InterpreterLoop.scala
index 6696f210df..a353c2b3e8 100644
--- a/src/compiler/scala/tools/nsc/InterpreterLoop.scala
+++ b/src/compiler/scala/tools/nsc/InterpreterLoop.scala
@@ -108,7 +108,7 @@ class InterpreterLoop(in0: BufferedReader, out: PrintWriter) {
       if (line eq null)
         return ()  // assumes null means EOF
 
-      val Pair(keepGoing, finalLineMaybe) = command(line)
+      val (keepGoing, finalLineMaybe) = command(line)
 
       if (!keepGoing)
         return
@@ -158,7 +158,7 @@ class InterpreterLoop(in0: BufferedReader, out: PrintWriter) {
   /** Run one command submitted by the user.  Three values are returned:
     * (1) whether to keep running, (2) the line to record for replay,
     * if any. */
-  def command(line: String): Pair[Boolean, Option[String]] = {
+  def command(line: String): (Boolean, Option[String]) = {
     def withFile(command: String)(action: String => Unit): Unit = {
       val spaceIdx = command.indexOf(' ')
       if (spaceIdx <= 0) {
@@ -183,7 +183,7 @@ class InterpreterLoop(in0: BufferedReader, out: PrintWriter) {
     if (line.matches(helpRegexp))
       printHelp
     else if (line.matches(quitRegexp))
-      return Pair(false, None)
+      return (false, None)
     else if (line.matches(loadRegexp)) {
       withFile(line)(f => {
         interpretAllFrom(f)
@@ -197,7 +197,7 @@ class InterpreterLoop(in0: BufferedReader, out: PrintWriter) {
     else
       shouldReplay = interpretStartingWith(line)
 
-    Pair(true, shouldReplay)
+    (true, shouldReplay)
   }
 
   /** Interpret expressions starting with the first line.
diff --git a/src/compiler/scala/tools/nsc/ScriptRunner.scala b/src/compiler/scala/tools/nsc/ScriptRunner.scala
index e541cfc906..6ee8348600 100644
--- a/src/compiler/scala/tools/nsc/ScriptRunner.scala
+++ b/src/compiler/scala/tools/nsc/ScriptRunner.scala
@@ -227,7 +227,7 @@ object ScriptRunner {
       * the directory with the compiled class files,
       * and a flag for whether the compilation succeeded.
       */
-    def compile: Pair[File, Boolean] = {
+    def compile: (File, Boolean) = {
       val compiledPath = File.createTempFile("scalascript", "")
       compiledPath.delete  // the file is created as a file; make it a directory
       compiledPath.mkdirs
@@ -239,10 +239,10 @@ object ScriptRunner {
         val compiler = new Global(settings, reporter)
         val cr = new compiler.Run
         cr.compileSources(List(wrappedScript(scriptFile, &compiler.getSourceFile)))
-        Pair(compiledPath, !reporter.hasErrors)
+        (compiledPath, !reporter.hasErrors)
       } else {
         val compok = compileWithDaemon(settings, scriptFile)
-        Pair(compiledPath, compok)
+        (compiledPath, compok)
       }
     }
 
@@ -258,7 +258,7 @@ object ScriptRunner {
       } else {
         // The pre-compiled jar is old.  Recompile the script.
         jarFile.delete
-        val Pair(compiledPath, compok) = compile
+        val (compiledPath, compok) = compile
         try {
           if (compok) {
             tryMakeJar(jarFile, compiledPath)
@@ -277,7 +277,7 @@ object ScriptRunner {
       }
     } else {
       // don't use the cache; just run from the interpreter's temporary directory
-      val Pair(compiledPath, compok) = compile
+      val (compiledPath, compok) = compile
       try {
         if (compok)
           handler(compiledPath.getPath)
diff --git a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
index 038daeb815..057071f97f 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
@@ -173,7 +173,7 @@ abstract class TreeBrowsers {
         override def convertValueToText(value: Any, sel: Boolean,
                                         exp: Boolean, leaf: Boolean,
                                         row: Int, hasFocus: Boolean) = {
-            val Pair(cls, name) = TreeInfo.treeName(value.asInstanceOf[Tree])
+            val (cls, name) = TreeInfo.treeName(value.asInstanceOf[Tree])
             if (name != EMPTY)
               cls + "[" + name.toString() + "]"
             else
@@ -250,138 +250,138 @@ abstract class TreeBrowsers {
   object TreeInfo {
 
     /** Return the case class name and the Name, if the node defines one */
-    def treeName(t: Tree): Pair[String, Name] = t match {
+    def treeName(t: Tree): (String, Name) = t match {
       case ProgramTree(units) =>
-        Pair("Program", EMPTY)
+        ("Program", EMPTY)
 
       case UnitTree(unit) =>
-        Pair("CompilationUnit", unit.toString())
+        ("CompilationUnit", unit.toString())
 
       case DocDef(comment, definition) =>
-        Pair("DocDef", EMPTY)
+        ("DocDef", EMPTY)
 
       case ClassDef(mods, name, tparams, self, impl) =>
-        Pair("ClassDef", name)
+        ("ClassDef", name)
 
       case PackageDef(packaged, impl) =>
-        Pair("PackageDef", EMPTY)
+        ("PackageDef", EMPTY)
 
       case ModuleDef(mods, name, impl) =>
-        Pair("ModuleDef", name)
+        ("ModuleDef", name)
 
       case ValDef(mods, name, tpe, rhs) =>
-        Pair("ValDef", name)
+        ("ValDef", name)
 
       case DefDef(mods, name, tparams, vparams, tpe, rhs) =>
-        Pair("DefDef", name)
+        ("DefDef", name)
 
       case AbsTypeDef(mods, name, rhs, lobound) =>
-        Pair("AbsTypeDef", name)
+        ("AbsTypeDef", name)
 
       case AliasTypeDef(mods, name, tparams, rhs) =>
-        Pair("AliasTypeDef", name)
+        ("AliasTypeDef", name)
 
       case Import(expr, selectors) =>
-        Pair("Import", EMPTY)
+        ("Import", EMPTY)
 
       case CaseDef(pat, guard, body) =>
-        Pair("CaseDef", EMPTY)
+        ("CaseDef", EMPTY)
 
       case Template(parents, body) =>
-        Pair("Template", EMPTY)
+        ("Template", EMPTY)
 
       case LabelDef(name, params, rhs) =>
-        Pair("LabelDef", name)
+        ("LabelDef", name)
 
       case Block(stats, expr) =>
-        Pair("Block", EMPTY)
+        ("Block", EMPTY)
 
       case Sequence(trees) =>
-        Pair("Sequence", EMPTY)
+        ("Sequence", EMPTY)
 
       case Alternative(trees) =>
-        Pair("Alternative", EMPTY)
+        ("Alternative", EMPTY)
 
       case Bind(name, rhs) =>
-        Pair("Bind", name)
+        ("Bind", name)
 
       case Match(selector, cases) =>
-        Pair("Visitor", EMPTY)
+        ("Visitor", EMPTY)
 
       case Function(vparams, body) =>
-        Pair("Function", EMPTY)
+        ("Function", EMPTY)
 
       case Assign(lhs, rhs) =>
-        Pair("Assign", EMPTY)
+        ("Assign", EMPTY)
 
       case If(cond, thenp, elsep) =>
-        Pair("If", EMPTY)
+        ("If", EMPTY)
 
       case Return(expr) =>
-        Pair("Return", EMPTY)
+        ("Return", EMPTY)
 
       case Throw(expr) =>
-        Pair("Throw", EMPTY)
+        ("Throw", EMPTY)
 
       case New(init) =>
-        Pair("New", EMPTY)
+        ("New", EMPTY)
 
       case Typed(expr, tpe) =>
-        Pair("Typed", EMPTY)
+        ("Typed", EMPTY)
 
       case TypeApply(fun, args) =>
-        Pair("TypeApply", EMPTY)
+        ("TypeApply", EMPTY)
 
       case Apply(fun, args) =>
-        Pair("Apply", EMPTY)
+        ("Apply", EMPTY)
 
       case Super(qualif, mix) =>
-        Pair("Super", qualif.toString() + ", mix: " + mix.toString())
+        ("Super", qualif.toString() + ", mix: " + mix.toString())
 
       case This(qualifier) =>
-        Pair("This", qualifier)
+        ("This", qualifier)
 
       case Select(qualifier, selector) =>
-        Pair("Select", selector)
+        ("Select", selector)
 
       case Ident(name) =>
-        Pair("Ident", name)
+        ("Ident", name)
 
       case Literal(value) =>
-        Pair("Literal", EMPTY)
+        ("Literal", EMPTY)
 
       case TypeTree() =>
-        Pair("TypeTree", EMPTY)
+        ("TypeTree", EMPTY)
 
       case Annotated(constr, elements, arg) =>
-        Pair("Annotated", EMPTY)
+        ("Annotated", EMPTY)
 
       case AttributedTypeTree(attribs, tpt) =>
-        Pair("AttributedTypeTree", EMPTY)
+        ("AttributedTypeTree", EMPTY)
 
       case SingletonTypeTree(ref) =>
-        Pair("SingletonType", EMPTY)
+        ("SingletonType", EMPTY)
 
       case SelectFromTypeTree(qualifier, selector) =>
-        Pair("SelectFromType", selector)
+        ("SelectFromType", selector)
 
       case CompoundTypeTree(template) =>
-        Pair("CompoundType", EMPTY)
+        ("CompoundType", EMPTY)
 
       case AppliedTypeTree(tpe, args) =>
-        Pair("AppliedType", EMPTY)
+        ("AppliedType", EMPTY)
 
       case Try(block, catcher, finalizer) =>
-        Pair("Try", EMPTY)
+        ("Try", EMPTY)
 
       case EmptyTree =>
-        Pair("Empty", EMPTY)
+        ("Empty", EMPTY)
 
       case ArrayValue(elemtpt, trees) =>
-        Pair("ArrayValue", EMPTY)
+        ("ArrayValue", EMPTY)
 
       case Star(t) =>
-        Pair("Star", EMPTY)
+        ("Star", EMPTY)
     }
 
     /** Return a list of children for the given tree node */
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 28a7fd10b0..2ff4b41266 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -8,6 +8,7 @@ package scala.tools.nsc.ast
 
 import scala.tools.nsc.util.Position
 import symtab.Flags._
+import scala.collection.mutable.ListBuffer
 
 abstract class TreeGen {
 
@@ -205,4 +206,34 @@ abstract class TreeGen {
 
   def mkRuntimeCall(meth: Name, args: List[Tree]): Tree =
     Apply(Select(mkAttributedRef(ScalaRunTimeModule), meth), args)
+
+  def evalOnce(expr: Tree, owner: Symbol, unit: CompilationUnit)(within: (() => Tree) => Tree): Tree =
+    if (treeInfo.isPureExpr(expr)) {
+      within(() => expr);
+    } else {
+      val temp = owner.newValue(expr.pos, unit.fresh.newName())
+      .setFlag(SYNTHETIC).setInfo(expr.tpe);
+      atPos(expr.pos) {
+        Block(List(ValDef(temp, expr)), within(() => Ident(temp) setType expr.tpe))
+      }
+    }
+
+  def evalOnceAll(exprs: List[Tree], owner: Symbol, unit: CompilationUnit)(within: (List[() => Tree]) => Tree): Tree = {
+    val vdefs = new ListBuffer[ValDef]
+    val exprs1 = new ListBuffer[() => Tree]
+    for (val expr <- exprs) {
+      if (treeInfo.isPureExpr(expr)) {
+        exprs1 += (() => expr)
+      } else {
+        val temp = owner.newValue(expr.pos, unit.fresh.newName())
+          .setFlag(SYNTHETIC).setInfo(expr.tpe)
+        vdefs += ValDef(temp, expr)
+        exprs1 += (() => Ident(temp) setType expr.tpe)
+      }
+    }
+    val prefix = vdefs.toList
+    val result = within(exprs1.toList)
+    if (prefix.isEmpty) result
+    else Block(prefix, result) setPos prefix.head.pos
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
index 13980856ec..d4ff2d1737 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
@@ -96,6 +96,25 @@ abstract class TreeInfo {
       false
   }
 
+  def mayBeVarGetter(sym: Symbol) = sym.info match {
+    case PolyType(List(), _) => sym.owner.isClass && !sym.isStable
+    case _: ImplicitMethodType => sym.owner.isClass && !sym.isStable
+    case _ => false
+  }
+
+  def isVariableOrGetter(tree: Tree) = tree match {
+    case Ident(_) =>
+      tree.symbol.isVariable
+    case Select(qual, _) =>
+      tree.symbol.isVariable ||
+      (mayBeVarGetter(tree.symbol) &&
+       tree.symbol.owner.info.decl(nme.getterToSetter(tree.symbol.name)) != NoSymbol)
+    case Apply(Select(qual, nme.apply), _) =>
+      qual.tpe.decl(nme.update) != NoSymbol
+    case _ =>
+      false
+  }
+
   /** Is tree a self constructor call?
    */
   def isSelfConstrCall(tree: Tree): boolean = tree match {
diff --git a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
index 5294cb5fc6..c592c01af0 100644
--- a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
@@ -177,7 +177,7 @@ abstract class TreePrinters {
           print(symName(tree, name)); printRow(params, "(", ",", ")"); printBlock(rhs)
 
         case Import(expr, selectors) =>
-          def selectorToString(s: Pair[Name, Name]): String =
+          def selectorToString(s: (Name, Name)): String =
             if (s._1 == nme.WILDCARD || s._1 == s._2) s._1.toString()
             else s._1.toString() + "=>" + s._2.toString()
           print("import "); print(expr)
diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index a2085bb50b..d4f400169d 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -409,7 +409,7 @@ trait Trees requires Global {
    *  @param expr
    *  @param selectors
    */
-  case class Import(expr: Tree, selectors: List[Pair[Name, Name]])
+  case class Import(expr: Tree, selectors: List[(Name, Name)])
        extends SymTree
 
   /** Annotation application (constructor arguments + name-value pairs) */
@@ -751,7 +751,7 @@ trait Trees requires Global {
     def AbsTypeDef(tree: Tree, mods: Modifiers, name: Name, lo: Tree, hi: Tree): AbsTypeDef
     def AliasTypeDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[AbsTypeDef], rhs: Tree): AliasTypeDef
     def LabelDef(tree: Tree, name: Name, params: List[Ident], rhs: Tree): LabelDef
-    def Import(tree: Tree, expr: Tree, selectors: List[Pair[Name, Name]]): Import
+    def Import(tree: Tree, expr: Tree, selectors: List[(Name, Name)]): Import
     def Annotation(tree: Tree, constr: Tree, elements: List[Tree]): Annotation
     def DocDef(tree: Tree, comment: String, definition: Tree): DocDef
     def Template(tree: Tree, parents: List[Tree], body: List[Tree]): Template
@@ -806,7 +806,7 @@ trait Trees requires Global {
       new AliasTypeDef(mods, name, tparams, rhs).copyAttrs(tree)
     def LabelDef(tree: Tree, name: Name, params: List[Ident], rhs: Tree) =
       new LabelDef(name, params, rhs).copyAttrs(tree)
-    def Import(tree: Tree, expr: Tree, selectors: List[Pair[Name, Name]]) =
+    def Import(tree: Tree, expr: Tree, selectors: List[(Name, Name)]) =
       new Import(expr, selectors).copyAttrs(tree)
     def Annotation(tree: Tree, constr: Tree, elements: List[Tree]) =
       new Annotation(constr, elements)
@@ -923,7 +923,7 @@ trait Trees requires Global {
       if (name0 == name) && (params0 == params) && (rhs0 == rhs) => t
       case _ => copy.LabelDef(tree, name, params, rhs)
     }
-    def Import(tree: Tree, expr: Tree, selectors: List[Pair[Name, Name]]) = tree match {
+    def Import(tree: Tree, expr: Tree, selectors: List[(Name, Name)]) = tree match {
       case t @ Import(expr0, selectors0)
       if (expr0 == expr) && (selectors0 == selectors) => t
       case _ => copy.Import(tree, expr, selectors)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
index 4e1d73b53f..1da2a5e779 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
@@ -62,7 +62,7 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
     else
       reportSyntaxError("'" + that + "' expected instead of '" + ch + "'")
 
-  var debugLastStartElement = new mutable.Stack[Pair[Int, String]]
+  var debugLastStartElement = new mutable.Stack[(Int, String)]
 
   /** checks whether next character starts a Scala block, if yes, skip it.
    * @return true if next character starts a scala block
@@ -143,7 +143,7 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
    *  [40] STag         ::= '<' Name { S Attribute } [S]
    *  [44] EmptyElemTag ::= '<' Name { S Attribute } [S]
    */
-  /*[Duplicate]*/ def xTag: Pair[String, mutable.Map[String, Tree]] = {
+  /*[Duplicate]*/ def xTag: (String, mutable.Map[String, Tree]) = {
     val elemName = xName
     xSpaceOpt
     val aMap =
@@ -378,7 +378,7 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
       if(qname == "xml:unparsed")
         return xUnparsed
 
-      debugLastStartElement.push(Pair(pos1, qname))
+      debugLastStartElement.push((pos1, qname))
       val ts = content
       xEndTag(qname)
       debugLastStartElement.pop
@@ -613,7 +613,7 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
     //Console.println("xPattern")
     val pos1 = pos
     val qname = xName
-    debugLastStartElement.push(Pair(pos1, qname))
+    debugLastStartElement.push((pos1, qname))
     xSpaceOpt
     if (ch == '/') { // empty tag
       nextch
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index e21460633c..6f4247b49e 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -1059,8 +1059,8 @@ trait Parsers requires SyntaxAnalyzer {
               parents += annotType(false)
             }
             newLineOptWhenFollowedBy(LBRACE)
-            val Pair(self, stats) = if (in.token == LBRACE) templateBody()
-                                    else Pair(emptyValDef, List())
+            val (self, stats) = if (in.token == LBRACE) templateBody()
+                                    else (emptyValDef, List())
             makeNew(parents.toList, self, stats, argss.toList)
           }
           canApply = false
@@ -1704,7 +1704,7 @@ trait Parsers requires SyntaxAnalyzer {
         def loop: Tree =
           if (in.token == USCORE) {
             in.nextToken()
-            Import(t, List(Pair(nme.WILDCARD, null)))
+            Import(t, List((nme.WILDCARD, null)))
           } else if (in.token == LBRACE) {
             Import(t, importSelectors())
           } else {
@@ -1714,7 +1714,7 @@ trait Parsers requires SyntaxAnalyzer {
               pos = accept(DOT)
               loop
             } else {
-              Import(t, List(Pair(name, name)))
+              Import(t, List((name, name)))
             }
           }
         loop
@@ -1722,8 +1722,8 @@ trait Parsers requires SyntaxAnalyzer {
 
     /** ImportSelectors ::= `{' {ImportSelector `,'} (ImportSelector | `_') `}'
      */
-    def importSelectors(): List[Pair[Name, Name]] = {
-      val names = new ListBuffer[Pair[Name, Name]]
+    def importSelectors(): List[(Name, Name)] = {
+      val names = new ListBuffer[(Name, Name)]
       accept(LBRACE)
       var isLast = importSelector(names)
       while (!isLast && in.token == COMMA) {
@@ -1736,12 +1736,12 @@ trait Parsers requires SyntaxAnalyzer {
 
     /** ImportSelector ::= Id [`=>' Id | `=>' `_']
      */
-    def importSelector(names: ListBuffer[Pair[Name, Name]]): boolean =
+    def importSelector(names: ListBuffer[(Name, Name)]): boolean =
       if (in.token == USCORE) {
-        in.nextToken(); names += Pair(nme.WILDCARD, null); true
+        in.nextToken(); names += (nme.WILDCARD, null); true
       } else {
         val name = ident()
-        names += Pair(
+        names += (
           name,
           if (in.token == ARROW) {
             in.nextToken()
@@ -1821,9 +1821,9 @@ trait Parsers requires SyntaxAnalyzer {
      */
     def varDefOrDcl(mods: Modifiers): List[Tree] = {
       var newmods = mods | Flags.MUTABLE
-      val lhs = new ListBuffer[Pair[Int, Name]]
+      val lhs = new ListBuffer[(Int, Name)]
       do {
-        lhs += Pair(in.skipToken(), ident())
+        lhs += (in.skipToken(), ident())
       } while (in.token == COMMA)
       val tp = typedOpt()
       val rhs = if (tp.isEmpty || in.token == EQUALS) {
@@ -1838,7 +1838,7 @@ trait Parsers requires SyntaxAnalyzer {
         newmods = newmods | Flags.DEFERRED
         EmptyTree
       }
-      for (val Pair(pos, name) <- lhs.toList) yield
+      for (val (pos, name) <- lhs.toList) yield
         atPos(pos) { ValDef(newmods, name, tp.duplicate, rhs.duplicate) }
     }
 
@@ -1965,12 +1965,12 @@ trait Parsers requires SyntaxAnalyzer {
         implicitClassViews = implicitViewBuf.toList
         //if (mods.hasFlag(Flags.CASE) && in.token != LPAREN) accept(LPAREN)
         val constrAnnots = annotations()
-        val Pair(constrMods, vparamss) =
-          if (mods.hasFlag(Flags.TRAIT)) Pair(NoMods, List())
-          else Pair(accessModifierOpt(),
+        val (constrMods, vparamss) =
+          if (mods.hasFlag(Flags.TRAIT)) (NoMods, List())
+          else (accessModifierOpt(),
                     paramClauses(name, implicitClassViews, mods.hasFlag(Flags.CASE)))
         val thistpe = requiresTypeOpt()
-        val Pair(self0, template) =
+        val (self0, template) =
           classTemplate(mods, name, constrMods withAnnotations constrAnnots, vparamss)
         val mods1 = if (mods.hasFlag(Flags.TRAIT) &&
                         (template.body forall treeInfo.isInterfaceMember))
@@ -1987,7 +1987,7 @@ trait Parsers requires SyntaxAnalyzer {
     def objectDef(mods: Modifiers): ModuleDef =
       atPos(in.skipToken()) {
         val name = ident()
-        val Pair(self, template0) = classTemplate(mods, name, NoMods, List())
+        val (self, template0) = classTemplate(mods, name, NoMods, List())
         val template = self match {
           case ValDef(mods, name, tpt, EmptyTree) if (name != nme.WILDCARD) =>
             val vd = ValDef(mods, name, tpt, This(nme.EMPTY.toTypeName)) setPos self.pos
@@ -2003,7 +2003,7 @@ trait Parsers requires SyntaxAnalyzer {
      *  TraitTemplate      ::= [extends MixinParents] [TemplateBody]
      *  MixinParents       ::= AnnotType {with AnnotType}
      */
-    def classTemplate(mods: Modifiers, name: Name, constrMods: Modifiers, vparamss: List[List[ValDef]]): Pair[ValDef, Template] = {
+    def classTemplate(mods: Modifiers, name: Name, constrMods: Modifiers, vparamss: List[List[ValDef]]): (ValDef, Template) = {
       val pos = in.currentPos;
       def acceptEmptyTemplateBody(msg: String): unit = {
         if (in.token == LPAREN && settings.migrate.value)
@@ -2039,10 +2039,10 @@ trait Parsers requires SyntaxAnalyzer {
       }
       val ps = parents.toList
       newLineOptWhenFollowedBy(LBRACE)
-      val Pair(self, body) =
+      val (self, body) =
         if (in.token == LBRACE) templateBody()
-        else { acceptEmptyTemplateBody("`{' expected"); Pair(emptyValDef, List()) }
-      Pair(self,
+        else { acceptEmptyTemplateBody("`{' expected"); (emptyValDef, List()) }
+      (self,
            atPos(pos) {
              if (!mods.hasFlag(Flags.TRAIT)) Template(ps, constrMods, vparamss, argss.toList, body)
              else Template(ps, body)
@@ -2053,11 +2053,11 @@ trait Parsers requires SyntaxAnalyzer {
 
     /** TemplateBody ::= [nl] `{' TemplateStatSeq `}'
      */
-    def templateBody(): Pair[ValDef, List[Tree]] = {
+    def templateBody(): (ValDef, List[Tree]) = {
       accept(LBRACE)
-      val result @ Pair(self, stats) = templateStatSeq()
+      val result @ (self, stats) = templateStatSeq()
       accept(RBRACE)
-      if (stats.isEmpty) Pair(self, List(EmptyTree)) else result
+      if (stats.isEmpty) (self, List(EmptyTree)) else result
     }
 
     /** Refinement ::= [nl] `{' RefineStat {semi RefineStat} `}'
@@ -2122,7 +2122,7 @@ trait Parsers requires SyntaxAnalyzer {
      *                     | Expr1
      *                     |
      */
-    def templateStatSeq(): Pair[ValDef, List[Tree]] = {
+    def templateStatSeq(): (ValDef, List[Tree]) = {
       var self: ValDef = emptyValDef
       val stats = new ListBuffer[Tree]
       if (isExprIntro) {
@@ -2149,7 +2149,7 @@ trait Parsers requires SyntaxAnalyzer {
         }
         if (in.token != RBRACE && in.token != EOF) acceptStatSep()
       }
-      Pair(self, stats.toList)
+      (self, stats.toList)
     }
 
     /** RefineStatSeq    ::= RefineStat {semi RefineStat}
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 251d1a774f..e6efb6e76a 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -57,16 +57,16 @@ abstract class TreeBuilder {
 
   /** Traverse pattern and collect all variable names with their types in buffer */
   private object getvarTraverser extends Traverser {
-    val buf = new ListBuffer[Pair[Name, Tree]]
+    val buf = new ListBuffer[(Name, Tree)]
     def init: Traverser = { buf.clear; this }
     override def traverse(tree: Tree): unit = tree match {
       case Bind(name, Typed(tree1, tpt)) =>
         if ((name != nme.WILDCARD) && (buf.elements forall (name !=)))
-          buf += Pair(name, tpt)
+          buf += (name, tpt)
         traverse(tree1)
       case Bind(name, tree1) =>
         if ((name != nme.WILDCARD) && (buf.elements forall (name !=)))
-          buf += Pair(name, TypeTree())
+          buf += (name, TypeTree())
         traverse(tree1)
       case _ =>
         super.traverse(tree)
@@ -76,7 +76,7 @@ abstract class TreeBuilder {
   /** Returns list of all pattern variables, possibly with their types,
    *  without duplicates
    */
-  private def getVariables(tree: Tree): List[Pair[Name, Tree]] = {
+  private def getVariables(tree: Tree): List[(Name, Tree)] = {
     getvarTraverser.init.traverse(tree)
     getvarTraverser.buf.toList
   }
@@ -112,11 +112,11 @@ abstract class TreeBuilder {
 
   /** If tree is a variable pattern, return Some("its name and type").
    *  Otherwise return none */
-  private def matchVarPattern(tree: Tree): Option[Pair[Name, Tree]] = tree match {
-    case Ident(name) => Some(Pair(name, TypeTree()))
-    case Bind(name, Ident(nme.WILDCARD)) => Some(Pair(name, TypeTree()))
-    case Typed(Ident(name), tpt) => Some(Pair(name, tpt))
-    case Bind(name, Typed(Ident(nme.WILDCARD), tpt)) => Some(Pair(name, tpt))
+  private def matchVarPattern(tree: Tree): Option[(Name, Tree)] = tree match {
+    case Ident(name) => Some((name, TypeTree()))
+    case Bind(name, Ident(nme.WILDCARD)) => Some((name, TypeTree()))
+    case Typed(Ident(name), tpt) => Some((name, tpt))
+    case Bind(name, Typed(Ident(nme.WILDCARD), tpt)) => Some((name, tpt))
     case _ => None
   }
 
@@ -265,7 +265,7 @@ abstract class TreeBuilder {
   private def makeFor(mapName: Name, flatMapName: Name, enums: List[Enumerator], body: Tree): Tree = {
 
     def makeClosure(pat: Tree, body: Tree): Tree = matchVarPattern(pat) match {
-      case Some(Pair(name, tpt)) =>
+      case Some((name, tpt)) =>
         Function(List(ValDef(Modifiers(PARAM), name, tpt, EmptyTree)), body)
       case None =>
         makeVisitor(List(CaseDef(pat, EmptyTree, body)), false)
@@ -390,7 +390,7 @@ abstract class TreeBuilder {
 
   /** Create tree for pattern definition &lt;mods val pat0 = rhs&gt; */
   def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree): List[Tree] = matchVarPattern(pat) match {
-    case Some(Pair(name, tpt)) =>
+    case Some((name, tpt)) =>
       List(ValDef(mods, name, tpt, rhs))
 
     case None =>
@@ -415,13 +415,13 @@ abstract class TreeBuilder {
       vars match {
         case List() =>
           List(matchExpr)
-        case List(Pair(vname, tpt)) =>
+        case List((vname, tpt)) =>
           List(ValDef(mods, vname, tpt, matchExpr))
         case _ =>
           val tmp = freshName()
           val firstDef = ValDef(Modifiers(PRIVATE | LOCAL | SYNTHETIC), tmp, TypeTree(), matchExpr)
           var cnt = 0
-          val restDefs = for (val Pair(vname, tpt) <- vars) yield {
+          val restDefs = for (val (vname, tpt) <- vars) yield {
             cnt = cnt + 1
             ValDef(mods, vname, tpt, Select(Ident(tmp), newTermName("_" + cnt)))
           }
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala b/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala
index e7a456aee6..f7dd446c0d 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala
@@ -209,7 +209,7 @@ abstract class Checkers {
          *  kind TypeKind.
          */
         def checkBinop(kind: TypeKind) = {
-          val Pair(a, b) = stack.pop2
+          val (a, b) = stack.pop2
           checkType(a, kind)
           checkType(b, kind)
         }
@@ -269,11 +269,11 @@ abstract class Checkers {
           case LOAD_ARRAY_ITEM(kind) =>
             checkStack(2)
             stack.pop2 match {
-              case Pair(INT, ARRAY(elem)) =>
+              case (INT, ARRAY(elem)) =>
                 if (!(elem <:< kind))
                   typeError(kind, elem);
                 stack.push(elem);
-              case Pair(a, b) =>
+              case (a, b) =>
                 error(" expected and INT and a array reference, but " +
                     a + ", " + b + " found");
             }
@@ -302,12 +302,12 @@ abstract class Checkers {
          case STORE_ARRAY_ITEM(kind) =>
            checkStack(3);
            stack.pop3 match {
-             case Triple(k, INT, ARRAY(elem)) =>
+             case (k, INT, ARRAY(elem)) =>
                 if (!(k <:< kind))
                   typeError(kind, k);
                 if (!(k <:< elem))
                   typeError(elem, k);
-             case Triple(a, b, c) =>
+             case (a, b, c) =>
                 error(" expected and array reference, and int and " + kind +
                       " but " + a + ", " + b + ", " + c + " found");
            }
@@ -333,7 +333,7 @@ abstract class Checkers {
            } else {
              checkStack(2);
              stack.pop2 match {
-               case Pair(value, obj) =>
+               case (value, obj) =>
                  checkField(obj, field);
                  val fieldType = toTypeKind(field.tpe);
                  if (fieldType != SCALA_ALL_REF && !(value <:< fieldType))
@@ -378,7 +378,7 @@ abstract class Checkers {
 
              case Shift(op, kind) =>
                checkType(kind, BYTE, CHAR, SHORT, INT, LONG)
-               val Pair(a, b) = stack.pop2
+               val (a, b) = stack.pop2
                checkType(a, INT)
                checkType(b, kind)
                stack push kind
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index e60ea9a341..0abf72055f 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -484,14 +484,14 @@ abstract class GenICode extends SubComponent  {
           val kind = toTypeKind(tree.tpe)
           var handlers = for (val CaseDef(pat, _, body) <- catches.reverse)
             yield pat match {
-              case Typed(Ident(nme.WILDCARD), tpt) => Triple(tpt.tpe.symbol, kind, {
+              case Typed(Ident(nme.WILDCARD), tpt) => (tpt.tpe.symbol, kind, {
                 ctx: Context =>
                   ctx.bb.emit(DROP(REFERENCE(tpt.tpe.symbol)));
                   val ctx1 = genLoad(body, ctx, kind);
                   genLoad(finalizer, ctx1, UNIT);
                 })
 
-              case Ident(nme.WILDCARD) => Triple(definitions.ThrowableClass, kind, {
+              case Ident(nme.WILDCARD) => (definitions.ThrowableClass, kind, {
                 ctx: Context =>
                   ctx.bb.emit(DROP(REFERENCE(definitions.ThrowableClass)))
                   val ctx1 = genLoad(body, ctx, kind)
@@ -502,7 +502,7 @@ abstract class GenICode extends SubComponent  {
                 val exception = new Local(pat.symbol, toTypeKind(pat.symbol.tpe), false)
                 ctx.method.addLocal(exception);
 
-                Triple(pat.symbol.tpe.symbol, kind, {
+                (pat.symbol.tpe.symbol, kind, {
                   ctx: Context =>
                     ctx.bb.emit(STORE_LOCAL(exception), pat.pos);
                   val ctx1 = genLoad(body, ctx, kind);
@@ -511,7 +511,7 @@ abstract class GenICode extends SubComponent  {
             }
 
           if (finalizer != EmptyTree)
-            handlers = Triple(NoSymbol, kind, {
+            handlers = (NoSymbol, kind, {
               ctx: Context =>
                 val exception = new Local(ctx.method.symbol
                                           .newVariable(finalizer.pos, unit.fresh.newName("exc"))
@@ -747,7 +747,7 @@ abstract class GenICode extends SubComponent  {
                   ctx1
                 }, List(
 		  // tree.tpe / fun.tpe is object, which is no longer true after this transformation
-                  Triple(NoSymbol, expectedType, exhCtx => {
+                  (NoSymbol, expectedType, exhCtx => {
                   exhCtx.bb.emit(LOAD_LOCAL(monitor))
                   exhCtx.bb.emit(MONITOR_EXIT(), tree.pos)
                   exhCtx.bb.emit(THROW())
@@ -1277,9 +1277,9 @@ abstract class GenICode extends SubComponent  {
       def genComparisonOp(l: Tree, r: Tree, code: Int): Unit = {
         // special-case reference (in)equality test for null
         if (code == scalaPrimitives.ID || code == scalaPrimitives.NI) {
-          val expr: Tree = Pair(l, r) match {
-            case Pair(Literal(Constant(null)), expr) => expr
-            case Pair(expr, Literal(Constant(null))) => expr
+          val expr: Tree = (l, r) match {
+            case (Literal(Constant(null)), expr) => expr
+            case (expr, Literal(Constant(null))) => expr
             case _ => null
           }
           if (expr ne null) {
@@ -1397,15 +1397,15 @@ abstract class GenICode extends SubComponent  {
           local
       }
 
-      Pair(l, r) match {
+      (l, r) match {
         // null == expr -> expr eq null
-        case Pair(Literal(Constant(null)), expr) =>
+        case (Literal(Constant(null)), expr) =>
           val ctx1 = genLoad(expr, ctx, ANY_REF_CLASS)
           ctx1.bb.emit(CZJUMP(thenCtx.bb, elseCtx.bb, EQ, ANY_REF_CLASS))
           ctx1.bb.close
 
         // expr == null -> if(expr eq null) true else expr.equals(null)
-        case Pair(expr, Literal(Constant(null))) =>
+        case (expr, Literal(Constant(null))) =>
           val eqEqTempLocal = getTempLocal
           var ctx1 = genLoad(expr, ctx, ANY_REF_CLASS)
           ctx1.bb.emit(DUP(ANY_REF_CLASS))
@@ -1804,15 +1804,15 @@ abstract class GenICode extends SubComponent  {
        *
        * <code> ctx.Try( ctx => {
        *   ctx.bb.emit(...) // protected block
-       * }, Pair(definitions.ThrowableClass,
+       * }, (definitions.ThrowableClass,
        *   ctx => {
        *     ctx.bb.emit(...); // exception handler
-       *   }), Pair(AnotherExceptionClass,
+       *   }), (AnotherExceptionClass,
        *   ctx => {...
        *   } ))</code>
        */
       def Try(body: Context => Context,
-              handlers: List[Triple[Symbol, TypeKind, (Context => Context)]],
+              handlers: List[(Symbol, TypeKind, (Context => Context))],
               finalizer: Tree) = {
         val outerCtx = this.dup
         val afterCtx = outerCtx.newBlock
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala b/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala
index a780a233d5..9b08ac20e7 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala
@@ -73,7 +73,7 @@ abstract class ICodes extends AnyRef
          succ.predecessors.length == 1;
          succ.predecessors.head == b;
          !(m.exh.contains { (e: ExceptionHandler) => e.covers(b) && !e.covers(succ) }))
-        yield Pair(b, succ)
+        yield (b, succ)
     ()
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
index 654da7762e..f185c4c4b3 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
@@ -77,7 +77,7 @@ trait Members requires ICodes {
     /* This method applies the given function to each basic block. */
     def traverseFeedBack(f: (BasicBlock, HashMap[BasicBlock, Boolean])  => Unit) = {
       val visited : HashMap[BasicBlock, Boolean] = new HashMap;
-      visited ++= blocks.elements.map(x => Pair(x, false));
+      visited ++= blocks.elements.map(x => (x, false));
 
       var blockToVisit : List[BasicBlock] = startBlock::Nil;
 
@@ -243,7 +243,7 @@ trait Members requires ICodes {
     var end: Int = _
 
     /** PC-based ranges for this local variable's visibility */
-    var ranges: List[Pair[Int, Int]] = Nil
+    var ranges: List[(Int, Int)] = Nil
 
     override def equals(other: Any): Boolean = (
       other.isInstanceOf[Local] &&
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
index 00faaa19c8..1639b9fd12 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
@@ -52,12 +52,12 @@ trait TypeStacks requires ICodes {
     /** Return the topmost two values on the stack. It assumes the stack
      *  is large enough. Topmost element first.
      */
-    def pop2: Pair[TypeKind, TypeKind] = Pair(pop, pop)
+    def pop2: (TypeKind, TypeKind) = (pop, pop)
 
     /** Return the topmost three values on the stack. It assumes the stack
      *  is large enough. Topmost element first.
      */
-    def pop3: Triple[TypeKind, TypeKind, TypeKind] = Triple(pop, pop, pop)
+    def pop3: (TypeKind, TypeKind, TypeKind) = (pop, pop, pop)
 
     /** Drop the first n elements of the stack. */
     def pop(n: Int): Unit = types = types.drop(n)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 36a2307212..71ca0959bd 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -203,7 +203,7 @@ abstract class GenJVM extends SubComponent {
     }
 
     def addExceptionsAttribute(sym: Symbol): Unit = {
-      val Pair(excs, others) = sym.attributes.partition((a => a match {
+      val (excs, others) = sym.attributes.partition((a => a match {
         case AttrInfo(ThrowsAttr, _, _) => true
         case _ => false
       }))
@@ -289,7 +289,7 @@ abstract class GenJVM extends SubComponent {
           buf.putShort(cpool.addUtf8("value").toShort)
           emitElement(consts.head)
         }
-        for (val Pair(name, value) <- nvPairs) {
+        for (val (name, value) <- nvPairs) {
           buf.putShort(cpool.addUtf8(name.toString()).toShort)
           emitElement(value)
         }
@@ -583,9 +583,9 @@ abstract class GenJVM extends SubComponent {
        *  The intervals in the list have to be inclusive in the beginning and
        *  exclusive in the end: [start, end).
        */
-      def ranges(e: ExceptionHandler): List[Pair[Int, Int]] = {
+      def ranges(e: ExceptionHandler): List[(Int, Int)] = {
         var covered = e.covered
-        var ranges: List[Pair[Int, Int]] = Nil
+        var ranges: List[(Int, Int)] = Nil
         var start = -1
         var end = -1
 
@@ -593,7 +593,7 @@ abstract class GenJVM extends SubComponent {
           if (! (covered contains b) ) {
             if (start >= 0) { // we're inside a handler range
               end = labels(b).getAnchor()
-              ranges = Pair(start, end) :: ranges
+              ranges = (start, end) :: ranges
               start = -1
             }
           } else {
@@ -612,7 +612,7 @@ abstract class GenJVM extends SubComponent {
          * code!
          */
         if (start >= 0) {
-          ranges = Pair(start, jcode.getPC()) :: ranges;
+          ranges = (start, jcode.getPC()) :: ranges;
         }
 
         if (covered != Nil)
@@ -989,10 +989,10 @@ abstract class GenJVM extends SubComponent {
 
           case SCOPE_EXIT(lv) =>
             if (varsInBlock contains lv) {
-              lv.ranges = Pair(lv.start, jcode.getPC()) :: lv.ranges
+              lv.ranges = (lv.start, jcode.getPC()) :: lv.ranges
               varsInBlock -= lv
             } else if (b.varsInScope contains lv) {
-              lv.ranges = Pair(labels(b).getAnchor(), jcode.getPC()) :: lv.ranges
+              lv.ranges = (labels(b).getAnchor(), jcode.getPC()) :: lv.ranges
               b.varsInScope -= lv
             } else
               assert(false, "Illegal local var nesting: " + method)
@@ -1022,10 +1022,10 @@ abstract class GenJVM extends SubComponent {
 
       // local vars that survived this basic block
       for (val lv <- varsInBlock) {
-        lv.ranges = Pair(lv.start, jcode.getPC()) :: lv.ranges
+        lv.ranges = (lv.start, jcode.getPC()) :: lv.ranges
       }
       for (val lv <- b.varsInScope) {
-        lv.ranges = Pair(labels(b).getAnchor(), jcode.getPC()) :: lv.ranges
+        lv.ranges = (labels(b).getAnchor(), jcode.getPC()) :: lv.ranges
       }
     }
 
@@ -1101,67 +1101,67 @@ abstract class GenJVM extends SubComponent {
               abort("Unknown arithmetic primitive " + primitive)
           }
 
-        case Logical(op, kind) => Pair(op, kind) match {
-          case Pair(AND, LONG) =>
+        case Logical(op, kind) => (op, kind) match {
+          case (AND, LONG) =>
             jcode.emitLAND()
-          case Pair(AND, INT) =>
+          case (AND, INT) =>
             jcode.emitIAND()
-          case Pair(AND, _) =>
+          case (AND, _) =>
             jcode.emitIAND()
             if (kind != BOOL)
               jcode.emitT2T(javaType(INT), javaType(kind));
 
-          case Pair(OR, LONG) =>
+          case (OR, LONG) =>
             jcode.emitLOR()
-          case Pair(OR, INT) =>
+          case (OR, INT) =>
             jcode.emitIOR()
-          case Pair(OR, _) =>
+          case (OR, _) =>
             jcode.emitIOR()
             if (kind != BOOL)
               jcode.emitT2T(javaType(INT), javaType(kind));
 
-          case Pair(XOR, LONG) =>
+          case (XOR, LONG) =>
             jcode.emitLXOR()
-          case Pair(XOR, INT) =>
+          case (XOR, INT) =>
             jcode.emitIXOR()
-          case Pair(XOR, _) =>
+          case (XOR, _) =>
             jcode.emitIXOR()
             if (kind != BOOL)
               jcode.emitT2T(javaType(INT), javaType(kind));
         }
 
-        case Shift(op, kind) => Pair(op, kind) match {
-          case Pair(LSL, LONG) =>
+        case Shift(op, kind) => (op, kind) match {
+          case (LSL, LONG) =>
             jcode.emitLSHL()
-          case Pair(LSL, INT) =>
+          case (LSL, INT) =>
             jcode.emitISHL()
-          case Pair(LSL, _) =>
+          case (LSL, _) =>
             jcode.emitISHL()
             jcode.emitT2T(javaType(INT), javaType(kind))
 
-          case Pair(ASR, LONG) =>
+          case (ASR, LONG) =>
             jcode.emitLSHR()
-          case Pair(ASR, INT) =>
+          case (ASR, INT) =>
             jcode.emitISHR()
-          case Pair(ASR, _) =>
+          case (ASR, _) =>
             jcode.emitISHR()
             jcode.emitT2T(javaType(INT), javaType(kind))
 
-          case Pair(LSR, LONG) =>
+          case (LSR, LONG) =>
             jcode.emitLUSHR()
-          case Pair(LSR, INT) =>
+          case (LSR, INT) =>
             jcode.emitIUSHR()
-          case Pair(LSR, _) =>
+          case (LSR, _) =>
             jcode.emitIUSHR()
             jcode.emitT2T(javaType(INT), javaType(kind))
         }
 
-        case Comparison(op, kind) => Pair(op, kind) match {
-          case Pair(CMP, LONG)    => jcode.emitLCMP()
-          case Pair(CMPL, FLOAT)  => jcode.emitFCMPL()
-          case Pair(CMPG, FLOAT)  => jcode.emitFCMPG()
-          case Pair(CMPL, DOUBLE) => jcode.emitDCMPL()
-          case Pair(CMPG, DOUBLE) => jcode.emitDCMPL()
+        case Comparison(op, kind) => (op, kind) match {
+          case (CMP, LONG)    => jcode.emitLCMP()
+          case (CMPL, FLOAT)  => jcode.emitFCMPL()
+          case (CMPG, FLOAT)  => jcode.emitFCMPG()
+          case (CMPL, DOUBLE) => jcode.emitDCMPL()
+          case (CMPG, DOUBLE) => jcode.emitDCMPL()
         }
 
         case Conversion(src, dst) =>
@@ -1449,7 +1449,7 @@ abstract class GenJVM extends SubComponent {
 
             val index = indexOf(lv).asInstanceOf[Short]
             val tpe   = javaType(lv.kind).getSignature()
-            for (val Pair(start, end) <- lv.ranges) {
+            for (val (start, end) <- lv.ranges) {
               emitEntry(name, tpe, index, start.asInstanceOf[Short], (end - start).asInstanceOf[Short])
             }
         }
@@ -1463,10 +1463,10 @@ abstract class GenJVM extends SubComponent {
 
 
     /** Merge adjacent ranges. */
-    private def mergeEntries(ranges: List[Pair[Int, Int]]): List[Pair[Int, Int]] =
-      (ranges.foldLeft(Nil: List[Pair[Int, Int]]) { (collapsed: List[Pair[Int, Int]], p: Pair[Int, Int]) => Pair(collapsed, p) match {
-        case Pair(Nil, _) => List(p)
-        case Pair(Pair(s1, e1) :: rest, Pair(s2, e2)) if (e1 == s2) => Pair(s1, e2) :: rest
+    private def mergeEntries(ranges: List[(Int, Int)]): List[(Int, Int)] =
+      (ranges.foldLeft(Nil: List[(Int, Int)]) { (collapsed: List[(Int, Int)], p: (Int, Int)) => (collapsed, p) match {
+        case (Nil, _) => List(p)
+        case ((s1, e1) :: rest, (s2, e2)) if (e1 == s2) => (s1, e2) :: rest
         case _ => p :: collapsed
       }}).reverse
 
diff --git a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
index 3623d125ea..8ffd4da396 100644
--- a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
+++ b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
@@ -322,7 +322,7 @@ abstract class GenMSIL extends SubComponent {
       }
     }
 
-    def getAttributeArgs(consts: List[Constant], nvPairs: List[Pair[Name, Constant]]): Array[Byte] = {
+    def getAttributeArgs(consts: List[Constant], nvPairs: List[(Name, Constant)]): Array[Byte] = {
       val buf = ByteBuffer.allocate(2048) // FIXME: this may be not enough!
       buf.order(ByteOrder.LITTLE_ENDIAN)
       buf.putShort(1.toShort) // signature
@@ -384,7 +384,7 @@ abstract class GenMSIL extends SubComponent {
 
       consts foreach emitConst
       buf.putShort(nvPairs.length.toShort)
-      def emitNamedArg(nvPair: Pair[Name, Constant]): Unit = {
+      def emitNamedArg(nvPair: (Name, Constant)): Unit = {
 	// the named argument is a property of the attribute (it can't be a field, since
 	//  all fields in scala are private)
 	buf.put(0x54.toByte)
@@ -881,18 +881,18 @@ abstract class GenMSIL extends SubComponent {
 	     * returns: the output blocks plus an Option containing the possibly created
 	     * new block
 	     **/
-	    def adaptBlocks(blocks: List[BasicBlock], exh: ExceptionHandler): Pair[List[BasicBlock], Option[BasicBlock]] = {
+	    def adaptBlocks(blocks: List[BasicBlock], exh: ExceptionHandler): (List[BasicBlock], Option[BasicBlock]) = {
 	      def outsideTargets(block: BasicBlock, blocks: List[BasicBlock]) = {
 		block.successors.filter(scc => !blocks.contains(scc))
 	      }
 	      // get leaving blocks and their outside targets
-	      def leavingBlocks(blocks: List[BasicBlock]): List[Pair[BasicBlock, List[BasicBlock]]] = {
+	      def leavingBlocks(blocks: List[BasicBlock]): List[(BasicBlock, List[BasicBlock])] = {
 		for {val b <- blocks
 		     val t = outsideTargets(b, blocks)
-		     t.length != 0 } yield Pair(b, t)
+		     t.length != 0 } yield (b, t)
 	      }
 
-	      def replaceOutJumps(blocks: List[BasicBlock], leaving: List[Pair[BasicBlock, List[BasicBlock]]], exh: ExceptionHandler):Pair[List[BasicBlock], Option[BasicBlock]] = {
+	      def replaceOutJumps(blocks: List[BasicBlock], leaving: List[(BasicBlock, List[BasicBlock])], exh: ExceptionHandler): (List[BasicBlock], Option[BasicBlock]) = {
 		def replaceJump(block: BasicBlock, from: BasicBlock, to: BasicBlock) = block.lastInstruction match {
 		  case JUMP(where) =>
 		    assert(from == where)
@@ -926,12 +926,12 @@ abstract class GenMSIL extends SubComponent {
 		  val target = p._2(0) // the elemets of p._2 are all the same, checked before
 		  replaceJump(lBlock, target, jumpOutBlock)
 		})
-		Pair(blocks ::: List(jumpOutBlock), Some(jumpOutBlock))
+		(blocks ::: List(jumpOutBlock), Some(jumpOutBlock))
 	      }
 
 	      val leaving = leavingBlocks(blocks)
 	      if (leaving.length == 0)
-		Pair(blocks, None)
+		(blocks, None)
 	      else if (leaving.length == 1) {
 		val outside = leaving(0)._2
 		assert(outside.forall(b => b == outside(0)), "exception-block leaving to multiple targets")
@@ -940,7 +940,7 @@ abstract class GenMSIL extends SubComponent {
 		else
 		  assert(firstBlockAfter(exh) == outside(0), "try/catch leaving to multiple targets: " + firstBlockAfter(exh) + ", new: " + outside(0))
 		val last = leaving(0)._1
-		Pair(blocks.diff(List(last)) ::: List(last), None)
+		(blocks.diff(List(last)) ::: List(last), None)
 	      } else {
 		val outside = leaving.flatMap(p => p._2)
 		assert(outside.forall(b => b == outside(0)), "exception-block leaving to multiple targets")
@@ -968,7 +968,7 @@ abstract class GenMSIL extends SubComponent {
 	    var singleAffectedHandler: ExceptionHandler = affectedHandlers(0) // List[ExceptionHandler] = Nil
 	    var exceptionBlock: Option[ExceptionBlock] = None
 	    affectedHandlers.foreach(h1 => {
-	      val Pair(adaptedBlocks, newBlock) = adaptBlocks(blocksToPut.intersect(h1.blocks), singleAffectedHandler)
+	      val (adaptedBlocks, newBlock) = adaptBlocks(blocksToPut.intersect(h1.blocks), singleAffectedHandler)
 	      newBlock match {
 		case Some(block) =>
 		  blocksToPut = blocksToPut ::: List(block)
@@ -986,7 +986,7 @@ abstract class GenMSIL extends SubComponent {
 		  val excBlock = currentBlock.addExceptionBlock(singleAffectedHandler)
 		  exceptionBlock = Some(excBlock)
 
-		  val Pair(tryBlocks, newBlock) = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.covered), singleAffectedHandler)
+		  val (tryBlocks, newBlock) = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.covered), singleAffectedHandler)
 
 		  newBlock match {
 		    case Some(block) =>
@@ -998,7 +998,7 @@ abstract class GenMSIL extends SubComponent {
 		  addBlocks(tryBlocks)
 
 		  if (singleAffectedHandler.finalizer != null && singleAffectedHandler.finalizer != NoFinalizer) {
-		    val Pair(blocks0, newBlock) = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.finalizer.blocks), singleAffectedHandler)
+		    val (blocks0, newBlock) = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.finalizer.blocks), singleAffectedHandler)
 		    newBlock match {
 		      case Some(block) =>
 			blocksToPut = blocksToPut ::: List(block)
@@ -1379,13 +1379,13 @@ abstract class GenMSIL extends SubComponent {
               }
 
 	      // method: implicit view(FunctionX[PType0, PType1, ...,PTypeN, ResType]):DelegateType
-	      val Triple(isDelegateView, paramType, resType) = atPhase(currentRun.typerPhase){
+	      val (isDelegateView, paramType, resType) = atPhase(currentRun.typerPhase){
 		msym.tpe match {
 		  case MethodType(parameterTypes, resultType)
 		  if (parameterTypes.length == 1 && msym.name == nme.view_) =>
 		    val isDel = definitions.isCorrespondingDelegate(resultType, parameterTypes(0))
-		    Triple(isDel, parameterTypes(0), resultType)
-		  case _ => Triple(false, null, null)
+		    (isDel, parameterTypes(0), resultType)
+		  case _ => (false, null, null)
 		}
 	      }
 	      if (doEmit && isDelegateView) {
@@ -2206,8 +2206,8 @@ abstract class GenMSIL extends SubComponent {
 
 
       // create the static caller method and the delegate object
-      val Pair(paramTypes, returnType) = delegateType.member(nme.apply).tpe match {
-	case MethodType(delParams, delReturn) => Pair(delParams, delReturn)
+      val (paramTypes, returnType) = delegateType.member(nme.apply).tpe match {
+	case MethodType(delParams, delReturn) => (delParams, delReturn)
 	case _ => abort("not a delegate type: "  + delegateType)
       }
       val caller: MethodBuilder = delegateCallers.DefineMethod(
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
index 354bf647a8..8b7fa9a3f3 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
@@ -53,20 +53,20 @@ abstract class ClosureElimination extends SubComponent {
 
     /** A simple peephole optimizer. */
     val peephole = new PeepholeOpt( (i1, i2) =>
-    	Pair(i1, i2) match {
-        case Pair(CONSTANT(c), DROP(_)) =>
+    	(i1, i2) match {
+        case (CONSTANT(c), DROP(_)) =>
           if (c.tag == UnitTag)
             Some(List(i2))
           else
             Some(Nil);
 
-        case Pair(LOAD_LOCAL(x), STORE_LOCAL(y)) =>
+        case (LOAD_LOCAL(x), STORE_LOCAL(y)) =>
         	if (x eq y) Some(Nil) else None
 
-        case Pair(LOAD_LOCAL(_), DROP(_)) =>
+        case (LOAD_LOCAL(_), DROP(_)) =>
           Some(Nil)
 
-        case Pair(LOAD_FIELD(sym, isStatic), DROP(_)) =>
+        case (LOAD_FIELD(sym, isStatic), DROP(_)) =>
         	if (isStatic)
             Some(Nil)
           else
diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
index 8b987cdf79..152d33354e 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
@@ -51,7 +51,7 @@ abstract class DeadCodeElimination extends SubComponent {
       a.run;
 
       for (val bb <- m.code.blocks.toList;
-           val Pair(i, pos) <- bb.toList.zipWithIndex.reverse) {
+           val (i, pos) <- bb.toList.zipWithIndex.reverse) {
         var live = a.out(bb);
 
         i match {
diff --git a/src/compiler/scala/tools/nsc/doc/DocGenerator.scala b/src/compiler/scala/tools/nsc/doc/DocGenerator.scala
index 3944e1444d..744e9f9a45 100644
--- a/src/compiler/scala/tools/nsc/doc/DocGenerator.scala
+++ b/src/compiler/scala/tools/nsc/doc/DocGenerator.scala
@@ -105,7 +105,7 @@ abstract class DocGenerator extends Models {
         val n = tpe.typeArgs.length
         if (n > 0) {
           if (definitions.isFunctionType(tpe)) {
-            val Pair(ts, List(r)) = tpe.typeArgs.splitAt(n-1)
+            val (ts, List(r)) = tpe.typeArgs.splitAt(n-1)
             Text("(") ++ (
                 if (ts.isEmpty) NodeSeq.Empty
                 else
@@ -318,7 +318,7 @@ abstract class DocGenerator extends Models {
           if (!args.isEmpty)
             buf.append(args.map(.escapedStringValue).mkString("(", ",", ")"))
           if (!nvPairs.isEmpty)
-            for (val Pair(Pair(name, value), index) <- nvPairs.zipWithIndex) {
+            for (val ((name, value), index) <- nvPairs.zipWithIndex) {
               if (index > 0)
                 buf.append(", ")
               buf.append(name).append(" = ").append(value)
@@ -509,9 +509,9 @@ abstract class DocGenerator extends Models {
 
     def fullComment(mmbr: HasTree): NodeSeq = {
       val sym = mmbr.tree.symbol
-      val Pair(sym1, kind1) =
-        if (sym.isPrimaryConstructor) Pair(sym.owner, CONSTRUCTOR)
-        else Pair(sym, if (sym.isConstructor) DEF else kindOf(mmbr.tree))
+      val (sym1, kind1) =
+        if (sym.isPrimaryConstructor) (sym.owner, CONSTRUCTOR)
+        else (sym, if (sym.isConstructor) DEF else kindOf(mmbr.tree))
       comments.get(sym1) match {
         case Some(text) => comment(text, false, kind1)
         case None => NodeSeq.Empty
@@ -739,8 +739,8 @@ abstract class DocGenerator extends Models {
         val decls = sym.tpe.decls.toList
         //compute table members once for each relevant kind
         val tables = for (val k <- kinds.keys.toList)
-                     yield Pair(k, decls filter kinds(k))
-        for (val Pair(k, members) <- tables; !members.isEmpty) yield
+                     yield (k, decls filter kinds(k))
+        for (val (k, members) <- tables; !members.isEmpty) yield
           <table cellpadding="3" class="member" summary="">
             <tr>
               <td colspan="2" class="title">{k} Summary</td>
@@ -1202,7 +1202,7 @@ abstract class DocGenerator extends Models {
     assert(comment0 endsWith JDOC_END)
     comment0 = comment0.substring(0, comment0.length() - JDOC_END.length())
     val buf = new StringBuilder
-    type AttrDescr = Triple[String, String, StringBuilder]
+    type AttrDescr = (String, String, StringBuilder)
     val attributes = new ListBuffer[AttrDescr]
     var attr: AttrDescr = null
     val tok = new StringTokenizer(comment0, LINE_SEPARATOR)
@@ -1210,12 +1210,12 @@ abstract class DocGenerator extends Models {
       val s = tok.nextToken.replaceFirst("\\p{Space}?\\*", "")
       val mat1 = pat1.matcher(s)
       if (mat1.matches) {
-        attr = Triple(mat1.group(1), null, new StringBuilder(mat1.group(2)))
+        attr = (mat1.group(1), null, new StringBuilder(mat1.group(2)))
         if (kind != CONSTRUCTOR) attributes += attr
       } else {
         val mat2 = pat2.matcher(s)
         if (mat2.matches) {
-          attr = Triple(mat2.group(1), mat2.group(2), new StringBuilder(mat2.group(3)))
+          attr = (mat2.group(1), mat2.group(2), new StringBuilder(mat2.group(3)))
           if (kind != CLASS) attributes += attr
         } else if (attr ne null)
           attr._3.append(s + LINE_SEPARATOR)
@@ -1223,15 +1223,15 @@ abstract class DocGenerator extends Models {
           buf.append(s + LINE_SEPARATOR)
       }
     }
-    val exceptions = new TreeMap[String, Pair[Symbol, String]] +
+    val exceptions = new TreeMap[String, (Symbol, String)] +
       "Predef.IndexOutOfBoundsException" ->
-        Pair(definitions.PredefModule, "IndexOutOfBoundsException") +
+        (definitions.PredefModule, "IndexOutOfBoundsException") +
       "Predef.NoSuchElementException" ->
-        Pair(definitions.PredefModule, "NoSuchElementException") +
+        (definitions.PredefModule, "NoSuchElementException") +
       "Predef.NullPointerException" ->
-        Pair(definitions.PredefModule, "NullPointerException") +
+        (definitions.PredefModule, "NullPointerException") +
       "Predef.UnsupportedOperationException" ->
-        Pair(definitions.PredefModule, "UnsupportedOperationException")
+        (definitions.PredefModule, "UnsupportedOperationException")
     val body = buf.toString
     if (isShort)
       <span>{parse(body)}</span>;
@@ -1247,7 +1247,7 @@ abstract class DocGenerator extends Models {
           else if (attr._1.equals("throws"))
             <code>{ exceptions.get(attr._2) match {
               case Some(p) =>
-                val Pair(sym, s) = p
+                val (sym, s) = p
                 val path = "../" //todo: fix path
                 val href = path + sym.fullNameString('/') +
                   (if (sym.isModule || sym.isModuleClass) NAME_SUFFIX_OBJECT else "") +
diff --git a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
index 75ab5623fd..bed3aed1fe 100644
--- a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
+++ b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala
@@ -1044,7 +1044,7 @@ print()
       //Console.println("sel:"+selector+" last"+lastSelector+" - "+(selector == lastSelector))
         val next = _h.next;
         //res = And(mkNegate(res), toTree(node.or, selector));
-        val Triple(doOptimize, coveredCases, remainingCases) = _h.optimize1()
+        val (doOptimize, coveredCases, remainingCases) = _h.optimize1()
         if(!remainingCases.isEmpty && doCheckExhaustive) {
           carryCovered = carryCovered ++ coveredCases // ??
           if(next != null && next.or.and.isUnguardedBody) {
@@ -1296,12 +1296,12 @@ print()
               toTree(node.or, selector.duplicate))
 
           case ConstrPat(casted) =>
-            def outerAlwaysEqual(left: Type, right: Type) = Pair(left,right) match {
-              case Pair(TypeRef(lprefix, _,_), TypeRef(rprefix,_,_)) if lprefix =:= rprefix =>
+            def outerAlwaysEqual(left: Type, right: Type) = (left,right) match {
+              case (TypeRef(lprefix, _,_), TypeRef(rprefix,_,_)) if lprefix =:= rprefix =>
                 true
               case _ =>
                 if(settings.XprintOuterMatches.value)
-                  cunit.warning(node.pos, "can't be sure statically that these outers are equal:"+Pair(left,right).toString)
+                  cunit.warning(node.pos, "can't be sure statically that these outers are equal:"+(left,right).toString)
                 false
             }
 
diff --git a/src/compiler/scala/tools/nsc/matching/PatternNodes.scala b/src/compiler/scala/tools/nsc/matching/PatternNodes.scala
index b436dccefb..ad1a32674f 100644
--- a/src/compiler/scala/tools/nsc/matching/PatternNodes.scala
+++ b/src/compiler/scala/tools/nsc/matching/PatternNodes.scala
@@ -327,16 +327,16 @@ trait PatternNodes requires transform.ExplicitOuter {
     /** returns true if this tree is optimizable
      *  throws a warning if is not exhaustive
      */
-    def optimize1(): Triple[Boolean, SymSet, SymSet] = {
+    def optimize1(): (Boolean, SymSet, SymSet) = {
       import symtab.Flags
 
       val selType = this.getTpe
 
       if (!isSubType(selType, definitions.ScalaObjectClass.tpe))
-        return Triple(false, null, emptySymbolSet)
+        return (false, null, emptySymbolSet)
 
       if(this.or eq null)
-        return Triple(false, null, emptySymbolSet)  // only case _
+        return (false, null, emptySymbolSet)  // only case _
 
       def checkExCoverage(tpesym:Symbol): SymSet =
         if(!tpesym.hasFlag(Flags.SEALED)) emptySymbolSet
@@ -409,7 +409,7 @@ trait PatternNodes requires transform.ExplicitOuter {
       }
 
       this.forEachBranch(traverse)
-      return Triple(res && (cases > 2), coveredCases, remainingCases)
+      return (res && (cases > 2), coveredCases, remainingCases)
     } // def optimize
 
   }
diff --git a/src/compiler/scala/tools/nsc/matching/TransMatcher.scala b/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
index 433a33f3a7..8fa8bb6437 100644
--- a/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
+++ b/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
@@ -163,7 +163,7 @@ with PatternMatchers */ {
      *
      *  case    .. () .. => val x = Nil; body
      */
-    def isRegular(pats: List[CaseDef]): Pair[List[CaseDef],Boolean] = {
+    def isRegular(pats: List[CaseDef]): (List[CaseDef],Boolean) = {
       var existsReg = false
       var isReg = false
       var nilVars: List[Symbol] = null
@@ -273,7 +273,7 @@ with PatternMatchers */ {
 
         res = copy.CaseDef(cdef, newt, cdef.guard, nbody) :: res
       }
-      Pair(res.reverse, existsReg)
+      (res.reverse, existsReg)
     }
 
     /** handles all translation of pattern matching
@@ -284,7 +284,7 @@ with PatternMatchers */ {
       //
       // 1. is there a regular pattern?
 
-      val Pair(cases, containsReg) = isRegular(ocases)
+      val (cases, containsReg) = isRegular(ocases)
 
       // @todo: remove unused variables
 
diff --git a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
index 52934c95fc..a61e9ae549 100644
--- a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
+++ b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
@@ -67,7 +67,7 @@ class SemanticTokens(val compiler: Global) {
   }
 
   abstract class Actual extends HasNext with HasPrev {
-    def convertToGap: Pair[Int, Actual]  = {
+    def convertToGap: (Int, Actual)  = {
       val nextGap = next.isInstanceOf[Gap]
       val prevGap = prev.isInstanceOf[Gap]
 
@@ -83,21 +83,21 @@ class SemanticTokens(val compiler: Global) {
           gap.next0 = next
           next.prev0 = gap
         }
-        new Pair(ret, gap)
+        (ret, gap)
       }
       else if (nextGap) {
         val gap = next.asInstanceOf[Gap]
         gap.setLength(gap.length + length)
         gap.prev0 = prev
         prev.next0 = gap
-        new Pair(0, gap)
+        (0, gap)
       }
       else {
         prev.next0 = next
         next.prev0 = prev
         val gap = new Gap(prev)
         gap.setLength(length)
-        new Pair(0, gap)
+        (0, gap)
       }
 
     }
@@ -122,7 +122,7 @@ class SemanticTokens(val compiler: Global) {
     def setLength(length1: Int) = length0 = length1
 
     // already gap
-    override def convertToGap: Pair[Int,Actual] = new Pair(0, this)
+    override def convertToGap: (Int,Actual) = (0, this)
   }
 
   def Process(unit: CompilationUnit) = new Process(unit)
diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala
index 7f2f08a495..8467bcb302 100644
--- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala
@@ -45,7 +45,7 @@ trait Definitions requires SymbolTable {
     var DelegateClass: Symbol = _ // System.MulticastDelegate
     var Delegate_scalaCallers: List[Symbol] = List()
     // Symbol -> (Symbol, Type): scalaCaller -> (scalaMethodSym, DelegateType)
-    // var Delegate_scalaCallerInfos: HashMap[Symbol, Pair[Symbol, Type]] = _
+    // var Delegate_scalaCallerInfos: HashMap[Symbol, (Symbol, Type)] = _
     var Delegate_scalaCallerTargets: HashMap[Symbol, Symbol] = _
 
     // the scala value classes
@@ -921,7 +921,7 @@ trait Definitions requires SymbolTable {
 
     // def addScalaCallerInfo(scalaCaller: Symbol, methSym: Symbol, delType: Type) = {
     // assert(Delegate_scalaCallers contains scalaCaller)
-    // Delegate_scalaCallerInfos += scalaCaller -> Pair(methSym, delType)
+    // Delegate_scalaCallerInfos += scalaCaller -> (methSym, delType)
     // }
 
     def addScalaCallerInfo(scalaCaller: Symbol, methSym: Symbol) = {
diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
index a621cab408..8ab60f8459 100644
--- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala
+++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
@@ -89,6 +89,8 @@ trait StdNames requires SymbolTable {
     def isLocalName(name: Name) = name.endsWith(LOCAL_SUFFIX)
     def isSetterName(name: Name) = name.endsWith(SETTER_SUFFIX)
     def isLocalDummyName(name: Name) = name.startsWith(LOCALDUMMY_PREFIX)
+    def isOpAssignmentName(name: Name) =
+      name.endsWith(nme.EQL) && name != nme.EQEQ && !name.endsWith(nme.USCOREEQL)
 
     /** If `name' is an expandedName, the original name. Otherwise `name' itself.
      *  @see Symbol.expandedName
@@ -182,6 +184,8 @@ trait StdNames requires SymbolTable {
     val AMPAMP = encode("&&")
     val COLONCOLON = encode("::")
     val PERCENT = encode("%")
+    val EQL = encode("=")
+    val USCOREEQL = encode("_=")
 
     val Nothing = newTermName("Nothing")
     val Null = newTermName("Null")
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
index 8fe03975f3..25fc9448d3 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
@@ -174,7 +174,7 @@ abstract class SymbolLoaders {
       }
 
       // do classes first
-      for (val Pair(name, file) <- classes.elements) {
+      for (val (name, file) <- classes.elements) {
         val loader = if (!file.isSourceFile) {
           new ClassfileLoader(file.classFile, file.sourceFile, file.sourcePath)
         } else {
@@ -184,7 +184,7 @@ abstract class SymbolLoaders {
         enterClassAndModule(name, loader)
       }
 
-      for (val Pair(name, file) <- packages.elements)
+      for (val (name, file) <- packages.elements)
         enterPackage(name, newPackageLoader(file))
     }
   }
@@ -228,7 +228,7 @@ abstract class SymbolLoaders {
       }
 
       // import the CLR types contained in the package (namespace)
-      for (val Pair(name, typ) <- types.elements) {
+      for (val (name, typ) <- types.elements) {
         assert(namespace == typ.Namespace, typ.FullName);
 
         if (typ.IsDefined(clrTypes.SCALA_SYMTAB_ATTR, false)) {
diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala
index 66d1913608..f0b18dc5ab 100644
--- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala
@@ -1309,13 +1309,13 @@ trait Symbols requires SymbolTable {
     def cloneSymbolImpl(owner: Symbol): Symbol = throw new Error()
   }
 
-  case class AttrInfo(atp: Type, args: List[Constant], assocs: List[Pair[Name, Constant]]) {
+  case class AttrInfo(atp: Type, args: List[Constant], assocs: List[(Name, Constant)]) {
     override def toString: String =
       atp +
       (if (args.isEmpty) ""
        else args.mkString("(", ", ", ")")) +
       (if (assocs.isEmpty) ""
-       else (assocs map { case Pair(x, y) => x+" = "+y } mkString ("{", ", ", "}")))
+       else (assocs map { case (x, y) => x+" = "+y } mkString ("{", ", ", "}")))
   }
 
   def cloneSymbols(syms: List[Symbol]): List[Symbol] = {
diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala
index 163683401a..4e887d93ed 100644
--- a/src/compiler/scala/tools/nsc/symtab/Types.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Types.scala
@@ -918,7 +918,7 @@ trait Types requires SymbolTable {
           def apply(tp: Type): Type = {
             tp match {
               case TypeRef(_, sym, args) =>
-                for (val Pair(tparam1, arg) <- sym.info.typeParams zip args)
+                for (val (tparam1, arg) <- sym.info.typeParams zip args)
                   if (arg contains tparam) {
                     addRef(NonExpansive, tparam, tparam1)
                     if (arg.symbol != tparam) addRef(Expansive, tparam, tparam1)
@@ -943,7 +943,7 @@ trait Types requires SymbolTable {
       val lastRefs = Array(refs(0), refs(1))
       state = Initialized
       var change = false
-      for (val Pair(from, targets) <- refs(NonExpansive).elements)
+      for (val (from, targets) <- refs(NonExpansive).elements)
         for (val target <- targets) {
           var thatInfo = classInfo(target)
           if (thatInfo.state != Initialized)
@@ -951,7 +951,7 @@ trait Types requires SymbolTable {
           addRefs(NonExpansive, from, thatInfo.getRefs(NonExpansive, target))
           addRefs(Expansive, from, thatInfo.getRefs(Expansive, target))
         }
-      for (val Pair(from, targets) <- refs(Expansive).elements)
+      for (val (from, targets) <- refs(Expansive).elements)
         for (val target <- targets) {
           var thatInfo = classInfo(target)
           addRefs(Expansive, from, thatInfo.getRefs(NonExpansive, target))
@@ -2012,40 +2012,40 @@ trait Types requires SymbolTable {
    *             equivalent types.
    */
   def isSameType(tp1: Type, tp2: Type): boolean = {
-    Pair(tp1, tp2) match {
-      case Pair(ErrorType, _) => true
-      case Pair(WildcardType, _) => true
-      case Pair(_, ErrorType) => true
-      case Pair(_, WildcardType) => true
-
-      case Pair(NoType, _) => false
-      case Pair(NoPrefix, _) => tp2.symbol.isPackageClass
-      case Pair(_, NoType) => false
-      case Pair(_, NoPrefix) => tp1.symbol.isPackageClass
-
-      case Pair(ThisType(sym1), ThisType(sym2))
+    (tp1, tp2) match {
+      case (ErrorType, _) => true
+      case (WildcardType, _) => true
+      case (_, ErrorType) => true
+      case (_, WildcardType) => true
+
+      case (NoType, _) => false
+      case (NoPrefix, _) => tp2.symbol.isPackageClass
+      case (_, NoType) => false
+      case (_, NoPrefix) => tp1.symbol.isPackageClass
+
+      case (ThisType(sym1), ThisType(sym2))
       if (sym1 == sym2) =>
         true
-      case Pair(SingleType(pre1, sym1), SingleType(pre2, sym2))
+      case (SingleType(pre1, sym1), SingleType(pre2, sym2))
       if ((sym1 == sym2) && (pre1 =:= pre2)) =>
         true
 /*
-      case Pair(SingleType(pre1, sym1), ThisType(sym2))
+      case (SingleType(pre1, sym1), ThisType(sym2))
       if (sym1.isModule &&
           sym1.moduleClass == sym2 &&
           pre1 =:= sym2.owner.thisType) =>
         true
-      case Pair(ThisType(sym1), SingleType(pre2, sym2))
+      case (ThisType(sym1), SingleType(pre2, sym2))
       if (sym2.isModule &&
           sym2.moduleClass == sym1 &&
           pre2 =:= sym1.owner.thisType) =>
         true
 */
-      case Pair(ConstantType(value1), ConstantType(value2)) =>
+      case (ConstantType(value1), ConstantType(value2)) =>
         value1 == value2
-      case Pair(TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) =>
+      case (TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) =>
         sym1 == sym2 && (phase.erasedTypes || pre1 =:= pre2) && isSameTypes(args1, args2)
-      case Pair(RefinedType(parents1, ref1), RefinedType(parents2, ref2)) =>
+      case (RefinedType(parents1, ref1), RefinedType(parents2, ref2)) =>
         def isSubScope(s1: Scope, s2: Scope): boolean = s2.toList.forall {
           sym2 =>
             val sym1 = s1.lookup(sym2.name)
@@ -2054,31 +2054,31 @@ trait Types requires SymbolTable {
         }
         //Console.println("is same? " + tp1 + " " + tp2 + " " + tp1.symbol.owner + " " + tp2.symbol.owner)//DEBUG
         isSameTypes(parents1, parents2) && isSubScope(ref1, ref2) && isSubScope(ref2, ref1)
-      case Pair(MethodType(pts1, res1), MethodType(pts2, res2)) =>
+      case (MethodType(pts1, res1), MethodType(pts2, res2)) =>
         (pts1.length == pts2.length &&
          isSameTypes(pts1, pts2) &&
          res1 =:= res2 &&
          tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType])
-      case Pair(PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
+      case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
         (tparams1.length == tparams2.length &&
          List.forall2(tparams1, tparams2)
            ((p1, p2) => p1.info =:= p2.info.substSym(tparams2, tparams1)) &&
          res1 =:= res2.substSym(tparams2, tparams1))
-      case Pair(TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
+      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
         lo1 =:= lo2 && hi1 =:= hi2
-      case Pair(BoundedWildcardType(bounds), _) =>
+      case (BoundedWildcardType(bounds), _) =>
         bounds containsType tp2
-      case Pair(_, BoundedWildcardType(bounds)) =>
+      case (_, BoundedWildcardType(bounds)) =>
         bounds containsType tp1
-      case Pair(TypeVar(_, constr1), _) =>
+      case (TypeVar(_, constr1), _) =>
         if (constr1.inst != NoType) constr1.inst =:= tp2
         else constr1 instantiate (wildcardToTypeVarMap(tp2))
-      case Pair(_, TypeVar(_, constr2)) =>
+      case (_, TypeVar(_, constr2)) =>
         if (constr2.inst != NoType) tp1 =:= constr2.inst
         else constr2 instantiate (wildcardToTypeVarMap(tp1))
-      case Pair(AttributedType(_,atp), _) =>
+      case (AttributedType(_,atp), _) =>
         isSameType(atp, tp2)
-      case Pair(_, AttributedType(_,atp)) =>
+      case (_, AttributedType(_,atp)) =>
         isSameType(tp1, atp)
       case _ =>
         if (tp1.isStable && tp2.isStable) {
@@ -2127,24 +2127,24 @@ trait Types requires SymbolTable {
    *  @return    ...
    */
   def isSubType0(tp1: Type, tp2: Type): boolean = {
-    Pair(tp1, tp2) match {
-      case Pair(ErrorType, _)    => true
-      case Pair(WildcardType, _) => true
-      case Pair(_, ErrorType)    => true
-      case Pair(_, WildcardType) => true
-
-      case Pair(NoType, _)   => false
-      case Pair(NoPrefix, _) => tp2.symbol.isPackageClass
-      case Pair(_, NoType)   => false
-      case Pair(_, NoPrefix) => tp1.symbol.isPackageClass
-
-      case Pair(ThisType(_), ThisType(_))           => tp1 =:= tp2
-      case Pair(ThisType(_), SingleType(_, _))      => tp1 =:= tp2
-      case Pair(SingleType(_, _), ThisType(_))      => tp1 =:= tp2
-      case Pair(SingleType(_, _), SingleType(_, _)) => tp1 =:= tp2
-      case Pair(ConstantType(_), ConstantType(_))   => tp1 =:= tp2
-
-      case Pair(TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) =>
+    (tp1, tp2) match {
+      case (ErrorType, _)    => true
+      case (WildcardType, _) => true
+      case (_, ErrorType)    => true
+      case (_, WildcardType) => true
+
+      case (NoType, _)   => false
+      case (NoPrefix, _) => tp2.symbol.isPackageClass
+      case (_, NoType)   => false
+      case (_, NoPrefix) => tp1.symbol.isPackageClass
+
+      case (ThisType(_), ThisType(_))           => tp1 =:= tp2
+      case (ThisType(_), SingleType(_, _))      => tp1 =:= tp2
+      case (SingleType(_, _), ThisType(_))      => tp1 =:= tp2
+      case (SingleType(_, _), SingleType(_, _)) => tp1 =:= tp2
+      case (ConstantType(_), ConstantType(_))   => tp1 =:= tp2
+
+      case (TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) =>
         //Console.println("isSubType " + tp1 + " " + tp2);//DEBUG
         def isSubArgs(tps1: List[Type], tps2: List[Type],
                       tparams: List[Symbol]): boolean = (
@@ -2172,50 +2172,50 @@ trait Types requires SymbolTable {
          ||
          // Console.println("last chance " + sym1 + " " + sym2 + " " + sym2.isClass + " " (sym2 isSubClass ObjectClass))
          sym1 == AllRefClass && sym2.isClass && sym2 != AllClass && (sym2 isSubClass ObjectClass))
-      case Pair(MethodType(pts1, res1), MethodType(pts2, res2)) =>
+      case (MethodType(pts1, res1), MethodType(pts2, res2)) =>
         (pts1.length == pts2.length &&
          matchingParams(pts1, pts2, tp2.isInstanceOf[JavaMethodType]) &&
          (res1 <:< res2) &&
          tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType])
-      case Pair(PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
+      case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
         (tparams1.length == tparams2.length &&
          List.forall2(tparams1, tparams2)
            ((p1, p2) => p2.info.substSym(tparams2, tparams1) <:< p1.info) &&
          res1 <:< res2.substSym(tparams2, tparams1))
-      case Pair(TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
+      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
         lo2 <:< lo1 && hi1 <:< hi2
-      case Pair(BoundedWildcardType(bounds), _) =>
+      case (BoundedWildcardType(bounds), _) =>
         bounds.lo <:< tp2
-      case Pair(_, BoundedWildcardType(bounds)) =>
+      case (_, BoundedWildcardType(bounds)) =>
         tp1 <:< bounds.hi
-      case Pair(_, TypeVar(_, constr2)) =>
+      case (_, TypeVar(_, constr2)) =>
         if (constr2.inst != NoType) tp1 <:< constr2.inst
         else { constr2.lobounds = tp1 :: constr2.lobounds; true }
-      case Pair(TypeVar(_, constr1), _) =>
+      case (TypeVar(_, constr1), _) =>
         if (constr1.inst != NoType) constr1.inst <:< tp2
         else { constr1.hibounds = tp2 :: constr1.hibounds; true }
-      case Pair(AttributedType(_,atp1), _) =>
+      case (AttributedType(_,atp1), _) =>
         atp1 <:< tp2
-      case Pair(_, AttributedType(_,atp2)) =>
+      case (_, AttributedType(_,atp2)) =>
         tp1 <:< atp2
-      case Pair(_, TypeRef(pre2, sym2, args2))
+      case (_, TypeRef(pre2, sym2, args2))
       if sym2.isAbstractType && !(tp2 =:= tp2.bounds.lo) && (tp1 <:< tp2.bounds.lo) =>
         true
-      case Pair(_, RefinedType(parents2, ref2)) =>
+      case (_, RefinedType(parents2, ref2)) =>
         (parents2 forall tp1.<:<) && (ref2.toList forall tp1.specializes) &&
         (!parents2.exists(.symbol.isAbstractType) || tp1.symbol != AllRefClass)
-      case Pair(RefinedType(parents1, ref1), _) =>
+      case (RefinedType(parents1, ref1), _) =>
         parents1 exists (.<:<(tp2))
       /* todo: replace following with
-      case Pair(ThisType(_), _)
+      case (ThisType(_), _)
          | {SingleType(_, _), _}
          | {ConstantType(_), _} =>
          once patern matching bug is fixed */
-      case Pair(ThisType(_), _) => tp1.singleDeref <:< tp2
-      case Pair(SingleType(_, _), _) => tp1.singleDeref <:< tp2
-      case Pair(ConstantType(_), _) => tp1.singleDeref <:< tp2
+      case (ThisType(_), _) => tp1.singleDeref <:< tp2
+      case (SingleType(_, _), _) => tp1.singleDeref <:< tp2
+      case (ConstantType(_), _) => tp1.singleDeref <:< tp2
 
-      case Pair(TypeRef(pre1, sym1, args1), _) =>
+      case (TypeRef(pre1, sym1, args1), _) =>
         (sym1 == AllClass && tp2 <:< AnyClass.tpe
          ||
          sym1 == AllRefClass && tp2.isInstanceOf[SingletonType] && (tp1 <:< tp2.widen))
@@ -2260,21 +2260,21 @@ trait Types requires SymbolTable {
   }
 
   /** A function implementing <code>tp1</code> matches <code>tp2</code> */
-  private def matchesType(tp1: Type, tp2: Type): boolean = Pair(tp1, tp2) match {
-    case Pair(MethodType(pts1, res1), MethodType(pts2, res2)) =>
+  private def matchesType(tp1: Type, tp2: Type): boolean = (tp1, tp2) match {
+    case (MethodType(pts1, res1), MethodType(pts2, res2)) =>
       (matchingParams(pts1, pts2, tp2.isInstanceOf[JavaMethodType]) && (res1 matches res2) &&
        tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType])
-    case Pair(PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
+    case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
       (tparams1.length == tparams2.length &&
        (res1 matches res2.substSym(tparams2, tparams1)))
-    case Pair(PolyType(List(), rtp1), MethodType(List(), rtp2)) => matchesType(rtp1, rtp2)
-    case Pair(MethodType(List(), rtp1), PolyType(List(), rtp2)) => matchesType(rtp1, rtp2)
-    case Pair(PolyType(List(), rtp1), _) => matchesType(rtp1, tp2)
-    case Pair(_, PolyType(List(), rtp2)) => matchesType(tp1, rtp2)
-    case Pair(MethodType(_, _), _) => false
-    case Pair(PolyType(_, _), _)   => false
-    case Pair(_, MethodType(_, _)) => false
-    case Pair(_, PolyType(_, _))   => false
+    case (PolyType(List(), rtp1), MethodType(List(), rtp2)) => matchesType(rtp1, rtp2)
+    case (MethodType(List(), rtp1), PolyType(List(), rtp2)) => matchesType(rtp1, rtp2)
+    case (PolyType(List(), rtp1), _) => matchesType(rtp1, tp2)
+    case (_, PolyType(List(), rtp2)) => matchesType(tp1, rtp2)
+    case (MethodType(_, _), _) => false
+    case (PolyType(_, _), _)   => false
+    case (_, MethodType(_, _)) => false
+    case (_, PolyType(_, _))   => false
     case _ =>
       !phase.erasedTypes || tp1 =:= tp2
   }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index e36c40cfc0..40012423a9 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -193,7 +193,7 @@ abstract class ClassfileParser {
             in.buf(start) != CONSTANT_METHODREF &&
             in.buf(start) != CONSTANT_INTFMETHODREF) errorBadTag(start)
         val ownerTpe = getClassOrArrayType(in.getChar(start + 1))
-        val Pair(name, tpe) = getNameAndType(in.getChar(start + 3), ownerTpe)
+        val (name, tpe) = getNameAndType(in.getChar(start + 3), ownerTpe)
         if (name == nme.MODULE_INSTANCE_FIELD) {
           val index = in.getChar(start + 1)
           val name = getExternalName(in.getChar(starts(index) + 1))
@@ -217,9 +217,9 @@ abstract class ClassfileParser {
       f
     }
 
-    def getNameAndType(index: Int, ownerTpe: Type): Pair[Name, Type] = {
+    def getNameAndType(index: Int, ownerTpe: Type): (Name, Type) = {
       if (index <= 0 || len <= index) errorBadIndex(index)
-      var p = values(index).asInstanceOf[Pair[Name, Type]]
+      var p = values(index).asInstanceOf[(Name, Type)]
       if (p eq null) {
         val start = starts(index)
         if (in.buf(start) != CONSTANT_NAMEANDTYPE) errorBadTag(start)
@@ -232,7 +232,7 @@ abstract class ClassfileParser {
               tpe = MethodType(formals, ownerTpe)
           }
 
-        p = Pair(name, tpe)
+        p = (name, tpe)
       }
       p
     }
@@ -697,10 +697,10 @@ abstract class ClassfileParser {
         val attrNameIndex = in.nextChar
         val attrType = pool.getType(attrNameIndex)
         val nargs = in.nextChar
-        val nvpairs = new ListBuffer[Pair[Name,Constant]]
+        val nvpairs = new ListBuffer[(Name,Constant)]
         for (val i <- 0 until nargs) {
           val name = pool.getName(in.nextChar)
-          nvpairs += Pair(name, parseTaggedConstant())
+          nvpairs += (name, parseTaggedConstant())
         }
         sym.attributes = AttrInfo(attrType, List(), nvpairs.toList) :: sym.attributes
       }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
index 2dcd983b0c..5b521f12c8 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
@@ -40,7 +40,7 @@ abstract class ICodeReader extends ClassfileParser {
    *  two IClass objects, one for static members and one
    *  for non-static members.
    */
-  def readClass(cls: Symbol): Pair[IClass, IClass] = {
+  def readClass(cls: Symbol): (IClass, IClass) = {
     var classFile: AbstractFile = null;
     var sym = cls
     isScalaModule = cls.isModule && !cls.hasFlag(JAVA)
@@ -56,7 +56,7 @@ abstract class ICodeReader extends ClassfileParser {
     this.staticCode   = new IClass(sym.linkedClassOfClass)
     parse(classFile, sym)
 
-    Pair(staticCode, instanceCode)
+    (staticCode, instanceCode)
   }
 
   /** If we're parsing a scala module, the owner of members is always
@@ -86,12 +86,12 @@ abstract class ICodeReader extends ClassfileParser {
   }
 
   override def parseField(): Unit = {
-    val Pair(jflags, sym) = parseMember()
+    val (jflags, sym) = parseMember()
     getCode(jflags).addField(new IField(sym))
     skipAttributes()
   }
 
-  private def parseMember(): Pair[Int, Symbol] = {
+  private def parseMember(): (Int, Symbol) = {
     val jflags = in.nextChar
     val name = pool.getName(in.nextChar)
     var tpe  = pool.getType(in.nextChar)
@@ -103,19 +103,19 @@ abstract class ICodeReader extends ClassfileParser {
       }
 
     if ("<clinit>" == name.toString)
-      Pair(jflags, NoSymbol)
+      (jflags, NoSymbol)
     else {
       var sym = getOwner(jflags).info.member(name).suchThat(old => old.tpe =:= tpe);
       if (sym == NoSymbol)
         sym = getOwner(jflags).info.member(newTermName(name.toString + nme.LOCAL_SUFFIX)).suchThat(old => old.tpe =:= tpe);
       if (sym == NoSymbol)
         Console.println("Could not find symbol for " + name + ": " + tpe);
-      Pair(jflags, sym)
+      (jflags, sym)
     }
   }
 
   override def parseMethod(): Unit = {
-    val Pair(jflags, sym) = parseMember();
+    val (jflags, sym) = parseMember();
     if (sym != NoSymbol) {
       Console.println("Parsing method " + sym.fullNameString);
       this.method = new IMethod(sym);
@@ -568,15 +568,15 @@ abstract class ICodeReader extends ClassfileParser {
     if ((flags & JAVA_ACC_STATIC) != 0) staticCode else instanceCode
 
   class LinearCode {
-    var instrs: ListBuffer[Pair[Int, Instruction]] = new ListBuffer
+    var instrs: ListBuffer[(Int, Instruction)] = new ListBuffer
     var jmpTargets: Set[Int] = new HashSet[Int]
-    var locals: Map[Int, List[Pair[Local, TypeKind]]] = new HashMap()
+    var locals: Map[Int, List[(Local, TypeKind)]] = new HashMap()
 
     var containsDUPX = false
 
     def emit(i: Instruction) = {
 //      Console.println(i);
-      instrs += Pair(pc, i)
+      instrs += (pc, i)
       if (i.isInstanceOf[DupX])
         containsDUPX = true
     }
@@ -601,7 +601,7 @@ abstract class ICodeReader extends ClassfileParser {
       var otherBlock: BasicBlock = null
       var disableJmpTarget = false
 
-      for (val Pair(pc, instr) <- instrs.elements) {
+      for (val (pc, instr) <- instrs.elements) {
 //        Console.println("> " + pc + ": " + instr);
         if (jmpTargets contains pc) {
           otherBlock = blocks(pc)
@@ -652,21 +652,21 @@ abstract class ICodeReader extends ClassfileParser {
         import analysis._
         /** Abstract interpretation for one instruction. */
         override def interpret(in: typeFlowLattice.Elem, i: Instruction): typeFlowLattice.Elem = {
-          var out = Pair(new VarBinding(in._1), new TypeStack(in._2));
+          var out = (new VarBinding(in._1), new TypeStack(in._2));
           val bindings = out._1;
           val stack = out._2;
           import stack.push
           i match {
             case DUP_X1 =>
-              val Pair(one, two) = stack.pop2
+              val (one, two) = stack.pop2
               push(one); push(two); push(one);
 
             case DUP_X2 =>
-              val Triple(one, two, three) = stack.pop3
+              val (one, two, three) = stack.pop3
               push(one); push(three); push(two); push(one);
 
             case DUP2_X1 =>
-              val Pair(one, two) = stack.pop2
+              val (one, two) = stack.pop2
               if (one.isWideType) {
                 push(one); push(two); push(one);
               } else {
@@ -675,7 +675,7 @@ abstract class ICodeReader extends ClassfileParser {
               }
 
             case DUP2_X2 =>
-              val Pair(one, two) = stack.pop2
+              val (one, two) = stack.pop2
               if (one.isWideType && two.isWideType) {
                 push(one); push(two); push(one);
               } else if (one.isWideType) {
@@ -842,10 +842,10 @@ abstract class ICodeReader extends ClassfileParser {
         case Some(ls) =>
           val l = ls find { loc => loc._2 == kind }
           l match {
-            case Some(Pair(loc, _)) => loc
+            case Some((loc, _)) => loc
             case None =>
               val l = freshLocal(kind)
-              locals(idx) = Pair(l, kind) :: locals(idx)
+              locals(idx) = (l, kind) :: locals(idx)
               log("Expected kind " + kind + " for local " + idx +
                 " but only " + ls + " found. Added new local.")
               l
@@ -853,7 +853,7 @@ abstract class ICodeReader extends ClassfileParser {
         case None =>
           checkValidIndex
           val l = freshLocal(idx, kind, false)
-          locals += idx -> List(Pair(l, kind))
+          locals += idx -> List((l, kind))
           l
       }
     }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index f1ed8f36c0..5dc137e102 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -169,15 +169,15 @@ abstract class Pickler extends SubComponent {
       }
 
     private def putChildren(sym: Symbol, children: List[Symbol]): unit = {
-      assert(putEntry(Pair(sym, children)))
+      assert(putEntry((sym, children)))
       children foreach putSymbol
     }
 
     private def putAnnotation(sym: Symbol, attr: AttrInfo): unit = {
-      assert(putEntry(Pair(sym, attr)))
+      assert(putEntry((sym, attr)))
       putType(attr.atp)
       for (val c <- attr.args) putConstant(c)
-      for (val Pair(name, c) <- attr.assocs) { putEntry(name); putConstant(c) }
+      for (val (name, c) <- attr.assocs) { putEntry(name); putConstant(c) }
     }
 
     // Phase 2 methods: Write all entries to byte array ------------------------------
@@ -279,13 +279,13 @@ abstract class Pickler extends SubComponent {
           LITERAL + c.tag
         case AttributedType(attribs, tp) =>
           writeBody(tp) // obviously, this should be improved
-        case Pair(target: Symbol, attr @ AttrInfo(atp, args, assocs)) =>
+        case (target: Symbol, attr @ AttrInfo(atp, args, assocs)) =>
           writeRef(target)
           writeRef(atp)
           for (val c <- args) writeRef(c)
-          for (val Pair(name, c) <- assocs) { writeRef(name); writeRef(c) }
+          for (val (name, c) <- assocs) { writeRef(name); writeRef(c) }
           ATTRIBUTE
-        case Pair(target: Symbol, children: List[_]) =>
+        case (target: Symbol, children: List[_]) =>
           writeRef(target)
           for (val c <- children) writeRef(c.asInstanceOf[Symbol])
           CHILDREN
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala
index ac1d10e9be..a338824c8b 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala
@@ -288,10 +288,10 @@ abstract class UnPickler {
       if (tag == ATTRIBUTE) {
         val attrType = readTypeRef()
         val args = new ListBuffer[Constant]
-        val assocs = new ListBuffer[Pair[Name, Constant]]
+        val assocs = new ListBuffer[(Name, Constant)]
         while (readIndex != end) {
           val argref = readNat()
-          if (isNameEntry(argref)) assocs += Pair(at(argref, readName), readConstantRef())
+          if (isNameEntry(argref)) assocs += (at(argref, readName), readConstantRef())
           else args += at(argref, readConstant)
         }
         val attr = AttrInfo(attrType, args.toList, assocs.toList)
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index 4c80a56704..6d6dca90a3 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -164,16 +164,6 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
    }
   }
 
-  private def evalOnce(expr: Tree, owner: Symbol, unit: CompilationUnit)
-                      (within: (() => Tree) => Tree): Tree =
-    if (treeInfo.isPureExpr(expr)) {
-      within(() => expr);
-    } else {
-      val temp = owner.newValue(expr.pos, unit.fresh.newName())
-      .setFlag(SYNTHETIC).setInfo(expr.tpe);
-      Block(List(ValDef(temp, expr)), within(() => Ident(temp) setType expr.tpe))
-    }
-
 // -------- boxing/unboxing --------------------------------------------------------
 
   override def newTyper(context: Context) = new Eraser(context)
@@ -258,7 +248,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
         if (pt.symbol == ArrayClass)
           typed {
             atPos(tree.pos) {
-              evalOnce(tree, context.owner, context.unit) { x =>
+              gen.evalOnce(tree, context.owner, context.unit) { x =>
                 gen.mkAttributedCast(
                   If(
                     Apply(
@@ -275,7 +265,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
         else if (pt.symbol isNonBottomSubClass BoxedArrayClass)
           typed {
             atPos(tree.pos) {
-              evalOnce(tree, context.owner, context.unit) { x =>
+              gen.evalOnce(tree, context.owner, context.unit) { x =>
                 gen.mkAttributedCast(
                   If(
                     Apply(
@@ -292,7 +282,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
         else if ((SeqClass isNonBottomSubClass pt.symbol) && pt.symbol != ObjectClass)
           typed {
             atPos(tree.pos) {
-              evalOnce(tree, context.owner, context.unit) { x =>
+              gen.evalOnce(tree, context.owner, context.unit) { x =>
                 gen.mkAttributedCast(
                   If(
                     Apply(
@@ -760,7 +750,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
                         Apply(Select(qual, cmpOp), List(gen.mkAttributedQualifier(targ.tpe)))
                       }
                     case RefinedType(parents, decls) if (parents.length >= 2) =>
-                      evalOnce(qual, currentOwner, unit) {
+                      gen.evalOnce(qual, currentOwner, unit) {
                         q =>
                         def mkIsInstanceOf(tp: Type) =
                           copy.Apply(tree,
diff --git a/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala b/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala
index 68dd7368a9..489808c492 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala
@@ -49,21 +49,21 @@ abstract class ConstantFolder {
                                            // compiler itself crashing
     }
 
-  private def foldUnop(op: Name, x: Constant): Constant = Pair(op, x.tag) match {
-    case Pair(nme.UNARY_!, BooleanTag) => Constant(!x.booleanValue)
+  private def foldUnop(op: Name, x: Constant): Constant = (op, x.tag) match {
+    case (nme.UNARY_!, BooleanTag) => Constant(!x.booleanValue)
 
-    case Pair(nme.UNARY_~ , IntTag    ) => Constant(~x.intValue)
-    case Pair(nme.UNARY_~ , LongTag   ) => Constant(~x.longValue)
+    case (nme.UNARY_~ , IntTag    ) => Constant(~x.intValue)
+    case (nme.UNARY_~ , LongTag   ) => Constant(~x.longValue)
 
-    case Pair(nme.UNARY_+ , IntTag    ) => Constant(+x.intValue)
-    case Pair(nme.UNARY_+ , LongTag   ) => Constant(+x.longValue)
-    case Pair(nme.UNARY_+ , FloatTag  ) => Constant(+x.floatValue)
-    case Pair(nme.UNARY_+ , DoubleTag ) => Constant(+x.doubleValue)
+    case (nme.UNARY_+ , IntTag    ) => Constant(+x.intValue)
+    case (nme.UNARY_+ , LongTag   ) => Constant(+x.longValue)
+    case (nme.UNARY_+ , FloatTag  ) => Constant(+x.floatValue)
+    case (nme.UNARY_+ , DoubleTag ) => Constant(+x.doubleValue)
 
-    case Pair(nme.UNARY_- , IntTag    ) => Constant(-x.intValue)
-    case Pair(nme.UNARY_- , LongTag   ) => Constant(-x.longValue)
-    case Pair(nme.UNARY_- , FloatTag  ) => Constant(-x.floatValue)
-    case Pair(nme.UNARY_- , DoubleTag ) => Constant(-x.doubleValue)
+    case (nme.UNARY_- , IntTag    ) => Constant(-x.intValue)
+    case (nme.UNARY_- , LongTag   ) => Constant(-x.longValue)
+    case (nme.UNARY_- , FloatTag  ) => Constant(-x.floatValue)
+    case (nme.UNARY_- , DoubleTag ) => Constant(-x.doubleValue)
 
     case _ => null
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 0fb3d02cc5..34bafa6705 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -41,7 +41,7 @@ trait Contexts requires Analyzer {
       assert(pkg ne null)
       val qual = gen.mkAttributedStableRef(pkg)
       sc = sc.makeNewImport(
-        Import(qual, List(Pair(nme.WILDCARD, null)))
+        Import(qual, List((nme.WILDCARD, null)))
         .setSymbol(NoSymbol.newImport(NoPos).setFlag(SYNTHETIC).setInfo(ImportType(qual)))
         .setType(NoType))
       sc.depth = sc.depth + 1
@@ -95,7 +95,7 @@ trait Contexts requires Analyzer {
     var checking = false
     var retyping = false
 
-    var savedTypeBounds: List[Pair[Symbol, Type]] = List()
+    var savedTypeBounds: List[(Symbol, Type)] = List()
 
     override def equals(that : Any) = that match {
       case that if (super.equals(that)) => true
@@ -364,12 +364,12 @@ trait Contexts requires Analyzer {
     }
 
     def pushTypeBounds(sym: Symbol): unit = {
-      savedTypeBounds = Pair(sym, sym.info) :: savedTypeBounds
+      savedTypeBounds = (sym, sym.info) :: savedTypeBounds
     }
 
     def restoreTypeBounds(tp: Type): Type = {
       var current = tp
-      for (val Pair(sym, info) <- savedTypeBounds) {
+      for (val (sym, info) <- savedTypeBounds) {
         if (settings.debug.value) log("resetting " + sym + " to " + info);
         sym.info match {
           case TypeBounds(lo, hi) if (hi <:< lo && lo <:< hi) =>
@@ -391,10 +391,10 @@ trait Contexts requires Analyzer {
 
     private def collectImplicitImports(imp: ImportInfo): List[ImplicitInfo] = {
       val pre = imp.qual.tpe
-      def collect(sels: List[Pair[Name, Name]]): List[ImplicitInfo] = sels match {
+      def collect(sels: List[(Name, Name)]): List[ImplicitInfo] = sels match {
         case List() => List()
-        case List(Pair(nme.WILDCARD, _)) => collectImplicits(pre.implicitMembers, pre)
-        case Pair(from, to) :: sels1 =>
+        case List((nme.WILDCARD, _)) => collectImplicits(pre.implicitMembers, pre)
+        case (from, to) :: sels1 =>
           var impls = collect(sels1) filter (info => info.name != from)
           if (to != nme.WILDCARD) {
             val sym = imp.importedSymbol(to)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index fe0ffa65f8..85186da712 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -142,7 +142,7 @@ trait Infer requires Analyzer {
         val bound: Type = if (up) tparam.info.bounds.hi else tparam.info.bounds.lo
         //Console.println("solveOne0 "+tvar+" "+config+" "+bound);//DEBUG
         var cyclic = false
-        for (val Pair(tvar2, Pair(tparam2, variance2)) <- config) {
+        for (val (tvar2, (tparam2, variance2)) <- config) {
           if (tparam2 != tparam &&
               ((bound contains tparam2) ||
                up && (tparam2.info.bounds.lo =:= tparam.tpe) ||
@@ -178,7 +178,7 @@ trait Infer requires Analyzer {
         assertNonCyclic(tvar)//debug
       }
     }
-    for (val Pair(tvar, Pair(tparam, variance)) <- config)
+    for (val (tvar, (tparam, variance)) <- config)
       solveOne(tvar, tparam, variance)
     tvars map instantiate
   }
@@ -303,13 +303,13 @@ trait Infer requires Analyzer {
           explainName(sym1)
           explainName(sym2)
           if (sym1.owner == sym2.owner) sym2.name = newTypeName("(some other)"+sym2.name)
-          Triple(sym1, sym2, name)
+          (sym1, sym2, name)
         }
       }
 
       val result = op
 
-      for (val Triple(sym1, sym2, name) <- patches) {
+      for (val (sym1, sym2, name) <- patches) {
         sym1.name = name
         sym2.name = name
       }
@@ -693,8 +693,8 @@ trait Infer requires Analyzer {
      *        any correspondiong non-variant type arguments of bt1 and bt2 are the same
      */
     def isPopulated(tp1: Type, tp2: Type): boolean = {
-      def isConsistent(tp1: Type, tp2: Type): boolean = Pair(tp1, tp2) match {
-        case Pair(TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) =>
+      def isConsistent(tp1: Type, tp2: Type): boolean = (tp1, tp2) match {
+        case (TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) =>
           assert(sym1 == sym2)
           pre1 =:= pre2 &&
           !(List.map3(args1, args2, sym1.typeParams) {
@@ -781,9 +781,9 @@ trait Infer requires Analyzer {
         if (settings.debug.value) log("new alias of " + tparam + " = " + tparam.info)
       } else {
         val instType = toOrigin(tvar.constr.inst)
-        val Pair(loBounds, hiBounds) =
-          if (instType != NoType && isFullyDefined(instType)) Pair(List(instType), List(instType))
-          else Pair(tvar.constr.lobounds, tvar.constr.hibounds)
+        val (loBounds, hiBounds) =
+          if (instType != NoType && isFullyDefined(instType)) (List(instType), List(instType))
+          else (tvar.constr.lobounds, tvar.constr.hibounds)
         val lo = lub(tparam.info.bounds.lo :: loBounds map toOrigin)
         val hi = glb(tparam.info.bounds.hi :: hiBounds map toOrigin)
         if (!(lo <:< hi)) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 949740adde..6a877e9f50 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -219,7 +219,7 @@ trait Namers requires Analyzer {
 
     def skolemize(tparams: List[AbsTypeDef]): unit = {
       val tskolems = newTypeSkolems(tparams map (.symbol))
-      for (val Pair(tparam, tskolem) <- tparams zip tskolems) tparam.symbol = tskolem
+      for (val (tparam, tskolem) <- tparams zip tskolems) tparam.symbol = tskolem
     }
 
     def applicableTypeParams(owner: Symbol): List[Symbol] =
@@ -648,8 +648,8 @@ trait Namers requires Analyzer {
                 }
                 true
               }
-              def checkSelectors(selectors: List[Pair[Name, Name]]): unit = selectors match {
-                case Pair(from, to) :: rest =>
+              def checkSelectors(selectors: List[(Name, Name)]): unit = selectors match {
+                case (from, to) :: rest =>
         	  if (from != nme.WILDCARD && base != ErrorType) {
         	    if (base.member(from) == NoSymbol && base.member(from.toTypeName) == NoSymbol)
         	      context.error(tree.pos, from.decode + " is not a member of " + expr);
@@ -747,8 +747,8 @@ trait Namers requires Analyzer {
         else if (isFunctionType(tp) &&
                  (!isFunctionType(elemtp) || tp.typeArgs.length > elemtp.typeArgs.length))
           result = true
-        else Pair(tp, elemtp) match {
-          case Pair(TypeRef(pre, sym, args), TypeRef(elempre, elemsym, elemargs)) =>
+        else (tp, elemtp) match {
+          case (TypeRef(pre, sym, args), TypeRef(elempre, elemsym, elemargs)) =>
             if ((sym == elemsym) && (pre =:= elempre) && (args.length == elemargs.length))
               result = List.forall2(elemargs, args) (isContainedIn)
           case _ =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 7a06d45cb5..5d377b5a12 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -100,12 +100,12 @@ abstract class RefChecks extends InfoTransform {
                 else "")))
       }
 
-      def overridesType(tp1: Type, tp2: Type): boolean = Pair(tp1, tp2) match {
-        case Pair(MethodType(List(), rtp1), PolyType(List(), rtp2)) =>
+      def overridesType(tp1: Type, tp2: Type): boolean = (tp1, tp2) match {
+        case (MethodType(List(), rtp1), PolyType(List(), rtp2)) =>
           rtp1 <:< rtp2
-        case Pair(PolyType(List(), rtp1), MethodType(List(), rtp2)) =>
+        case (PolyType(List(), rtp1), MethodType(List(), rtp2)) =>
           rtp1 <:< rtp2
-        case Pair(TypeRef(_, sym, _),  _) if (sym.isModuleClass) =>
+        case (TypeRef(_, sym, _),  _) if (sym.isModuleClass) =>
           overridesType(PolyType(List(), tp1), tp2)
         case _ =>
           tp1 <:< tp2
@@ -375,7 +375,7 @@ abstract class RefChecks extends InfoTransform {
 
       def validateVarianceArgs(tps: List[Type], variance: int, tparams: List[Symbol]): unit =
 	(tps zip tparams) foreach {
-	  case Pair(tp, tparam) => validateVariance(tp, variance * tparam.variance)
+	  case (tp, tparam) => validateVariance(tp, variance * tparam.variance)
 	}
 
       validateVariance(all, variance)
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index 51ed171076..61bd300472 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -36,7 +36,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
 
   class SuperAccTransformer(unit: CompilationUnit) extends TypingTransformer(unit) {
     private var validCurrentOwner = true
-    private var accDefs: List[Pair[Symbol, ListBuffer[Tree]]] = List()
+    private var accDefs: List[(Symbol, ListBuffer[Tree])] = List()
 
     private def accDefBuf(clazz: Symbol) =
       accDefs.dropWhile(._1.!=(clazz)).head._2
@@ -63,7 +63,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
         super.transform(tree)
       case Template(parents, body) =>
 	val ownAccDefs = new ListBuffer[Tree];
-	accDefs = Pair(currentOwner, ownAccDefs) :: accDefs;
+	accDefs = (currentOwner, ownAccDefs) :: accDefs;
 
         // ugly hack... normally, the following line should not be
         // necessary, the 'super' method taking care of that. but because
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index bd534813c2..9c4dca6e59 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -81,7 +81,7 @@ trait SyntheticMethods requires Analyzer {
       //val retTpe = lub(accs map (.tpe.resultType))
       val method = syntheticMethod(nme.element, FINAL, MethodType(List(IntClass.tpe), AnyClass.tpe/*retTpe*/))
       typed(DefDef(method, vparamss => Match(Ident(vparamss.head.head), {
-	(for(val Pair(sym,i) <- accs.zipWithIndex) yield {
+	(for(val (sym,i) <- accs.zipWithIndex) yield {
 	  CaseDef(Literal(Constant(i)),EmptyTree, Ident(sym))
 	}):::List(CaseDef(Ident(nme.WILDCARD), EmptyTree,
 		    Throw(New(TypeTree(IndexOutOfBoundsExceptionClass.tpe), List(List(
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 46f3573edb..d6e833b916 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -275,7 +275,7 @@ trait Typers requires Analyzer {
     def checkParamsConvertible(pos: PositionType, tpe: Type): unit = tpe match {
       case MethodType(formals, restpe) =>
         if (formals.exists(.symbol.==(ByNameParamClass)) && formals.length != 1)
-          error(pos, "methods with `=>'-parameter can be converted to function values only if they are unary")
+          error(pos, "methods with `=>'-parameter can be converted to function values only if they take no other parameters")
         if (formals exists (.symbol.==(RepeatedParamClass)))
           error(pos, "methods with `*'-parameters cannot be converted to function values");
         checkParamsConvertible(pos, restpe)
@@ -464,7 +464,7 @@ trait Typers requires Analyzer {
       else tree
     }
 
-    /** The member with givne name of given qualifier tree */
+    /** The member with given name of given qualifier tree */
     def member(qual: Tree, name: Name) = qual.tpe match {
       case ThisType(clazz) if (context.enclClass.owner.ownerChain contains clazz) =>
         qual.tpe.member(name)
@@ -473,6 +473,22 @@ trait Typers requires Analyzer {
         else qual.tpe.nonLocalMember(name)
     }
 
+    def silent(op: Typer => Tree): AnyRef /* in fact, TypeError or Tree */ = try {
+      if (context.reportGeneralErrors) {
+        val context1 = context.makeSilent(context.reportAmbiguousErrors)
+        context1.undetparams = context.undetparams
+        val typer1 = newTyper(context1)
+        val result = op(typer1)
+        context.undetparams = context1.undetparams
+        result
+      } else {
+        op(this)
+      }
+    } catch {
+      case ex: CyclicReference => throw ex
+      case ex: TypeError => ex
+    }
+
     /** Perform the following adaptations of expression, pattern or type `tree' wrt to
      *  given mode `mode' and given prototype `pt':
      *  (0) Convert expressions with constant types to literals
@@ -979,21 +995,21 @@ trait Typers requires Analyzer {
      */
     def computeParamAliases(clazz: Symbol, vparamss: List[List[ValDef]], rhs: Tree): unit = {
       if (settings.debug.value) log("computing param aliases for "+clazz+":"+clazz.primaryConstructor.tpe+":"+rhs);//debug
-      def decompose(call: Tree): Pair[Tree, List[Tree]] = call match {
+      def decompose(call: Tree): (Tree, List[Tree]) = call match {
         case Apply(fn, args) =>
-          val Pair(superConstr, args1) = decompose(fn)
+          val (superConstr, args1) = decompose(fn)
           val formals = fn.tpe.paramTypes
           val args2 = if (formals.isEmpty || formals.last.symbol != RepeatedParamClass) args
                       else args.take(formals.length - 1) ::: List(EmptyTree)
           if (args2.length != formals.length)
             assert(false, "mismatch " + clazz + " " + formals + " " + args2);//debug
-          Pair(superConstr, args1 ::: args2)
+          (superConstr, args1 ::: args2)
         case Block(stats, expr) =>
           decompose(stats.head)
         case _ =>
-          Pair(call, List())
+          (call, List())
       }
-      val Pair(superConstr, superArgs) = decompose(rhs)
+      val (superConstr, superArgs) = decompose(rhs)
       assert(superConstr.symbol ne null)//debug
       if (superConstr.symbol.isPrimaryConstructor) {
         val superClazz = superConstr.symbol.owner
@@ -1226,16 +1242,16 @@ trait Typers requires Analyzer {
     def typedFunction(fun: Function, mode: int, pt: Type): Tree = {
       val codeExpected = !forCLDC && !forMSIL && (pt.symbol isNonBottomSubClass CodeClass)
 
-      def decompose(pt: Type): Triple[Symbol, List[Type], Type] =
+      def decompose(pt: Type): (Symbol, List[Type], Type) =
         if (isFunctionType(pt)
             ||
             pt.symbol == PartialFunctionClass &&
             fun.vparams.length == 1 && fun.body.isInstanceOf[Match])
-          Triple(pt.symbol, pt.typeArgs.init, pt.typeArgs.last)
+          (pt.symbol, pt.typeArgs.init, pt.typeArgs.last)
         else
-          Triple(FunctionClass(fun.vparams.length), fun.vparams map (x => NoType), WildcardType)
+          (FunctionClass(fun.vparams.length), fun.vparams map (x => NoType), WildcardType)
 
-      val Triple(clazz, argpts, respt) = decompose(if (codeExpected) pt.typeArgs.head else pt)
+      val (clazz, argpts, respt) = decompose(if (codeExpected) pt.typeArgs.head else pt)
 
       if (fun.vparams.length != argpts.length)
         errorTree(fun, "wrong number of parameters; expected = " + argpts.length)
@@ -1388,11 +1404,9 @@ trait Typers requires Analyzer {
           val formals = formalTypes(formals0, args.length)
           var args1 = actualArgs(tree.pos, args, formals.length)
           if (args1.length != args.length) {
-            try {
-              silentTypedApply(tree, fun, args1, mode, pt)
-            } catch {
-              case ex: TypeError =>
-                errorTree(tree, "wrong number of arguments for "+treeSymTypeMsg(fun))
+            silent(.typedApply(tree, fun, args1, mode, pt)) match {
+              case t: Tree => t
+              case ex => errorTree(tree, "wrong number of arguments for "+treeSymTypeMsg(fun))
             }
           } else if (formals.length != args1.length) {
             errorTree(tree, "wrong number of arguments for "+treeSymTypeMsg(fun))
@@ -1511,14 +1525,14 @@ trait Typers requires Analyzer {
           val oldArgType = arg.tpe
           if (!isApplicable(List(), unappType, List(arg.tpe), WildcardType)) {
             //Console.println("UNAPP: need to typetest, arg.tpe = "+arg.tpe+", unappType = "+unappType)
-            def freshArgType(tp: Type): Pair[Type, List[Symbol]] = tp match {
+            def freshArgType(tp: Type): (Type, List[Symbol]) = tp match {
               case MethodType(formals, restpe) =>
-                Pair(formals(0), List())
+                (formals(0), List())
               case PolyType(tparams, restype) =>
                 val tparams1 = cloneSymbols(tparams)
-                Pair(freshArgType(restype)._1.substSym(tparams, tparams1), tparams1)
+                (freshArgType(restype)._1.substSym(tparams, tparams1), tparams1)
             }
-            val Pair(unappFormal, freeVars) = freshArgType(unappType)
+            val (unappFormal, freeVars) = freshArgType(unappType)
             val context1 = context.makeNewScope(context.tree, context.owner)
             freeVars foreach context1.scope.enter
             val typer1 = new Typer(context1)
@@ -1548,18 +1562,6 @@ trait Typers requires Analyzer {
       }
     }
 
-    def silentTypedApply(tree: Tree, fun: Tree, args: List[Tree], mode: int, pt: Type): Tree =
-      if (context.reportGeneralErrors) {
-        val context1 = context.makeSilent(context.reportAmbiguousErrors)
-        context1.undetparams = context.undetparams
-        val typer1 = newTyper(context1)
-        val result = typer1.typedApply(tree, fun, args, mode, pt)
-        context.undetparams = context1.undetparams
-        result
-      } else {
-        typedApply(tree, fun, args, mode, pt)
-      }
-
     def typedAnnotation(constr: Tree, elements: List[Tree]): AttrInfo = {
       var attrError: Boolean = false;
       def error(pos: PositionType, msg: String): Null = {
@@ -1591,12 +1593,12 @@ trait Typers requires Analyzer {
                   error(ntree.pos, "duplicate value for element " + name)
                 } else {
                   names -= sym
-                  Pair(sym.name, getConstant(typed(rhs, EXPRmode | CONSTmode, sym.tpe.resultType)))
+                  (sym.name, getConstant(typed(rhs, EXPRmode | CONSTmode, sym.tpe.resultType)))
                 }
               }
             }
             for (val name <- names) {
-              if (!name.attributes.contains(Triple(AnnotationDefaultAttr.tpe, List(), List()))) {
+              if (!name.attributes.contains((AnnotationDefaultAttr.tpe, List(), List()))) {
                 error(constr.pos, "attribute " + tpt.tpe.symbol.fullNameString + " is missing element " + name.name)
               }
             }
@@ -1651,10 +1653,8 @@ trait Typers requires Analyzer {
         try {
           newTyper(c).typedArgs(args, mode)
         } catch {
-        case ex: TypeError =>
-          null
-        case t : Throwable =>
-          throw t
+          case ex: TypeError =>
+            null
         }
       }
 
@@ -1665,58 +1665,70 @@ trait Typers requires Analyzer {
        *  @param args ...
        *  @return     ...
        */
-      def tryTypedApply(fun: Tree, args: List[Tree]): Tree = try {
-        silentTypedApply(tree, fun, args, mode, pt)
-      } catch {
-        case ex: CyclicReference =>
-          throw ex
-        case ex: TypeError =>
-          val Select(qual, name) = fun
-          val args1 = tryTypedArgs(args, ex)
-          val qual1 =
-            if ((args1 ne null) && !pt.isError) {
-              def templateArgType(arg: Tree) =
-                new BoundedWildcardType(mkTypeBounds(arg.tpe, AnyClass.tpe))
-              adaptToMember(qual, name, MethodType(args1 map templateArgType, pt))
-            } else qual
-          if (qual1 ne qual) {
-            val tree1 = Apply(Select(qual1, name) setPos fun.pos, args1) setPos tree.pos
-            typed1(tree1, mode | SNDTRYmode, pt)
-          } else {
-            reportTypeError(tree.pos, ex)
-            setError(tree)
-          }
-        case t => throw t;
-      }
-/*
-      /** Try to apply function to arguments; if it does not work try to insert an implicit
-       *  conversion
-       */
-      def tryTypedApply(fun: Tree, args: List[Tree]): Tree = {
-        val reportGeneralErrors = context.reportGeneralErrors
-        val undetparams = context.undetparams
-        try {
-          context.reportGeneralErrors = false
-          typedApply(tree, fun, args, mode, pt)
-        } catch {
-          case ex: CyclicReference =>
-            throw ex
+      def tryTypedApply(fun: Tree, args: List[Tree]): Tree =
+        silent(.typedApply(tree, fun, args, mode, pt)) match {
+          case t: Tree =>
+            t
           case ex: TypeError =>
             val Select(qual, name) = fun
-            context.undetparams = undetparams
-            val args1 = tryTypedArgs(args map (arg => UnTyper.apply(arg)))
-            context.reportGeneralErrors = reportGeneralErrors
-            def templateArgType(arg: Tree) =
-              new BoundedWildcardType(TypeBounds(arg.tpe, AnyClass.tpe))
-            val qual1 = if ((args1 eq null) || pt.isError) qual
-                        else adaptToMember(qual, name, MethodType(args1 map templateArgType, pt))
-            val tree1 = Apply(Select(qual1, name) setPos fun.pos, args map (arg => UnTyper.apply(arg))) setPos tree.pos
-            typed1(tree1, mode | SNDTRYmode, pt)
-        } finally {
-          context.reportGeneralErrors = reportGeneralErrors
+            val args1 = tryTypedArgs(args, ex)
+            val qual1 =
+              if ((args1 ne null) && !pt.isError) {
+                def templateArgType(arg: Tree) =
+                  new BoundedWildcardType(mkTypeBounds(arg.tpe, AnyClass.tpe))
+                adaptToMember(qual, name, MethodType(args1 map templateArgType, pt))
+              } else qual
+            if (qual1 ne qual) {
+              val tree1 = Apply(Select(qual1, name) setPos fun.pos, args1) setPos tree.pos
+              typed1(tree1, mode | SNDTRYmode, pt)
+            } else {
+              reportTypeError(tree.pos, ex)
+              setError(tree)
+            }
+        }
+
+      def convertToAssignment(fun: Tree, qual: Tree, name: Name, args: List[Tree], ex: TypeError): Tree = {
+        val prefix = name.subName(0, name.length - nme.EQL.length)
+        def mkAssign(vble: Tree): Tree =
+          Assign(
+            vble,
+              Apply(Select(vble.duplicate, prefix) setPos fun.pos, args) setPos tree.pos
+          ) setPos tree.pos
+        val tree1 = qual match {
+          case Select(qualqual, vname) =>
+            gen.evalOnce(qualqual, context.owner, context.unit) { qq =>
+              mkAssign(Select(qq(), vname) setPos qual.pos)
+            }
+          case Apply(Select(table, nme.apply), indices) =>
+            gen.evalOnceAll(table :: indices, context.owner, context.unit) { ts =>
+              val tab = ts.head
+              val is = ts.tail
+              Apply(
+                 Select(tab(), nme.update) setPos table.pos,
+                 ((is map (i => i())) ::: List(
+                   Apply(
+                     Select(
+                       Apply(
+                         Select(tab(), nme.apply) setPos table.pos,
+                         is map (i => i())) setPos qual.pos,
+                       prefix) setPos fun.pos,
+                     args) setPos tree.pos)
+                 )
+               ) setPos tree.pos
+             }
+           case Ident(_) =>
+             mkAssign(qual)
+        }
+        if (settings.debug.value) log("retry assign: "+tree1)
+        silent(.typed1(tree1, mode, pt)) match {
+          case t: Tree =>
+            t
+          case _ =>
+            reportTypeError(tree.pos, ex)
+            setError(tree)
         }
       }
-*/
+
       /** Attribute a selection where <code>tree</code> is <code>qual.name</code>.
        *  <code>qual</code> is already attributed.
        *
@@ -2198,29 +2210,44 @@ trait Typers requires Analyzer {
             typed1(tree, mode & ~PATTERNmode | EXPRmode, pt)
           } else {
             val funpt = if ((mode & PATTERNmode) != 0) pt else WildcardType
-            var fun1 = typed(fun, funMode(mode), funpt)
-            if (stableApplication) fun1 = stabilizeFun(fun1, mode, pt)
-            // if function is overloaded, filter all alternatives that match
-            // number of arguments and expected result type.
-            if (util.Statistics.enabled) appcnt = appcnt + 1
-            val ret = if (phase.id <= currentRun.typerPhase.id &&
-                fun1.isInstanceOf[Select] &&
-                !fun1.tpe.isInstanceOf[ImplicitMethodType] &&
-                ((fun1.symbol eq null) || !fun1.symbol.isConstructor) &&
-                (mode & (EXPRmode | SNDTRYmode)) == EXPRmode) tryTypedApply(fun1, args)
-            else {
-              typedApply(tree, fun1, args, mode, pt)
+            silent(.typed(fun, funMode(mode), funpt)) match {
+              case fun1: Tree =>
+                val fun2 = if (stableApplication) stabilizeFun(fun1, mode, pt) else fun1
+                if (util.Statistics.enabled) appcnt = appcnt + 1
+                if (phase.id <= currentRun.typerPhase.id &&
+                    fun2.isInstanceOf[Select] &&
+                    !fun2.tpe.isInstanceOf[ImplicitMethodType] &&
+                    ((fun2.symbol eq null) || !fun2.symbol.isConstructor) &&
+                    (mode & (EXPRmode | SNDTRYmode)) == EXPRmode) tryTypedApply(fun2, args)
+                else {
+                  typedApply(tree, fun2, args, mode, pt)
+                }
+              case ex: TypeError =>
+                fun match {
+                  case Select(qual, name) =>
+                    val qual1 = typedQualifier(qual)
+                    if ((mode & PATTERNmode) == 0 &&
+                        nme.isOpAssignmentName(name) &&
+                        treeInfo.isVariableOrGetter(qual1)) {
+                      convertToAssignment(fun, qual1, name, args, ex)
+                    } else {
+                      reportTypeError(fun.pos, ex)
+                      setError(tree)
+                    }
+                  case _ =>
+                    reportTypeError(fun.pos, ex)
+                    setError(tree)
+                }
             }
-            ret
           }
 
         case Super(qual, mix) =>
-          val Pair(clazz, selftype) =
+          val (clazz, selftype) =
             if (tree.symbol != NoSymbol) {
-              Pair(tree.symbol, tree.symbol.thisType)
+              (tree.symbol, tree.symbol.thisType)
             } else {
               val clazzContext = qualifyingClassContext(tree, qual)
-              Pair(clazzContext.owner, clazzContext.prefix)
+              (clazzContext.owner, clazzContext.prefix)
             }
           if (clazz == NoSymbol) setError(tree)
           else {
@@ -2246,12 +2273,12 @@ trait Typers requires Analyzer {
           }
 
         case This(qual) =>
-          val Pair(clazz, selftype) =
+          val (clazz, selftype) =
             if (tree.symbol != NoSymbol) {
-              Pair(tree.symbol, tree.symbol.thisType)
+              (tree.symbol, tree.symbol.thisType)
             } else {
               val clazzContext = qualifyingClassContext(tree, qual)
-              Pair(clazzContext.owner, clazzContext.prefix)
+              (clazzContext.owner, clazzContext.prefix)
             }
           if (clazz == NoSymbol) setError(tree)
           else {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Variances.scala b/src/compiler/scala/tools/nsc/typechecker/Variances.scala
index 43e394cd91..1e112d320f 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Variances.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Variances.scala
@@ -53,7 +53,7 @@ trait Variances {
    *  `tps' which correspond to formal type parameters `tparams1'. */
   def varianceInArgs(tps: List[Type], tparams1: List[Symbol])(tparam: Symbol): int = {
     var v: int = VARIANCES;
-    for (val Pair(tp, tparam1) <- tps zip tparams1) {
+    for (val (tp, tparam1) <- tps zip tparams1) {
       val v1 = varianceInType(tp)(tparam);
       v = v & (if (tparam1.isCovariant) v1
 	       else if (tparam1.isContravariant) flip(v1)