Merge branch 'master' into issue/5846,4597,4027,4112

Conflicts:
	src/library/scala/collection/MapLike.scala
	src/library/scala/collection/SortedMapLike.scala

40 files changed, 669 insertions, 1 deletions

diff --git a/test/files/run/collection-conversions.check b/test/files/run/collection-conversions.check
new file mode 100644
index 0000000000..5e43d25f7e
--- /dev/null
+++ b/test/files/run/collection-conversions.check
@@ -0,0 +1,126 @@
+-- Testing iterator ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing Vector ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing List ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing Buffer ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing ParVector ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing ParArray ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing Set ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing SetView ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
+-- Testing BufferView ---
+  :[Direct] Vector   : OK
+  :[Copy]   Vector   : OK
+  :[Direct] Buffer   : OK
+  :[Copy]   Buffer   : OK
+  :[Direct] GenSeq   : OK
+  :[Copy]   GenSeq   : OK
+  :[Copy]   Seq      : OK
+  :[Direct] Stream   : OK
+  :[Copy]   Stream   : OK
+  :[Direct] Array    : OK
+  :[Copy]   Array    : OK
+  :[Copy]   ParVector: OK
+  :[Copy]   ParArray : OK
\ No newline at end of file
diff --git a/test/files/run/collection-conversions.scala b/test/files/run/collection-conversions.scala
new file mode 100644
index 0000000000..6d90caee4b
--- /dev/null
+++ b/test/files/run/collection-conversions.scala
@@ -0,0 +1,64 @@
+import collection._
+import mutable.Buffer
+import parallel.immutable.ParVector
+import parallel.mutable.ParArray
+import reflect.ClassTag
+
+object Test {
+
+  def printResult[A,B](msg: String, obj: A, expected: B)(implicit tag: ClassTag[A], tag2: ClassTag[B]) = {
+    print("  :" + msg +": ")
+    val isArray = obj match { 
+      case x: Array[Int] => true 
+      case _ => false
+    }
+    val expectedEquals = 
+      if(isArray) obj.asInstanceOf[Array[Int]].toSeq == expected.asInstanceOf[Array[Int]].toSeq
+      else obj == expected
+    val tagEquals = tag == tag2
+    if(expectedEquals && tagEquals) print("OK")
+    else print("FAILED")
+    if(!expectedEquals) print(", " + obj + " != " + expected)
+    if(!tagEquals)     print(", " + tag + " != " + tag2)
+    println("")
+  }
+
+  val testVector = Vector(1,2,3)
+  val testBuffer = Buffer(1,2,3)
+  val testGenSeq = GenSeq(1,2,3)
+  val testSeq = Seq(1,2,3)
+  val testStream = Stream(1,2,3)
+  val testArray = Array(1,2,3)
+  val testParVector = ParVector(1,2,3)
+  val testParArray = ParArray(1,2,3)
+
+  def testConversion[A: ClassTag](name: String, col: => GenTraversableOnce[A]): Unit = {
+    val tmp = col
+    println("-- Testing " + name + " ---")
+    printResult("[Direct] Vector   ", col.toVector, testVector)
+    printResult("[Copy]   Vector   ", col.convertTo[Vector], testVector)
+    printResult("[Direct] Buffer   ", col.toBuffer, testBuffer)
+    printResult("[Copy]   Buffer   ", col.convertTo[Buffer], testBuffer)
+    printResult("[Direct] GenSeq   ", col.toSeq, testGenSeq)
+    printResult("[Copy]   GenSeq   ", col.convertTo[GenSeq], testGenSeq)
+    printResult("[Copy]   Seq      ", col.convertTo[Seq], testSeq)
+    printResult("[Direct] Stream   ", col.toStream, testStream)
+    printResult("[Copy]   Stream   ", col.convertTo[Stream], testStream)
+    printResult("[Direct] Array    ", col.toArray, testArray)
+    printResult("[Copy]   Array    ", col.convertTo[Array], testArray)
+    printResult("[Copy]   ParVector", col.convertTo[ParVector], testParVector)
+    printResult("[Copy]   ParArray ", col.convertTo[ParArray], testParArray)
+  }
+  
+  def main(args: Array[String]): Unit = {
+    testConversion("iterator", (1 to 3).iterator)
+    testConversion("Vector", Vector(1,2,3))
+    testConversion("List", List(1,2,3))
+    testConversion("Buffer", Buffer(1,2,3))
+    testConversion("ParVector", ParVector(1,2,3))
+    testConversion("ParArray", ParArray(1,2,3))
+    testConversion("Set", Set(1,2,3))
+    testConversion("SetView", Set(1,2,3).view)
+    testConversion("BufferView", Buffer(1,2,3).view)
+  }
+}
diff --git a/test/files/run/macro-reify-splice-splice/Macros_1.scala b/test/files/run/macro-reify-splice-splice/Macros_1.scala
index 030a0a217e..4f1b600f63 100644
--- a/test/files/run/macro-reify-splice-splice/Macros_1.scala
+++ b/test/files/run/macro-reify-splice-splice/Macros_1.scala
@@ -1,5 +1,4 @@
 import scala.reflect.makro.{Context => Ctx}
-import scala.reflect.{mirror => mr}
 
 object Macros {
   def foo = macro Impls.foo
diff --git a/test/files/run/showraw_mods.check b/test/files/run/showraw_mods.check
new file mode 100644
index 0000000000..83055f2b70
--- /dev/null
+++ b/test/files/run/showraw_mods.check
@@ -0,0 +1 @@
+Block(List(ClassDef(Modifiers(ABSTRACT | DEFAULTPARAM/TRAIT), newTypeName("C"), List(), Template(List(Ident(java.lang.Object)), emptyValDef, List(DefDef(Modifiers(), newTermName("$init$"), List(), List(List()), TypeTree(), Block(List(), Literal(Constant(())))), ValDef(Modifiers(PRIVATE | LOCAL), newTermName("x"), TypeTree(), Literal(Constant(2))), ValDef(Modifiers(MUTABLE), newTermName("y"), TypeTree(), Select(This(newTypeName("C")), newTermName("x"))), ValDef(Modifiers(LAZY), newTermName("z"), TypeTree(), Select(This(newTypeName("C")), newTermName("y"))))))), Literal(Constant(())))

diff --git a/test/files/run/showraw_mods.scala b/test/files/run/showraw_mods.scala
new file mode 100644
index 0000000000..a10e4821dc
--- /dev/null
+++ b/test/files/run/showraw_mods.scala
@@ -0,0 +1,6 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  val tree = reify{trait C { private[this] val x = 2; var y = x; lazy val z = y }}
+  println(showRaw(tree.tree))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree.check b/test/files/run/showraw_tree.check
new file mode 100644
index 0000000000..82724cae44
--- /dev/null
+++ b/test/files/run/showraw_tree.check
@@ -0,0 +1,2 @@
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Ident(java.lang.String), Ident(java.lang.String)))), nme.CONSTRUCTOR), List())

+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Ident(java.lang.String), Ident(java.lang.String)))), nme.CONSTRUCTOR), List())

diff --git a/test/files/run/showraw_tree.scala b/test/files/run/showraw_tree.scala
new file mode 100644
index 0000000000..3624a24d6a
--- /dev/null
+++ b/test/files/run/showraw_tree.scala
@@ -0,0 +1,8 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tree1.tree))
+  println(showRaw(tree2.tree))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree_ids.check b/test/files/run/showraw_tree_ids.check
new file mode 100644
index 0000000000..c6dbd6f1ce
--- /dev/null
+++ b/test/files/run/showraw_tree_ids.check
@@ -0,0 +1,2 @@
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#1903), List(Ident(java.lang.String#129), Ident(java.lang.String#129)))), nme.CONSTRUCTOR), List())

+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#1908), List(Ident(java.lang.String#129), Ident(java.lang.String#129)))), nme.CONSTRUCTOR), List())

diff --git a/test/files/run/showraw_tree_ids.scala b/test/files/run/showraw_tree_ids.scala
new file mode 100644
index 0000000000..b56b8b4476
--- /dev/null
+++ b/test/files/run/showraw_tree_ids.scala
@@ -0,0 +1,8 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tree1.tree, printIds = true))
+  println(showRaw(tree2.tree, printIds = true))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree_kinds.check b/test/files/run/showraw_tree_kinds.check
new file mode 100644
index 0000000000..a12e21c611
--- /dev/null
+++ b/test/files/run/showraw_tree_kinds.check
@@ -0,0 +1,2 @@
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#CLS), List(Ident(java.lang.String#CLS), Ident(java.lang.String#CLS)))), nme.CONSTRUCTOR), List())

+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Ident(java.lang.String#CLS), Ident(java.lang.String#CLS)))), nme.CONSTRUCTOR), List())

diff --git a/test/files/run/showraw_tree_kinds.scala b/test/files/run/showraw_tree_kinds.scala
new file mode 100644
index 0000000000..0ca5a387da
--- /dev/null
+++ b/test/files/run/showraw_tree_kinds.scala
@@ -0,0 +1,8 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tree1.tree, printKinds = true))
+  println(showRaw(tree2.tree, printKinds = true))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree_types_ids.check b/test/files/run/showraw_tree_types_ids.check
new file mode 100644
index 0000000000..02e7aeed7c
--- /dev/null
+++ b/test/files/run/showraw_tree_types_ids.check
@@ -0,0 +1,10 @@
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#1903), List(TypeTree[4]().setOriginal(Ident[4](java.lang.String#129)), TypeTree[4]().setOriginal(Ident[4](java.lang.String#129)))))), nme.CONSTRUCTOR#1913), List())

+[1] TypeRef(ThisType(scala.collection.immutable#1898), scala.collection.immutable.HashMap#1903, List(TypeRef(ThisType(java.lang#128), java.lang.String#129, List()), TypeRef(ThisType(java.lang#128), java.lang.String#129, List())))

+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#1898), scala.collection.immutable.HashMap#1903, List(TypeRef(ThisType(java.lang#128), java.lang.String#129, List()), TypeRef(ThisType(java.lang#128), java.lang.String#129, List()))))

+[3] TypeRef(ThisType(scala.collection.immutable#1898), scala.collection.immutable.HashMap#1903, List())

+[4] TypeRef(ThisType(java.lang#128), java.lang.String#129, List())

+Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap#1908), List(TypeTree[4]().setOriginal(Ident[4](java.lang.String#129)), TypeTree[4]().setOriginal(Ident[4](java.lang.String#129)))))), nme.CONSTRUCTOR#2231), List())

+[4] TypeRef(ThisType(java.lang#128), java.lang.String#129, List())

+[5] TypeRef(ThisType(scala.collection.mutable#1907), scala.collection.mutable.HashMap#1908, List(TypeRef(ThisType(java.lang#128), java.lang.String#129, List()), TypeRef(ThisType(java.lang#128), java.lang.String#129, List())))

+[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#1907), scala.collection.mutable.HashMap#1908, List(TypeRef(ThisType(java.lang#128), java.lang.String#129, List()), TypeRef(ThisType(java.lang#128), java.lang.String#129, List()))))

+[7] TypeRef(ThisType(scala.collection.mutable#1907), scala.collection.mutable.HashMap#1908, List())

diff --git a/test/files/run/showraw_tree_types_ids.scala b/test/files/run/showraw_tree_types_ids.scala
new file mode 100644
index 0000000000..cb2c2bfb0f
--- /dev/null
+++ b/test/files/run/showraw_tree_types_ids.scala
@@ -0,0 +1,10 @@
+import scala.reflect.runtime.universe._
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = runtimeMirror(getClass.getClassLoader).mkToolBox()
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tb.typeCheck(tree1.tree), printIds = true, printTypes = true))
+  println(showRaw(tb.typeCheck(tree2.tree), printIds = true, printTypes = true))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree_types_typed.check b/test/files/run/showraw_tree_types_typed.check
new file mode 100644
index 0000000000..60176c7192
--- /dev/null
+++ b/test/files/run/showraw_tree_types_typed.check
@@ -0,0 +1,10 @@
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap), List(TypeTree[4]().setOriginal(Ident[4](java.lang.String)), TypeTree[4]().setOriginal(Ident[4](java.lang.String)))))), nme.CONSTRUCTOR), List())

+[1] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(ThisType(java.lang), java.lang.String, List()), TypeRef(ThisType(java.lang), java.lang.String, List())))

+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(ThisType(java.lang), java.lang.String, List()), TypeRef(ThisType(java.lang), java.lang.String, List()))))

+[3] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List())

+[4] TypeRef(ThisType(java.lang), java.lang.String, List())

+Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Ident[4](java.lang.String)), TypeTree[4]().setOriginal(Ident[4](java.lang.String)))))), nme.CONSTRUCTOR), List())

+[4] TypeRef(ThisType(java.lang), java.lang.String, List())

+[5] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(ThisType(java.lang), java.lang.String, List()), TypeRef(ThisType(java.lang), java.lang.String, List())))

+[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(ThisType(java.lang), java.lang.String, List()), TypeRef(ThisType(java.lang), java.lang.String, List()))))

+[7] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List())

diff --git a/test/files/run/showraw_tree_types_typed.scala b/test/files/run/showraw_tree_types_typed.scala
new file mode 100644
index 0000000000..d7ccc84ea3
--- /dev/null
+++ b/test/files/run/showraw_tree_types_typed.scala
@@ -0,0 +1,10 @@
+import scala.reflect.runtime.universe._
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = runtimeMirror(getClass.getClassLoader).mkToolBox()
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tb.typeCheck(tree1.tree), printTypes = true))
+  println(showRaw(tb.typeCheck(tree2.tree), printTypes = true))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree_types_untyped.check b/test/files/run/showraw_tree_types_untyped.check
new file mode 100644
index 0000000000..82724cae44
--- /dev/null
+++ b/test/files/run/showraw_tree_types_untyped.check
@@ -0,0 +1,2 @@
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Ident(java.lang.String), Ident(java.lang.String)))), nme.CONSTRUCTOR), List())

+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Ident(java.lang.String), Ident(java.lang.String)))), nme.CONSTRUCTOR), List())

diff --git a/test/files/run/showraw_tree_types_untyped.scala b/test/files/run/showraw_tree_types_untyped.scala
new file mode 100644
index 0000000000..4df2eb66b2
--- /dev/null
+++ b/test/files/run/showraw_tree_types_untyped.scala
@@ -0,0 +1,8 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tree1.tree, printTypes = true))
+  println(showRaw(tree2.tree, printTypes = true))
+}
\ No newline at end of file
diff --git a/test/files/run/showraw_tree_ultimate.check b/test/files/run/showraw_tree_ultimate.check
new file mode 100644
index 0000000000..0b409554a0
--- /dev/null
+++ b/test/files/run/showraw_tree_ultimate.check
@@ -0,0 +1,10 @@
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#1903#CLS), List(TypeTree[4]().setOriginal(Ident[4](java.lang.String#129#CLS)), TypeTree[4]().setOriginal(Ident[4](java.lang.String#129#CLS)))))), nme.CONSTRUCTOR#1913#PCTOR), List())

+[1] TypeRef(ThisType(scala.collection.immutable#1898#PK), scala.collection.immutable.HashMap#1903#CLS, List(TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List()), TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List())))

+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#1898#PK), scala.collection.immutable.HashMap#1903#CLS, List(TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List()), TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List()))))

+[3] TypeRef(ThisType(scala.collection.immutable#1898#PK), scala.collection.immutable.HashMap#1903#CLS, List())

+[4] TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List())

+Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap#1908#CLS), List(TypeTree[4]().setOriginal(Ident[4](java.lang.String#129#CLS)), TypeTree[4]().setOriginal(Ident[4](java.lang.String#129#CLS)))))), nme.CONSTRUCTOR#2231#CTOR), List())

+[4] TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List())

+[5] TypeRef(ThisType(scala.collection.mutable#1907#PK), scala.collection.mutable.HashMap#1908#CLS, List(TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List()), TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List())))

+[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#1907#PK), scala.collection.mutable.HashMap#1908#CLS, List(TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List()), TypeRef(ThisType(java.lang#128#PK), java.lang.String#129#CLS, List()))))

+[7] TypeRef(ThisType(scala.collection.mutable#1907#PK), scala.collection.mutable.HashMap#1908#CLS, List())

diff --git a/test/files/run/showraw_tree_ultimate.scala b/test/files/run/showraw_tree_ultimate.scala
new file mode 100644
index 0000000000..dfd7abde52
--- /dev/null
+++ b/test/files/run/showraw_tree_ultimate.scala
@@ -0,0 +1,10 @@
+import scala.reflect.runtime.universe._
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = runtimeMirror(getClass.getClassLoader).mkToolBox()
+  val tree1 = reify(new collection.immutable.HashMap[String, String])
+  val tree2 = reify(new collection.mutable.HashMap[String, String])
+  println(showRaw(tb.typeCheck(tree1.tree), printIds = true, printKinds = true, printTypes = true))
+  println(showRaw(tb.typeCheck(tree2.tree), printIds = true, printKinds = true, printTypes = true))
+}
\ No newline at end of file
diff --git a/test/files/run/t3326.check b/test/files/run/t3326.check
new file mode 100644
index 0000000000..d0e11cebf7
--- /dev/null
+++ b/test/files/run/t3326.check
@@ -0,0 +1,8 @@
+Map(2 -> Hello, 1 -> World)
+Map(5 -> Foo, 4 -> Bar)
+Map(5 -> Foo, 4 -> Bar, 2 -> Hello, 1 -> World)
+Map(3 -> ?, 2 -> Hello, 1 -> World)
+Map(2 -> Hello, 1 -> World)
+Map(5 -> Foo, 4 -> Bar)
+Map(5 -> Foo, 4 -> Bar, 2 -> Hello, 1 -> World)
+Map(3 -> ?, 2 -> Hello, 1 -> World)
\ No newline at end of file
diff --git a/test/files/run/t3326.scala b/test/files/run/t3326.scala
new file mode 100644
index 0000000000..f70cb01504
--- /dev/null
+++ b/test/files/run/t3326.scala
@@ -0,0 +1,74 @@
+
+
+
+import scala.math.Ordering
+
+
+
+/** The heart of the problem - we want to retain the ordering when
+ *  using `++` on sorted maps.
+ *
+ *  There are 2 `++` overloads - a generic one in traversables and
+ *  a map-specific one in `MapLike` - which knows about the ordering.
+ *  
+ *  The problem here is that the expected return type for the expression
+ *  in which `++` appears drives the decision of the overload that needs
+ *  to be taken.
+ *  The `collection.SortedMap` does not have `++` overridden to return
+ *  `SortedMap`, but `immutable.Map` instead.
+ *  This is why `collection.SortedMap` used to resort to the generic
+ *  `TraversableLike.++` which knows nothing about the ordering.
+ *  
+ *  To avoid `collection.SortedMap`s resort to the more generic `TraverableLike.++`,
+ *  we override the `MapLike.++` overload in `collection.SortedMap` to return
+ *  the proper type `SortedMap`.
+ */
+object Test {
+  
+  def main(args: Array[String]) {
+    testCollectionSorted()
+    testImmutableSorted()
+  }
+  
+  def testCollectionSorted() {
+    import collection._
+    val order = implicitly[Ordering[Int]].reverse
+    var m1: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    var m2: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    
+    m1 += (1 -> "World")
+    m1 += (2 -> "Hello")
+    
+    m2 += (4 -> "Bar")
+    m2 += (5 -> "Foo")
+    
+    val m3: SortedMap[Int, String] = m1 ++ m2
+    
+    println(m1)
+    println(m2)
+    println(m3)
+    
+    println(m1 + (3 -> "?"))
+  }
+
+  def testImmutableSorted() {
+    import collection.immutable._
+    val order = implicitly[Ordering[Int]].reverse
+    var m1: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    var m2: SortedMap[Int, String] = SortedMap.empty[Int, String](order)
+    
+    m1 += (1 -> "World")
+    m1 += (2 -> "Hello")
+    
+    m2 += (4 -> "Bar")
+    m2 += (5 -> "Foo")
+    
+    val m3: SortedMap[Int, String] = m1 ++ m2
+    
+    println(m1)
+    println(m2)
+    println(m3)
+    
+    println(m1 + (3 -> "?"))
+  }
+}
diff --git a/test/files/run/t4809.scala b/test/files/run/t4809.scala
new file mode 100644
index 0000000000..b30d80562f
--- /dev/null
+++ b/test/files/run/t4809.scala
@@ -0,0 +1,34 @@
+
+
+import scala.util.control.Breaks._
+
+
+
+object Test {
+  
+  def main(args: Array[String]) {
+    val x = tryBreakable {
+      break
+      2
+    } catchBreak {
+      3
+    }
+    assert(x == 3, x)
+    
+    val y = tryBreakable {
+      2
+    } catchBreak {
+      3
+    }
+    assert(y == 2, y)
+    
+    val z = tryBreakable {
+      break
+      1.0
+    } catchBreak {
+      2
+    }
+    assert(z == 2.0, z)
+  }
+  
+}
diff --git a/test/files/run/t4935.check b/test/files/run/t4935.check
new file mode 100644
index 0000000000..ef0493b275
--- /dev/null
+++ b/test/files/run/t4935.check
@@ -0,0 +1 @@
+hello

diff --git a/test/files/run/t4935.flags b/test/files/run/t4935.flags
new file mode 100644
index 0000000000..ac14fe5dbd
--- /dev/null
+++ b/test/files/run/t4935.flags
@@ -0,0 +1 @@
+-optimize

diff --git a/test/files/run/t4935.scala b/test/files/run/t4935.scala
new file mode 100644
index 0000000000..18631e2041
--- /dev/null
+++ b/test/files/run/t4935.scala
@@ -0,0 +1,9 @@
+object Test extends App {

+  for (i <- 0 to 1) {

+    val a = Foo

+  }

+}

+

+object Foo {

+  println("hello")

+}

diff --git a/test/files/run/t4954.scala b/test/files/run/t4954.scala
new file mode 100644
index 0000000000..b4916e651d
--- /dev/null
+++ b/test/files/run/t4954.scala
@@ -0,0 +1,45 @@
+
+
+import collection._
+
+
+object Test {
+  
+  def main(args: Array[String]) {
+    val m = scala.collection.mutable.LinkedHashMap("one" -> 1, "two" -> 2, "three" -> 3, "four" -> 4, "five" -> 5)
+    val expected = List("one", "two", "three", "four", "five")
+    assert(m.keys.iterator.toList == expected)
+    assert(m.keys.drop(0).iterator.toList == expected)
+    assert(m.keys.drop(1).iterator.toList == expected.drop(1))
+    assert(m.keys.drop(2).iterator.toList == expected.drop(2))
+    assert(m.keys.drop(3).iterator.toList == expected.drop(3))
+    assert(m.keys.drop(4).iterator.toList == expected.drop(4))
+    assert(m.keys.drop(5).iterator.toList == expected.drop(5))
+    
+    val expvals = List(1, 2, 3, 4, 5)
+    assert(m.values.iterator.toList == expvals)
+    assert(m.values.drop(0).iterator.toList == expvals)
+    assert(m.values.drop(1).iterator.toList == expvals.drop(1))
+    assert(m.values.drop(2).iterator.toList == expvals.drop(2))
+    assert(m.values.drop(3).iterator.toList == expvals.drop(3))
+    assert(m.values.drop(4).iterator.toList == expvals.drop(4))
+    assert(m.values.drop(5).iterator.toList == expvals.drop(5))
+    
+    val pred = (x: String) => x.length < 6
+    val filtered = m.filterKeys(pred)
+    assert(filtered.drop(0).keys.toList == expected.filter(pred))
+    assert(filtered.drop(1).keys.toList == expected.filter(pred).drop(1))
+    assert(filtered.drop(2).keys.toList == expected.filter(pred).drop(2))
+    assert(filtered.drop(3).keys.toList == expected.filter(pred).drop(3))
+    assert(filtered.drop(4).keys.toList == expected.filter(pred).drop(4))
+    
+    val mapped = m.mapValues(-_)
+    assert(mapped.drop(0).keys.toList == expected)
+    assert(mapped.drop(1).keys.toList == expected.drop(1))
+    assert(mapped.drop(2).keys.toList == expected.drop(2))
+    assert(mapped.drop(3).keys.toList == expected.drop(3))
+    assert(mapped.drop(4).keys.toList == expected.drop(4))
+    assert(mapped.drop(5).keys.toList == expected.drop(5))
+  }
+  
+}
diff --git a/test/files/run/t5284.check b/test/files/run/t5284.check
new file mode 100644
index 0000000000..0cfbf08886
--- /dev/null
+++ b/test/files/run/t5284.check
@@ -0,0 +1 @@
+2
diff --git a/test/files/run/t5284.scala b/test/files/run/t5284.scala
new file mode 100644
index 0000000000..ba0845fb8e
--- /dev/null
+++ b/test/files/run/t5284.scala
@@ -0,0 +1,25 @@
+
+
+
+
+
+/** Here we have a situation where a normalized method parameter `W`
+ *  is used in a position which accepts an instance of type `T` - we know we can
+ *  safely cast `T` to `W` whenever type bounds on `W` hold.
+ */
+object Test {
+  def main(args: Array[String]) {
+    val a = Blarg(Array(1, 2, 3))
+    println(a.m((x: Int) => x + 1))
+  }
+}
+
+
+object Blarg {
+  def apply[T: Manifest](a: Array[T]) = new Blarg(a)
+}
+
+
+class Blarg[@specialized(Int) T: Manifest](val a: Array[T]) {
+  def m[@specialized(Int) W >: T, @specialized(Int) S](f: W => S) = f(a(0))
+}
diff --git a/test/files/run/t5284b.check b/test/files/run/t5284b.check
new file mode 100644
index 0000000000..98d9bcb75a
--- /dev/null
+++ b/test/files/run/t5284b.check
@@ -0,0 +1 @@
+17
diff --git a/test/files/run/t5284b.scala b/test/files/run/t5284b.scala
new file mode 100644
index 0000000000..a9282a895f
--- /dev/null
+++ b/test/files/run/t5284b.scala
@@ -0,0 +1,28 @@
+
+
+
+
+
+
+/** Here we have a situation where a normalized method parameter `W`
+ *  is used in a position which expects a type `T` - we know we can
+ *  safely cast `W` to `T` whenever typebounds of `W` hold.
+ */
+object Test {
+  def main(args: Array[String]) {
+    val foo = Foo.createUnspecialized[Int]
+    println(foo.bar(17))
+  }
+}
+
+
+object Foo {
+  def createUnspecialized[T] = new Foo[T]
+}
+
+
+class Foo[@specialized(Int) T] {
+  val id: T => T = x => x
+  
+  def bar[@specialized(Int) W <: T, @specialized(Int) S](w: W) = id(w)
+}
diff --git a/test/files/run/t5284c.check b/test/files/run/t5284c.check
new file mode 100644
index 0000000000..00750edc07
--- /dev/null
+++ b/test/files/run/t5284c.check
@@ -0,0 +1 @@
+3
diff --git a/test/files/run/t5284c.scala b/test/files/run/t5284c.scala
new file mode 100644
index 0000000000..383b84c2cc
--- /dev/null
+++ b/test/files/run/t5284c.scala
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+/** Here we have a compound type `List[W]` used in
+ *  a position where `List[T]` is expected. The cast
+ *  emitted in the normalized `bar` is safe because the
+ *  normalized `bar` can only be called if the type
+ *  bounds hold.
+ */
+object Test {
+  def main(args: Array[String]) {
+    val foo = Foo.createUnspecialized[Int]
+    println(foo.bar(List(1, 2, 3)))
+  }
+}
+
+
+object Foo {
+  def createUnspecialized[T] = new Foo[T]
+}
+
+
+class Foo[@specialized(Int) T] {
+  val len: List[T] => Int = xs => xs.length
+  
+  def bar[@specialized(Int) W <: T](ws: List[W]) = len(ws)
+}
diff --git a/test/files/run/t5914.check b/test/files/run/t5914.check
new file mode 100644
index 0000000000..818e321255
--- /dev/null
+++ b/test/files/run/t5914.check
@@ -0,0 +1 @@
+correct
diff --git a/test/files/run/t5914.scala b/test/files/run/t5914.scala
new file mode 100644
index 0000000000..45d8815738
--- /dev/null
+++ b/test/files/run/t5914.scala
@@ -0,0 +1,23 @@
+import scala.reflect.ClassTag
+
+trait Trees {
+  class Tree
+  implicit val ttTag: ClassTag[TypeTree]
+  type TypeTree <: Tree
+  val TypeTree: TypeTreeExtractor
+  abstract class TypeTreeExtractor {
+    def unapply(t: TypeTree): Option[String]
+  }
+  def test(tree: Tree) =
+    tree match {
+      case TypeTree(_) => println("lolwut")
+      case null => println("correct")
+    }
+}
+
+object Test extends App with Trees {
+  val ttTag = implicitly[ClassTag[TypeTree]]
+  case class TypeTree(meh: String) extends Tree
+  object TypeTree extends TypeTreeExtractor
+  test(null) // should not crash
+}
\ No newline at end of file
diff --git a/test/files/run/t5966.check b/test/files/run/t5966.check
new file mode 100644
index 0000000000..bfe8358a77
--- /dev/null
+++ b/test/files/run/t5966.check
@@ -0,0 +1,3 @@
+(o()_)("") = List()
+(o("a1")_)("") = WrappedArray(a1)
+(o("a1", "a2")_)("") = WrappedArray(a1, a2)
diff --git a/test/files/run/t5966.scala b/test/files/run/t5966.scala
new file mode 100644
index 0000000000..bbe1a6e874
--- /dev/null
+++ b/test/files/run/t5966.scala
@@ -0,0 +1,9 @@
+object o { def apply(i: AnyRef*)(j: String) = i }
+
+object Test {
+  def main(args: Array[String]) {
+    println("(o()_)(\"\") = " + (o()_)(""))
+    println("(o(\"a1\")_)(\"\") = " + (o("a1")_)(""))
+    println("(o(\"a1\", \"a2\")_)(\"\") = " + (o("a1", "a2")_)(""))
+  }
+}
diff --git a/test/files/run/t5971.check b/test/files/run/t5971.check
new file mode 100644
index 0000000000..0c36a1ff02
--- /dev/null
+++ b/test/files/run/t5971.check
@@ -0,0 +1,4 @@
+r,b
+r
+a,b
+r,a,b
\ No newline at end of file
diff --git a/test/files/run/t5971.scala b/test/files/run/t5971.scala
new file mode 100644
index 0000000000..dbd9beebb3
--- /dev/null
+++ b/test/files/run/t5971.scala
@@ -0,0 +1,23 @@
+
+
+
+
+
+/** When using `AbstractTransformed` abstract inner class in views in order
+ *  to force generating bridges, one must take care to push the corresponding
+ *  collection trait (such as `Iterable` or `Seq`) as far as possible to the
+ *  left in the linearization order -- otherwise, overridden methods from these
+ *  traits can override the already overridden methods in view. This was the
+ *  case with `takeWhile`.
+ *  Mind blowing, I know.
+ */
+object Test {
+  
+  def main(args: Array[String]) {
+    println("bar".view.reverse.filter(_ > 'a').mkString(","))
+    println("bar".view.reverse.take(1).mkString(","))
+    println("bar".view.reverse.dropWhile(_ > 'a').mkString(","))
+    println("bar".view.reverse.takeWhile(_ => true).mkString(","))
+  }
+  
+}
diff --git a/test/files/run/t5986.check b/test/files/run/t5986.check
new file mode 100644
index 0000000000..4101770c6d
--- /dev/null
+++ b/test/files/run/t5986.check
@@ -0,0 +1,15 @@
+Foo(bar, 1)
+Foo(bar, 1)
+Foo(bar, 1),Foo(baz, 3),Foo(bazz, 4)
+Foo(bar, 1)
+Foo(bar, 1)
+Foo(bar, 1),Foo(baz, 3),Foo(bazz, 4)
+Foo(bar, 1)
+Foo(bar, 1)
+Foo(bar, 1),Foo(baz, 3),Foo(bazz, 4)
+Foo(bar, 1)
+Foo(bar, 1)
+Foo(bar, 1),Foo(baz, 3),Foo(bazz, 4)
+Foo(bar, 1)
+Foo(bar, 1)
+Foo(bar, 1),Foo(baz, 3),Foo(bazz, 4)
\ No newline at end of file
diff --git a/test/files/run/t5986.scala b/test/files/run/t5986.scala
new file mode 100644
index 0000000000..8cf7086f98
--- /dev/null
+++ b/test/files/run/t5986.scala
@@ -0,0 +1,36 @@
+
+
+
+import scala.collection._
+
+
+
+/** A sorted set should not replace elements when adding
+ *  and the element already exists in the set.
+ */
+object Test {
+  
+  class Foo(val name: String, val n: Int) {
+    override def equals(obj: Any): Boolean = obj match { case other: Foo => name == other.name; case _ => false }
+    override def hashCode = name.##
+    override def toString = "Foo(" + name + ", " + n + ")"
+  }
+  
+  implicit val ordering: Ordering[Foo] = Ordering.fromLessThan[Foo] { (a, b) => a.name.compareTo(b.name) < 0 }
+  
+  def check[S <: Set[Foo]](set: S) {
+    def output(s: Set[Foo]) = println(s.toList.sorted.mkString(","))
+    output(set + new Foo("bar", 2))
+    output(set ++ List(new Foo("bar", 2), new Foo("bar", 3), new Foo("bar", 4)))
+    output(set union Set(new Foo("bar", 2), new Foo("baz", 3), new Foo("bazz", 4)))
+  }
+  
+  def main(args: Array[String]) {
+    check(Set(new Foo("bar", 1)))
+    check(immutable.Set(new Foo("bar", 1)))
+    check(mutable.Set(new Foo("bar", 1)))
+    check(immutable.SortedSet(new Foo("bar", 1)))
+    check(mutable.SortedSet(new Foo("bar", 1)))
+  }
+  
+}