Merge branch 'master' into execution-context

68 files changed, 906 insertions, 304 deletions

diff --git a/test/files/continuations-neg/t2949.check b/test/files/continuations-neg/t2949.check
index dd9768807c..411aed1b5b 100644
--- a/test/files/continuations-neg/t2949.check
+++ b/test/files/continuations-neg/t2949.check
@@ -1,6 +1,6 @@
 t2949.scala:13: error: type mismatch;
  found   : Int
- required: ? @scala.util.continuations.cpsParam[List[?],Any]
+ required: ? @scala.util.continuations.cpsParam[List[?],?]
     x * y
       ^
 one error found
diff --git a/test/files/jvm/mkLibNatives.bat b/test/files/jvm/mkLibNatives.bat
index e11b6ee21c..2f99f7aab5 100755
--- a/test/files/jvm/mkLibNatives.bat
+++ b/test/files/jvm/mkLibNatives.bat
@@ -67,4 +67,4 @@ goto end
 

 :end

 if "%OS%"=="Windows_NT" @endlocal

-

+exit /b %errorlevel%

diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check
index 8704bcc643..15708f0c3b 100644
--- a/test/files/jvm/serialization.check
+++ b/test/files/jvm/serialization.check
@@ -160,8 +160,8 @@ x = Map(C -> 3, B -> 2, A -> 1)
 y = Map(C -> 3, A -> 1, B -> 2)
 x equals y: true, y equals x: true
 
-x = Set(layers, title, buffers)
-y = Set(layers, title, buffers)
+x = Set(buffers, title, layers)
+y = Set(buffers, title, layers)
 x equals y: true, y equals x: true
 
 x = History()
@@ -279,8 +279,8 @@ x = ParHashMap(1 -> 2, 2 -> 4)
 y = ParHashMap(1 -> 2, 2 -> 4)
 x equals y: true, y equals x: true
 
-x = ParHashSet(2, 1, 3)
-y = ParHashSet(2, 1, 3)
+x = ParHashSet(1, 2, 3)
+y = ParHashSet(1, 2, 3)
 x equals y: true, y equals x: true
 
 x = ParRange(0, 1, 2, 3, 4)
diff --git a/test/files/jvm/xml03syntax.check b/test/files/jvm/xml03syntax.check
index 75dc539137..9fbedc2ae6 100644
--- a/test/files/jvm/xml03syntax.check
+++ b/test/files/jvm/xml03syntax.check
@@ -23,4 +23,4 @@ true
 4
 
 node=<elem key="<b>hello</b>"></elem>, key=Some(<b>hello</b>)
-node=<elem ></elem>, key=None
+node=<elem></elem>, key=None
diff --git a/test/files/neg/checksensible.check b/test/files/neg/checksensible.check
index d45d16165f..0881205bb4 100644
--- a/test/files/neg/checksensible.check
+++ b/test/files/neg/checksensible.check
@@ -28,12 +28,6 @@ checksensible.scala:27: error: comparing values of types Int and Unit using `=='
 checksensible.scala:29: error: comparing values of types Int and String using `==' will always yield false
   1 == "abc"
     ^
-checksensible.scala:32: error: String and Int are unrelated: they will most likely never compare equal
-  "abc" == 1        // warns because the lub of String and Int is Any
-        ^
-checksensible.scala:33: error: Some[Int] and Int are unrelated: they will most likely never compare equal
-  Some(1) == 1      // as above
-          ^
 checksensible.scala:38: error: comparing a fresh object using `==' will always yield false
   new AnyRef == 1
              ^
@@ -100,4 +94,4 @@ checksensible.scala:84: error: comparing values of types EqEqRefTest.this.C3 and
 checksensible.scala:95: error: comparing values of types Unit and Int using `!=' will always yield true
     while ((c = in.read) != -1)
                          ^
-34 errors found
+32 errors found
diff --git a/test/files/neg/logImplicits.check b/test/files/neg/logImplicits.check
new file mode 100644
index 0000000000..d98422dacb
--- /dev/null
+++ b/test/files/neg/logImplicits.check
@@ -0,0 +1,19 @@
+logImplicits.scala:2: applied implicit conversion from xs.type to ?{val size: ?} = implicit def byteArrayOps(xs: Array[Byte]): scala.collection.mutable.ArrayOps[Byte]
+  def f(xs: Array[Byte]) = xs.size
+                           ^
+logImplicits.scala:7: applied implicit conversion from String("abc") to ?{val map: ?} = implicit def augmentString(x: String): scala.collection.immutable.StringOps
+  def f = "abc" map (_ + 1)
+          ^
+logImplicits.scala:15: inferred view from String("abc") to Int = C.this.convert:(p: String("abc"))Int
+  math.max(122, x: Int)
+                ^
+logImplicits.scala:19: applied implicit conversion from Int(1) to ?{val ->: ?} = implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A]
+  def f = (1 -> 2) + "c"
+           ^
+logImplicits.scala:19: applied implicit conversion from (Int, Int) to ?{val +: ?} = implicit def any2stringadd(x: Any): scala.runtime.StringAdd
+  def f = (1 -> 2) + "c"
+             ^
+logImplicits.scala:22: error: class Un needs to be abstract, since method unimplemented is not defined
+class Un {
+      ^
+one error found
diff --git a/test/files/neg/logImplicits.flags b/test/files/neg/logImplicits.flags
new file mode 100644
index 0000000000..97e5ae94ef
--- /dev/null
+++ b/test/files/neg/logImplicits.flags
@@ -0,0 +1 @@
+-Xlog-implicit-conversions
\ No newline at end of file
diff --git a/test/files/neg/logImplicits.scala b/test/files/neg/logImplicits.scala
new file mode 100644
index 0000000000..fb5dd8a025
--- /dev/null
+++ b/test/files/neg/logImplicits.scala
@@ -0,0 +1,25 @@
+class A {
+  def f(xs: Array[Byte]) = xs.size
+  def g(xs: Array[Byte]) = xs.length
+}
+
+class B {
+  def f = "abc" map (_ + 1)
+}
+
+object C {
+  final val x = "abc"
+  
+  implicit def convert(p: x.type): Int = 123
+ 
+  math.max(122, x: Int)
+}
+
+class D {
+  def f = (1 -> 2) + "c"
+}
+
+class Un {
+  // forcing post-typer failure, since we're only interested in the output from the above
+  def unimplemented: Int
+}
\ No newline at end of file
diff --git a/test/files/neg/migration28.check b/test/files/neg/migration28.check
index 97146e88f7..d7dfacf3db 100644
--- a/test/files/neg/migration28.check
+++ b/test/files/neg/migration28.check
@@ -1,6 +1,5 @@
-migration28.scala:4: error: method scanRight in trait TraversableLike has changed semantics:
-This scanRight definition has changed in 2.9.
-The previous behavior can be reproduced with scanRight.reverse.
+migration28.scala:4: error: method scanRight in trait TraversableLike has changed semantics in version 2.9.0:
+The behavior of `scanRight` has changed. The previous behavior can be reproduced with scanRight.reverse.
   List(1,2,3,4,5).scanRight(0)(_+_)
                   ^
 one error found
diff --git a/test/files/neg/names-defaults-neg.check b/test/files/neg/names-defaults-neg.check
index 03e44f745d..01bbe2de4e 100644
--- a/test/files/neg/names-defaults-neg.check
+++ b/test/files/neg/names-defaults-neg.check
@@ -10,8 +10,7 @@ names-defaults-neg.scala:5: error: type mismatch;
 names-defaults-neg.scala:8: error: positional after named argument.
   test1(b = "(*", 23)
                   ^
-names-defaults-neg.scala:13: error: reference to x is ambiguous; it is both, a parameter
-name of the method and the name of a variable currently in scope.
+names-defaults-neg.scala:13: error: reference to x is ambiguous; it is both a method parameter and a variable in scope.
   test2(x = 1)
           ^
 names-defaults-neg.scala:15: error: not found: value c
@@ -26,8 +25,7 @@ names-defaults-neg.scala:17: error: not found: value m
 names-defaults-neg.scala:18: error: not found: value m
   test7 { m = 1 } // no named arguments in argument block
           ^
-names-defaults-neg.scala:19: error: reference to x is ambiguous; it is both, a parameter
-name of the method and the name of a variable currently in scope.
+names-defaults-neg.scala:19: error: reference to x is ambiguous; it is both a method parameter and a variable in scope.
   test8(x = 1)
           ^
 names-defaults-neg.scala:22: error: parameter specified twice: a
@@ -85,7 +83,7 @@ names-defaults-neg.scala:76: error: no type parameters for method test4: (x: T[T
  --- because ---
 argument expression's type is not compatible with formal parameter type;
  found   : List[Int]
- required: ?T[?T[List[?T[X forSome { type X }]]]]
+ required: ?T
 Error occurred in an application involving default arguments.
   test4()
   ^
@@ -118,8 +116,7 @@ names-defaults-neg.scala:93: error: parameter specified twice: b
 names-defaults-neg.scala:98: error: unknown parameter name: m
   f3818(y = 1, m = 1)
                  ^
-names-defaults-neg.scala:131: error: reference to var2 is ambiguous; it is both, a parameter
-name of the method and the name of a variable currently in scope.
+names-defaults-neg.scala:131: error: reference to var2 is ambiguous; it is both a method parameter and a variable in scope.
   delay(var2 = 40)
              ^
 names-defaults-neg.scala:134: error: missing parameter type for expanded function ((x$1) => a = x$1)
@@ -146,15 +143,13 @@ names-defaults-neg.scala:164: error: variable definition needs type because 'x'
 names-defaults-neg.scala:167: error: variable definition needs type because 'x' is used as a named argument in its body.
   def u6 { var x = u.f(x = "32") }
                ^
-names-defaults-neg.scala:170: error: reference to x is ambiguous; it is both, a parameter
-name of the method and the name of a variable currently in scope.
+names-defaults-neg.scala:170: error: reference to x is ambiguous; it is both a method parameter and a variable in scope.
   def u9 { var x: Int = u.f(x = 1) }
                               ^
 names-defaults-neg.scala:177: error: variable definition needs type because 'x' is used as a named argument in its body.
   class u15 { var x = u.f(x = 1) }
                   ^
-names-defaults-neg.scala:180: error: reference to x is ambiguous; it is both, a parameter
-name of the method and the name of a variable currently in scope.
+names-defaults-neg.scala:180: error: reference to x is ambiguous; it is both a method parameter and a variable in scope.
   class u18 { var x: Int = u.f(x = 1) }
                                  ^
 one warning found
diff --git a/test/files/neg/t1960.check b/test/files/neg/t1960.check
index dabf53f126..5238141c4e 100644
--- a/test/files/neg/t1960.check
+++ b/test/files/neg/t1960.check
@@ -1,4 +1,4 @@
-t1960.scala:5: error: parameter 'p' requires field but conflicts with p in 'TBase'
+t1960.scala:5: error: parameter 'p' requires field but conflicts with method p in trait TBase
 class Aclass (p: Int) extends TBase { def g() { f(p) } }
               ^
 one error found
diff --git a/test/files/neg/t5354.check b/test/files/neg/t5354.check
new file mode 100644
index 0000000000..e47cecb5fe
--- /dev/null
+++ b/test/files/neg/t5354.check
@@ -0,0 +1,7 @@
+t5354.scala:9: error: ambiguous implicit values:
+ both method x123 in package foo of type => foo.Bippy
+ and method z of type => foo.Bippy
+ match expected type foo.Bippy
+      implicitly[Bippy]
+                ^
+one error found
diff --git a/test/files/neg/t5354.scala b/test/files/neg/t5354.scala
new file mode 100644
index 0000000000..99b5650155
--- /dev/null
+++ b/test/files/neg/t5354.scala
@@ -0,0 +1,15 @@
+package object foo {
+  implicit def x123: Bippy = new Bippy("x")
+}
+package foo {
+  class Bippy(override val toString: String){ }
+  class Dingus {
+    def f1 = {
+      implicit def z: Bippy = new Bippy("z")
+      implicitly[Bippy]
+    }
+  }
+  object Test extends App {
+    println(new Dingus().f1)
+  }
+}
diff --git a/test/files/neg/t5357.check b/test/files/neg/t5357.check
new file mode 100644
index 0000000000..3385559071
--- /dev/null
+++ b/test/files/neg/t5357.check
@@ -0,0 +1,4 @@
+t5357.scala:5: error: Pattern variables must start with a lower-case letter. (SLS 8.1.1.)
+    case A: N => 1
+          ^
+one error found
diff --git a/test/files/neg/t5357.scala b/test/files/neg/t5357.scala
new file mode 100644
index 0000000000..369a5568a4
--- /dev/null
+++ b/test/files/neg/t5357.scala
@@ -0,0 +1,9 @@
+trait M
+
+case class N() extends M {
+  def mytest(x: M) = x match { 
+    case A: N => 1
+    case _    => 0
+  }
+}
+
diff --git a/test/files/pos/t1459/App.scala b/test/files/pos/t1459/App.scala
index 651b285b17..36e5022e94 100755
--- a/test/files/pos/t1459/App.scala
+++ b/test/files/pos/t1459/App.scala
@@ -1,7 +1,7 @@
 package foo
 import base._
 
-object App extends Application {
+object App extends scala.App {
   class Concrete extends AbstractBase {
      override def doStuff(params:java.lang.String*): Unit = println("doStuff invoked")
   }
diff --git a/test/files/pos/t4063.scala b/test/files/pos/t4063.scala
new file mode 100644
index 0000000000..5e19c42edc
--- /dev/null
+++ b/test/files/pos/t4063.scala
@@ -0,0 +1,39 @@
+trait Parallel
+trait Parallelizable[+ParRepr <: Parallel]
+
+trait PIterableLike[+T, +Repr <: Parallel] extends Parallel with Parallelizable[PIterableLike[T, Repr]]
+
+trait PMap[K, V] extends PIterableLike[(K, V), PMap[K, V]]
+trait PSet[T] extends PIterableLike[T, PSet[T]]
+
+trait CIterableLike[+T, +Repr]
+
+trait CSet[T] extends CIterableLike[T, CSet[T]] with Parallelizable[PSet[T]]
+
+trait CMap[K, V] extends CIterableLike[(K, V), CMap[K, V]] with Parallelizable[PMap[K, V]]
+
+object Test {
+  var x = 0
+
+  def main() {
+    val map: CMap[Int, CSet[Int]] = new CMap[Int, CSet[Int]] {}
+    val set: CSet[Int] = new CSet[Int] {}
+
+    // should infer type argument
+    //map.synchronized[CIterableLike[Any, Any] with Parallelizable[PIterableLike[Any, Parallel with Parallelizable[Parallel]]]] {
+    // or:
+    //map.synchronized[CIterableLike[Any, Any] with Parallelizable[PIterableLike[Any, Parallel]]] {
+    // or, maybe it could also infer existential types:
+    //map.synchronized[CIterableLike[Any, _] with Parallelizable[PIterableLike[Any, _]]] {
+
+    map.synchronized {
+      if (x == 0) {
+        map
+      } else {
+        set
+      }
+    }
+
+  }
+}
+
diff --git a/test/files/pos/t4070.scala b/test/files/pos/t4070.scala
new file mode 100644
index 0000000000..29c8d16e30
--- /dev/null
+++ b/test/files/pos/t4070.scala
@@ -0,0 +1,37 @@
+package a {
+  // method before classes
+  trait Foo {
+    def crash(x: Dingus[_]): Unit = x match { case m: Bippy[tv] => () }
+
+    class Dingus[T]
+    class Bippy[CC[X] <: Seq[X]]() extends Dingus[CC[Int]]
+  }
+}
+
+package b {
+  // classes before method
+  trait Foo {
+    class Dingus[T]
+    class Bippy[CC[X] <: Seq[X]]() extends Dingus[CC[Int]]
+
+    def crash(x: Dingus[_]): Unit = x match { case m: Bippy[tv] => () }
+  }
+}
+
+
+/*
+// With crash below the clasess:
+% scalac -Dscalac.debug.tvar ./a.scala 
+[    create] ?_$1                     ( In Foo#crash )
+[   setInst] tv[Int]                  ( In Foo#crash, _$1=tv[Int] )
+[    create] tv[Int]                  ( In Foo#crash )
+[     clone] tv[Int]                  ( Foo#crash )
+
+// With crash above the classes:
+% scalac -Dscalac.debug.tvar ./a.scala 
+[    create] ?tv                      ( In Foo#crash )
+./a.scala:2: error: Invalid type application in TypeVar: List(), List(Int)
+  def crash(x: Dingus[_]): Unit = x match { case m: Bippy[tv] => () }
+                                                  ^
+one error found
+*/
diff --git a/test/files/pos/t4070b.scala b/test/files/pos/t4070b.scala
new file mode 100644
index 0000000000..36d03de80c
--- /dev/null
+++ b/test/files/pos/t4070b.scala
@@ -0,0 +1,35 @@
+package a {
+  abstract class DeliteOp[B]
+  abstract class DeliteCollection[A]
+  abstract class Exp[T] { def Type: T }
+
+  trait DeliteOpMap[A,B,C[X] <: DeliteCollection[X]] extends DeliteOp[C[B]] {
+    val in: Exp[C[A]]
+    val func: Exp[B]
+    val alloc: Exp[C[B]]
+  }
+
+  object Test {
+    def f(x: DeliteOp[_]) = x match {
+      case map: DeliteOpMap[_,_,_] => map.alloc.Type
+    }
+  }
+}
+
+package b {
+  object Test {
+    def f(x: DeliteOp[_]) = x match {
+      case map: DeliteOpMap[_,_,_] => map.alloc.Type
+    }
+  }
+
+  abstract class DeliteOp[B]
+  abstract class DeliteCollection[A]
+  abstract class Exp[T] { def Type: T }
+
+  trait DeliteOpMap[A,B,C[X] <: DeliteCollection[X]] extends DeliteOp[C[B]] {
+    val in: Exp[C[A]]
+    val func: Exp[B]
+    val alloc: Exp[C[B]]
+  }
+}
\ No newline at end of file
diff --git a/test/files/pos/t4273.scala b/test/files/pos/t4273.scala
new file mode 100644
index 0000000000..9a942e8325
--- /dev/null
+++ b/test/files/pos/t4273.scala
@@ -0,0 +1,8 @@
+class A {
+  implicit def compareComparables[T](x: T)(implicit ord: Ordering[T]) = new ord.Ops(x)
+  
+  class Bippy
+  implicit val bippyOrdering = new Ordering[Bippy] { def compare(x: Bippy, y: Bippy) = util.Random.nextInt }
+  
+  (new Bippy) < (new Bippy)
+}
\ No newline at end of file
diff --git a/test/files/pos/t5020.scala b/test/files/pos/t5020.scala
new file mode 100644
index 0000000000..06f7723f9f
--- /dev/null
+++ b/test/files/pos/t5020.scala
@@ -0,0 +1,19 @@
+package a {
+  sealed trait GenericList[U, M[_ <: U]] {
+    type Transformed[N[MMA <: U]] <: GenericList[U, N]
+  }
+
+  trait GenericCons[U, M[_ <: U], T <: GenericList[U, M]] extends GenericList[U, M] {
+    type Transformed[N[MMB <: U]] = GenericCons[U, N, GenericList[U, M]#Transformed[N]]
+  }
+}
+
+package b {
+  sealed trait GenericList[L, M[_ >: L]] {
+    type Transformed[N[MMA >: L]] <: GenericList[L, N]
+  }
+
+  trait GenericCons[L, M[_ >: L], T <: GenericList[L, M]] extends GenericList[L, M] {
+    type Transformed[N[MMB >: L]] = GenericCons[L, N, T#Transformed[N]]
+  }
+}
\ No newline at end of file
diff --git a/test/files/pos/t5119.scala b/test/files/pos/t5119.scala
new file mode 100644
index 0000000000..4a67244e50
--- /dev/null
+++ b/test/files/pos/t5119.scala
@@ -0,0 +1,13 @@
+import collection.mutable
+
+object Test {
+  class IMap0[K[_], V[_]](backing: Map[K[_], V[_]]) {
+    def mapSeparate[VL[_], VR[_]](f: V[_] => ({type l[T] = Either[VL[T], VR[T]]})#l[_] ) = {
+      backing.view.map { case (k,v) => f(v) match {
+	case Left(l) => Left((k, l))
+	case Right(r) => Right((k, r))
+        }
+      }
+    }
+  }
+}
diff --git a/test/files/pos/t5175.flags b/test/files/pos/t5175.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/pos/t5175.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/t5175.scala b/test/files/pos/t5175.scala
new file mode 100644
index 0000000000..e15cc3affd
--- /dev/null
+++ b/test/files/pos/t5175.scala
@@ -0,0 +1,9 @@
+object Test {
+  def ==(p: Phase): Int = 0
+
+  def foo {
+    ==(new Phase())
+  }
+}
+
+class Phase
diff --git a/test/files/pos/t5317.scala b/test/files/pos/t5317.scala
new file mode 100644
index 0000000000..8c9c9d8222
--- /dev/null
+++ b/test/files/pos/t5317.scala
@@ -0,0 +1,12 @@
+object Test {
+  trait S { type T; val x: AnyRef }
+  trait A extends S { type T <: A; val x: A = null }
+  trait B extends S { type T <: B; val x: B = null }
+  
+  val a = new A{}
+  val b = new B{}
+  val y = if (true) a else b
+  
+  // lub of y should allow for this
+  println(y.x.x)
+}
diff --git a/test/files/pos/t5359.scala b/test/files/pos/t5359.scala
new file mode 100644
index 0000000000..c22b2b1c76
--- /dev/null
+++ b/test/files/pos/t5359.scala
@@ -0,0 +1,17 @@
+// /scala/trac/5359/a.scala
+// Thu Jan  5 13:31:05 PST 2012
+
+object test {
+  trait Step[F[_]] {
+    // crash: typeConstructor inapplicable for <none>
+    this match {
+      case S1() =>
+    }
+  }
+  case class S1[F[_]]() extends Step[F]
+
+  // okay
+  (null: Step[Option]) match {
+    case S1() =>
+  }
+}
diff --git a/test/files/pos/virtpatmat_alts_subst.flags b/test/files/pos/virtpatmat_alts_subst.flags
new file mode 100644
index 0000000000..9769db9257
--- /dev/null
+++ b/test/files/pos/virtpatmat_alts_subst.flags
@@ -0,0 +1 @@
+ -Yvirtpatmat -Xexperimental
diff --git a/test/files/pos/virtpatmat_alts_subst.scala b/test/files/pos/virtpatmat_alts_subst.scala
new file mode 100644
index 0000000000..e27c52f9c7
--- /dev/null
+++ b/test/files/pos/virtpatmat_alts_subst.scala
@@ -0,0 +1,6 @@
+case class Foo(s: String) {
+  def appliedType(tycon: Any) =
+    tycon match {
+        case Foo(sym @ ("NothingClass" | "AnyClass")) => println(sym)
+    }
+}
diff --git a/test/files/pos/virtpatmat_binding_opt.flags b/test/files/pos/virtpatmat_binding_opt.flags
new file mode 100644
index 0000000000..9769db9257
--- /dev/null
+++ b/test/files/pos/virtpatmat_binding_opt.flags
@@ -0,0 +1 @@
+ -Yvirtpatmat -Xexperimental
diff --git a/test/files/pos/virtpatmat_binding_opt.scala b/test/files/pos/virtpatmat_binding_opt.scala
new file mode 100644
index 0000000000..962e3d7dbe
--- /dev/null
+++ b/test/files/pos/virtpatmat_binding_opt.scala
@@ -0,0 +1,11 @@
+class Test {
+  def combine = this match {
+    case that if that eq this => this // just return this
+    case that: Test2 =>
+      println(that)
+      this
+    case _ => error("meh")
+  }
+}
+
+class Test2 extends Test
\ No newline at end of file
diff --git a/test/files/presentation/properties.check b/test/files/presentation/properties.check
deleted file mode 100644
index a721d49e3a..0000000000
--- a/test/files/presentation/properties.check
+++ /dev/null
@@ -1,158 +0,0 @@
-reload: properties.scala
-
-askTypeCompletion at properties.scala(29,33)
-================================================================================
-[response] aksTypeCompletion at (29,33)
-retrieved 50 members
-`method !=(x$1: Any)Boolean`
-`method !=(x$1: AnyRef)Boolean`
-`method ##()Int`
-`method +(other: String)String`
-`method ->[B](y: B)(properties.Property[String], B)`
-`method ==(x$1: Any)Boolean`
-`method ==(x$1: AnyRef)Boolean`
-`method apply()String`
-`method asInstanceOf[T0]=> T0`
-`method canEqual(that: Any)Boolean`
-`method clone()Object`
-`method ensuring(cond: Boolean)properties.Property[String]`
-`method ensuring(cond: Boolean, msg: => Any)properties.Property[String]`
-`method ensuring(cond: properties.Property[String] => Boolean)properties.Property[String]`
-`method ensuring(cond: properties.Property[String] => Boolean, msg: => Any)properties.Property[String]`
-`method eq(x$1: AnyRef)Boolean`
-`method equals(x$1: Any)Boolean`
-`method finalize()Unit`
-`method formatted(fmtstr: String)String`
-`method get(newGetter: String => String)properties.Property[String]`
-`method hashCode()Int`
-`method isInstanceOf[T0]=> Boolean`
-`method ne(x$1: AnyRef)Boolean`
-`method notify()Unit`
-`method notifyAll()Unit`
-`method productArity=> Int`
-`method productElement(n: Int)Any`
-`method productIterator=> Iterator[Any]`
-`method productPrefix=> String`
-`method set(newSetter: String => String)properties.Property[String]`
-`method synchronized[T0](x$1: T0)T0`
-`method toString()String`
-`method update(newValue: String)Unit`
-`method wait()Unit`
-`method wait(x$1: Long)Unit`
-`method wait(x$1: Long, x$2: Int)Unit`
-`method x=> properties.Property[String]`
-`method →[B](y: B)(properties.Property[String], B)`
-`value __leftOfArrowproperties.Property[String]`
-`value __resultOfEnsuringproperties.Property[String]`
-`value initString`
-`value selfAny`
-`variable getterString => String`
-`variable setterString => String`
-`variable valueString`
-================================================================================
-
-askTypeCompletion at properties.scala(29,67)
-================================================================================
-[response] aksTypeCompletion at (29,67)
-retrieved 50 members
-`method !=(x$1: Any)Boolean`
-`method !=(x$1: AnyRef)Boolean`
-`method ##()Int`
-`method +(other: String)String`
-`method ->[B](y: B)(properties.Property[String], B)`
-`method ==(x$1: Any)Boolean`
-`method ==(x$1: AnyRef)Boolean`
-`method apply()String`
-`method asInstanceOf[T0]=> T0`
-`method canEqual(that: Any)Boolean`
-`method clone()Object`
-`method ensuring(cond: Boolean)properties.Property[String]`
-`method ensuring(cond: Boolean, msg: => Any)properties.Property[String]`
-`method ensuring(cond: properties.Property[String] => Boolean)properties.Property[String]`
-`method ensuring(cond: properties.Property[String] => Boolean, msg: => Any)properties.Property[String]`
-`method eq(x$1: AnyRef)Boolean`
-`method equals(x$1: Any)Boolean`
-`method finalize()Unit`
-`method formatted(fmtstr: String)String`
-`method get(newGetter: String => String)properties.Property[String]`
-`method hashCode()Int`
-`method isInstanceOf[T0]=> Boolean`
-`method ne(x$1: AnyRef)Boolean`
-`method notify()Unit`
-`method notifyAll()Unit`
-`method productArity=> Int`
-`method productElement(n: Int)Any`
-`method productIterator=> Iterator[Any]`
-`method productPrefix=> String`
-`method set(newSetter: String => String)properties.Property[String]`
-`method synchronized[T0](x$1: T0)T0`
-`method toString()String`
-`method update(newValue: String)Unit`
-`method wait()Unit`
-`method wait(x$1: Long)Unit`
-`method wait(x$1: Long, x$2: Int)Unit`
-`method x=> properties.Property[String]`
-`method →[B](y: B)(properties.Property[String], B)`
-`value __leftOfArrowproperties.Property[String]`
-`value __resultOfEnsuringproperties.Property[String]`
-`value initString`
-`value selfAny`
-`variable getterString => String`
-`variable setterString => String`
-`variable valueString`
-================================================================================
-
-askTypeCompletion at properties.scala(45,10)
-================================================================================
-[response] aksTypeCompletion at (45,10)
-retrieved 38 members
-`method !=(x$1: Any)Boolean`
-`method !=(x$1: AnyRef)Boolean`
-`method ##()Int`
-`method +(other: String)String`
-`method ->[B](y: B)(properties.User, B)`
-`method ==(x$1: Any)Boolean`
-`method ==(x$1: AnyRef)Boolean`
-`method asInstanceOf[T0]=> T0`
-`method clone()Object`
-`method ensuring(cond: Boolean)properties.User`
-`method ensuring(cond: Boolean, msg: => Any)properties.User`
-`method ensuring(cond: properties.User => Boolean)properties.User`
-`method ensuring(cond: properties.User => Boolean, msg: => Any)properties.User`
-`method eq(x$1: AnyRef)Boolean`
-`method equals(x$1: Any)Boolean`
-`method finalize()Unit`
-`method formatted(fmtstr: String)String`
-`method hashCode()Int`
-`method isInstanceOf[T0]=> Boolean`
-`method ne(x$1: AnyRef)Boolean`
-`method notify()Unit`
-`method notifyAll()Unit`
-`method synchronized[T0](x$1: T0)T0`
-`method toString()String`
-`method wait()Unit`
-`method wait(x$1: Long)Unit`
-`method wait(x$1: Long, x$2: Int)Unit`
-`method x=> properties.User`
-`method →[B](y: B)(properties.User, B)`
-`value __leftOfArrowproperties.User`
-`value __resultOfEnsuringproperties.User`
-`value firstnameproperties.Property[String]`
-`value lastnameproperties.Property[String]`
-`value selfAny`
-================================================================================
-
-askType at properties.scala(18,28)
-================================================================================
-[response] askTypeAt at (18,28)
-def update(newValue: T): Unit = Property.this.value_=(Property.this.setter.apply(newValue))
-================================================================================
-
-askType at properties.scala(21,31)
-================================================================================
-[response] askTypeAt at (21,31)
-def get(newGetter: T => T): properties.Property[T] = {
-  Property.this.getter_=(newGetter);
-  this
-}
-================================================================================
diff --git a/test/files/presentation/properties/Runner.scala b/test/files/presentation/properties/Runner.scala
deleted file mode 100644
index 1ef3cf9025..0000000000
--- a/test/files/presentation/properties/Runner.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-import scala.tools.nsc.interactive.tests._
-
-object Test extends InteractiveTest
\ No newline at end of file
diff --git a/test/files/presentation/properties/src/properties.scala b/test/files/presentation/properties/src/properties.scala
deleted file mode 100644
index 35b6a92221..0000000000
--- a/test/files/presentation/properties/src/properties.scala
+++ /dev/null
@@ -1,54 +0,0 @@
-/** Illustrate the use of custom 'apply/update' methods. */
-object properties {
-
-  /** A mutable property whose getter and setter may be customized. */
-  case class Property[T](init: T) {
-    private var value: T = init
-
-    /** The getter function, defaults to identity. */
-    private var setter: T => T = identity[T]
-
-    /** The setter function, defaults to identity. */
-    private var getter: T => T = identity[T]
-
-    /** Retrive the value held in this property.   */
-    def apply(): T = getter(value)
-
-    /** Update the value held in this property, through the setter. */
-    def update(newValue: T) /*?*/ = value = setter(newValue)
-
-    /** Change the getter. */
-    def get(newGetter: T => T) /*?*/ = { getter = newGetter; this }
-
-    /** Change the setter */
-    def set(newSetter: T => T) = { setter = newSetter; this }
-  }
-
-  class User {
-    // Create a property with custom getter and setter
-    val firstname = Property("")./*!*/get { v => v.toUpperCase() }./*!*/set { v => "Mr. " + v }
-    val lastname = Property("<noname>")
-
-    /** Scala provides syntactic sugar for calling 'apply'. Simply
-     *  adding a list of arguments between parenthesis (in this case,
-     *  an empty list) is translated to a call to 'apply' with those
-     *  arguments.
-     */
-    override def toString() = firstname() + " " + lastname()
-  }
-
-  def main(args: Array[String]) {
-    val user1 = new User
-
-    // Syntactic sugar for 'update': an assignment is translated to a
-    // call to method 'update'
-    user1./*!*/firstname() = "Robert"
-
-    val user2 = new User
-    user2.firstname() = "bob"
-    user2.lastname() = "KUZ"
-
-    println("user1: " + user1)
-    println("user2: " + user2)
-  }
-}
\ No newline at end of file
diff --git a/test/files/run/array-existential-bound.check b/test/files/run/array-existential-bound.check
new file mode 100644
index 0000000000..f5cca843e3
--- /dev/null
+++ b/test/files/run/array-existential-bound.check
@@ -0,0 +1,4 @@
+2
+1000
+1000
+26
diff --git a/test/files/run/array-existential-bound.scala b/test/files/run/array-existential-bound.scala
new file mode 100644
index 0000000000..bc442d39f7
--- /dev/null
+++ b/test/files/run/array-existential-bound.scala
@@ -0,0 +1,17 @@
+trait Fooz[Q <: Array[_]] {
+  def f0(x: Q) = x.length
+}
+
+object Test extends Fooz[Array[Int]] {
+  val f1 = new Fooz[Array[String]] { }
+  val f2 = new Fooz[Array[Int]] { }
+  val f3 = new Fooz[Array[Any]] { }
+  val f4 = new Fooz[Array[_]] { }
+  
+  def main(args: Array[String]): Unit = {
+    println(f1.f0(Array[String]("a", "b")))
+    println(f2.f0(1 to 1000 toArray))
+    println(f3.f0((1 to 1000).toArray[Any]))
+    println(f4.f0('a' to 'z' toArray))
+  }
+}
diff --git a/test/files/run/mixin-bridge-methods.scala b/test/files/run/mixin-bridge-methods.scala
new file mode 100644
index 0000000000..e0340ebb12
--- /dev/null
+++ b/test/files/run/mixin-bridge-methods.scala
@@ -0,0 +1,14 @@
+trait Foo {
+  def getFoo() = "foo"
+}
+
+class Sub extends Foo {
+  def getBar() = "bar"
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val ms = classOf[Sub].getDeclaredMethods
+    assert(ms forall (x => !x.isBridge), ms mkString " ")
+  }
+}
diff --git a/test/files/run/origins.scala b/test/files/run/origins.scala
index ab873bca89..9dc6071c7b 100644
--- a/test/files/run/origins.scala
+++ b/test/files/run/origins.scala
@@ -1,4 +1,4 @@
-import scala.tools.nsc.util.Origins
+import scala.reflect.internal.util.Origins
 
 package goxbox {
   object Socks {
diff --git a/test/files/run/repl-power.check b/test/files/run/repl-power.check
index 38e7532133..1e7b6f0cd8 100644
--- a/test/files/run/repl-power.check
+++ b/test/files/run/repl-power.check
@@ -2,15 +2,31 @@ Type in expressions to have them evaluated.
 Type :help for more information.
 
 scala> :power
-** Power User mode enabled - BEEP BOOP SPIZ **
+** Power User mode enabled - BEEP WHIR GYVE **
 ** :phase has been set to 'typer'.          **
 ** scala.tools.nsc._ has been imported      **
-** global._ and definitions._ also imported **
-** Try  :help,  vals.<tab>,  power.<tab>    **
+** global._, definitions._ also imported    **
+** Try  :help, :vals, power.<tab>           **
 
 scala> // guarding against "error: reference to global is ambiguous"
 
 scala> global.emptyValDef  // "it is imported twice in the same scope by ..."
 res0: $r.global.emptyValDef.type = private val _ = _
 
+scala> val tp = ArrayClass[scala.util.Random]    // magic with manifests
+tp: $r.global.Type = Array[scala.util.Random]
+
+scala> tp.memberType(Array_apply)                // evidence
+res1: $r.global.Type = (i: Int)scala.util.Random
+
+scala> val m = LIT(10) MATCH (CASE(LIT(5)) ==> FALSE, DEFAULT ==> TRUE) // treedsl
+m: $r.treedsl.global.Match = 
+10 match {
+  case 5 => false
+  case _ => true
+}
+
+scala> typed(m).tpe                              // typed is in scope
+res2: $r.treedsl.global.Type = Boolean
+
 scala> 
diff --git a/test/files/run/repl-power.scala b/test/files/run/repl-power.scala
index 9f70ac4b68..27da3df106 100644
--- a/test/files/run/repl-power.scala
+++ b/test/files/run/repl-power.scala
@@ -5,6 +5,10 @@ object Test extends ReplTest {
 :power
 // guarding against "error: reference to global is ambiguous"
 global.emptyValDef  // "it is imported twice in the same scope by ..."
+val tp = ArrayClass[scala.util.Random]    // magic with manifests
+tp.memberType(Array_apply)                // evidence
+val m = LIT(10) MATCH (CASE(LIT(5)) ==> FALSE, DEFAULT ==> TRUE) // treedsl
+typed(m).tpe                              // typed is in scope
   """.trim
 }
 
diff --git a/test/files/run/t3758.scala b/test/files/run/t3758.scala
new file mode 100644
index 0000000000..18750b0a9c
--- /dev/null
+++ b/test/files/run/t3758.scala
@@ -0,0 +1,10 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(classManifest[Array[String]].typeArguments contains classManifest[String])
+    assert(classManifest[Array[Int]].typeArguments contains classManifest[Int])
+    assert(classManifest[Array[Float]].typeArguments contains classManifest[Float])
+    assert(manifest[Array[String]].typeArguments contains manifest[String])
+    assert(manifest[Array[Int]].typeArguments contains manifest[Int])
+    assert(manifest[Array[Float]].typeArguments contains manifest[Float])
+  }
+}
diff --git a/test/files/run/t4024.scala b/test/files/run/t4024.scala
index ef768beb99..7c62a3fc6e 100644
--- a/test/files/run/t4024.scala
+++ b/test/files/run/t4024.scala
@@ -5,5 +5,16 @@ object Test extends App {
   val m = x.getClass.getMethod("toString")
   
   assert(m.invoke(x, (Nil: List[AnyRef]): _*) == "abc")
+
+  Test2.main(Array())
 }
 
+
+object Test2 {
+  def main(args: Array[String]): Unit = {
+    val x = "abc"
+    val m = x.getClass.getMethod("toString")
+    m.invoke(x, Nil: _*)
+    m.invoke(x, Seq(): _*)
+  }
+}
diff --git a/test/files/run/t4871.check b/test/files/run/t4871.check
new file mode 100644
index 0000000000..a60526a0f3
--- /dev/null
+++ b/test/files/run/t4871.check
@@ -0,0 +1,2 @@
+class Test$C
+class Test$D
diff --git a/test/files/run/t4871.scala b/test/files/run/t4871.scala
new file mode 100644
index 0000000000..70d8b7145c
--- /dev/null
+++ b/test/files/run/t4871.scala
@@ -0,0 +1,12 @@
+object Test {
+  class C
+  class D
+
+  def main(args: Array[String]): Unit = {
+    val z: Class[C] = classOf
+    val z2: Class[D] = classOf[D]
+    
+    println(z)
+    println(z2)
+  }
+}
diff --git a/test/files/run/t5053.check b/test/files/run/t5053.check
new file mode 100644
index 0000000000..5ec39bbdeb
--- /dev/null
+++ b/test/files/run/t5053.check
@@ -0,0 +1,6 @@
+true
+true
+true
+true
+true
+true
diff --git a/test/files/run/t5053.scala b/test/files/run/t5053.scala
new file mode 100644
index 0000000000..e46dad5ac6
--- /dev/null
+++ b/test/files/run/t5053.scala
@@ -0,0 +1,20 @@
+object Test extends App {
+  {
+    val (left, right) = Seq((1, "a"), (1, "a"), (1, "a"), (3, "c")).view.unzip
+    println(left.isInstanceOf[scala.collection.SeqViewLike[_,_,_]])
+    val (l, m, r) = Seq((1, 1.0, "a"), (1, 1.0, "a"), (1, 1.0, "a"), (3, 3.0, "c")).view.unzip3
+    println(l.isInstanceOf[scala.collection.SeqViewLike[_,_,_]])  
+  }
+  {
+    val (left, right) = Iterable((1, "a"), (1, "a"), (1, "a"), (3, "c")).view.unzip
+    println(left.isInstanceOf[scala.collection.IterableViewLike[_,_,_]])
+    val (l, m, r) = Iterable((1, 1.0, "a"), (1, 1.0, "a"), (1, 1.0, "a"), (3, 3.0, "c")).view.unzip3
+    println(l.isInstanceOf[scala.collection.IterableViewLike[_,_,_]])  
+  }
+  {
+    val (left, right) = Traversable((1, "a"), (1, "a"), (1, "a"), (3, "c")).view.unzip
+    println(left.isInstanceOf[scala.collection.TraversableViewLike[_,_,_]])
+    val (l, m, r) = Traversable((1, 1.0, "a"), (1, 1.0, "a"), (1, 1.0, "a"), (3, 3.0, "c")).view.unzip3
+    println(l.isInstanceOf[scala.collection.TraversableViewLike[_,_,_]])  
+  }
+}
diff --git a/test/files/run/t5239.check b/test/files/run/t5239.check
deleted file mode 100644
index db5778f95b..0000000000
--- a/test/files/run/t5239.check
+++ /dev/null
@@ -1,13 +0,0 @@
-result = 2{Int(2)}
-[[syntax trees at end of typer]]// Scala source: NoSourceFile
-package <empty> {
-  final object __wrapper$1 extends Object {
-    def this(): object __wrapper$1 = {
-      __wrapper$1.super.this();
-      ()
-    };
-    <static> def wrapper(): Int = 2
-  }
-}
-
-evaluated = 2
diff --git a/test/files/run/t5266_1.check b/test/files/run/t5266_1.check
new file mode 100644
index 0000000000..3feac16a0b
--- /dev/null
+++ b/test/files/run/t5266_1.check
@@ -0,0 +1,2 @@
+2
+evaluated = null
\ No newline at end of file
diff --git a/test/files/run/t5266_1.scala b/test/files/run/t5266_1.scala
new file mode 100644
index 0000000000..18e288e685
--- /dev/null
+++ b/test/files/run/t5266_1.scala
@@ -0,0 +1,16 @@
+import scala.tools.nsc.reporters._
+import scala.tools.nsc.Settings
+import reflect.runtime.Mirror.ToolBox
+
+object Test extends App {
+  val code = scala.reflect.Code.lift{
+    def x = 2
+    println(x)
+  };
+
+  val reporter = new ConsoleReporter(new Settings)
+  val toolbox = new ToolBox(reporter)
+  val ttree = toolbox.typeCheck(code.tree)
+  val evaluated = toolbox.runExpr(ttree)
+  println("evaluated = " + evaluated)
+}
\ No newline at end of file
diff --git a/test/files/run/t5266_2.check b/test/files/run/t5266_2.check
new file mode 100644
index 0000000000..3feac16a0b
--- /dev/null
+++ b/test/files/run/t5266_2.check
@@ -0,0 +1,2 @@
+2
+evaluated = null
\ No newline at end of file
diff --git a/test/files/run/t5239.scala b/test/files/run/t5266_2.scala
index 1f404196ba..eb319583f8 100644
--- a/test/files/run/t5239.scala
+++ b/test/files/run/t5266_2.scala
@@ -4,17 +4,14 @@ import reflect.runtime.Mirror.ToolBox
 
 object Test extends App {
   val code = scala.reflect.Code.lift{
-    2
+    def x = 2
+    def y = x
+    println(y)
   };
 
-  val settings = new Settings
-  settings.Xprint.value = List("typer")
-
-  val reporter = new ConsoleReporter(settings)
+  val reporter = new ConsoleReporter(new Settings)
   val toolbox = new ToolBox(reporter)
   val ttree = toolbox.typeCheck(code.tree)
-  println("result = " + toolbox.showAttributed(ttree))
-
   val evaluated = toolbox.runExpr(ttree)
   println("evaluated = " + evaluated)
 }
diff --git a/test/files/run/t5293.scala b/test/files/run/t5293.scala
new file mode 100644
index 0000000000..de1efaec4a
--- /dev/null
+++ b/test/files/run/t5293.scala
@@ -0,0 +1,83 @@
+
+
+
+import scala.collection.JavaConverters._
+
+
+
+object Test extends App {
+  
+  def bench(label: String)(body: => Unit): Long = {
+    val start = System.nanoTime
+
+    0.until(10).foreach(_ => body)
+
+    val end = System.nanoTime
+
+    //println("%s: %s ms".format(label, (end - start) / 1000.0 / 1000.0))
+    
+    end - start
+  }
+  
+  def benchJava(values: java.util.Collection[Int]) = {
+    bench("Java Set") {
+      val set = new java.util.HashSet[Int]
+      
+      set.addAll(values)
+    }
+  }
+
+  def benchScala(values: Iterable[Int]) = {
+    bench("Scala Set") {
+      val set = new scala.collection.mutable.HashSet[Int]
+      
+      set ++= values
+    }
+  }
+  
+  def benchScalaSorted(values: Iterable[Int]) = {
+    bench("Scala Set sorted") {
+      val set = new scala.collection.mutable.HashSet[Int]
+      
+      set ++= values.toArray.sorted
+    }
+  }
+  
+  def benchScalaPar(values: Iterable[Int]) = {
+    bench("Scala ParSet") {
+      val set = new scala.collection.parallel.mutable.ParHashSet[Int] map { x => x }
+      
+      set ++= values
+    }
+  }
+  
+  val values = 0 until 50000
+  val set = scala.collection.mutable.HashSet.empty[Int]
+  
+  set ++= values
+  
+  // warmup
+  for (x <- 0 until 5) {
+    benchJava(set.asJava)
+    benchScala(set)
+    benchScalaPar(set)
+    benchJava(set.asJava)
+    benchScala(set)
+    benchScalaPar(set)
+  }
+  
+  val javaset = benchJava(set.asJava)
+  val scalaset = benchScala(set)
+  val scalaparset = benchScalaPar(set)
+  
+  assert(scalaset < (javaset * 4))
+  assert(scalaparset < (javaset * 4))
+}
+
+
+
+
+
+
+
+
diff --git a/test/files/run/t5300.scala b/test/files/run/t5300.scala
new file mode 100644
index 0000000000..073b29604a
--- /dev/null
+++ b/test/files/run/t5300.scala
@@ -0,0 +1,7 @@
+object Test {
+  val pf: PartialFunction[Any, Unit] = { case _ => () }
+  
+  def main(args: Array[String]): Unit = {
+    pf orElse pf
+  }
+}
diff --git a/test/files/run/t5356.check b/test/files/run/t5356.check
new file mode 100644
index 0000000000..21c4aef07b
--- /dev/null
+++ b/test/files/run/t5356.check
@@ -0,0 +1,6 @@
+1 scala.runtime.RichInt
+1 scala.runtime.RichInt
+1 scala.math.BigInt
+1 scala.runtime.RichDouble
+1 scala.runtime.RichFloat
+1
diff --git a/test/files/run/t5356.scala b/test/files/run/t5356.scala
new file mode 100644
index 0000000000..f7696c6088
--- /dev/null
+++ b/test/files/run/t5356.scala
@@ -0,0 +1,12 @@
+object Test {
+  def f(x: { def toInt: Int }) = println(x.toInt + " " + x.getClass.getName)
+  
+  def main(args: Array[String]): Unit = {
+    f(1)
+    f(1.toInt)
+    f(BigInt(1))
+    f(1d)
+    f(1f)
+    println((1: { def toInt: Int }).toInt)
+  }
+}
diff --git a/test/files/run/treePrint.scala b/test/files/run/treePrint.scala
index 745c2150c2..e0332a705f 100644
--- a/test/files/run/treePrint.scala
+++ b/test/files/run/treePrint.scala
@@ -35,7 +35,7 @@ object Test {
     settings.Ycompacttrees.value = true
 
     val intp = new IMain(settings, new PrintWriter(new NullOutputStream))
-    val power = Power(intp)
+    val power = new Power(intp, new ReplVals { })
     intp.interpret("""def initialize = "Have to interpret something or we get errors." """)
     power trees code foreach println
   }
diff --git a/test/files/run/type-currying.check b/test/files/run/type-currying.check
new file mode 100644
index 0000000000..e5db238ca5
--- /dev/null
+++ b/test/files/run/type-currying.check
@@ -0,0 +1,27 @@
+Map(abc -> 55)
+(a,0)
+(b,1)
+(c,2)
+(d,3)
+(e,4)
+(f,5)
+(g,6)
+(h,7)
+(i,8)
+(j,9)
+(k,10)
+(l,11)
+(m,12)
+(n,13)
+(o,14)
+(p,15)
+(q,16)
+(r,17)
+(s,18)
+(t,19)
+(u,20)
+(v,21)
+(w,22)
+(x,23)
+(y,24)
+(z,25)
diff --git a/test/files/run/type-currying.scala b/test/files/run/type-currying.scala
new file mode 100644
index 0000000000..f9764c64f0
--- /dev/null
+++ b/test/files/run/type-currying.scala
@@ -0,0 +1,58 @@
+import scala.collection.{ mutable, immutable, generic }
+import generic.CanBuildFrom
+
+object Partial {
+  type KnownContainer[CC[K, V] <: collection.Map[K, V]] = {
+    def values[V] : KnownValues[CC, V]
+    def apply[K] : KnownKeys[CC, K]
+  }
+  type KnownKeys[CC[K, V] <: collection.Map[K, V], K] = {
+    def apply[V](implicit cbf: CanBuildFrom[_, (K, V), CC[K, V]]): CC[K, V]
+  }
+  type KnownValues[CC[K, V] <: collection.Map[K, V], V] = {
+    def apply[K](implicit cbf: CanBuildFrom[_, (K, V), CC[K, V]]): CC[K, V]
+  }
+
+  def apply[CC[K, V] <: collection.Map[K, V]] : KnownContainer[CC] = new {
+    def values[V] : KnownValues[CC, V] = new {
+      def apply[K](implicit cbf: CanBuildFrom[_, (K, V), CC[K, V]]) = cbf().result
+    }
+    def apply[K] = new {
+      def apply[V](implicit cbf: CanBuildFrom[_, (K, V), CC[K, V]]) = cbf().result
+    }
+  }
+}
+
+object Test {
+  val m = Partial[immutable.TreeMap]
+  val m1 = m[String]
+  val m2 = m[Int][Int]
+
+  val mutableBippy = Partial[mutable.HashMap][String][Int]
+  mutableBippy("abc") = 55
+
+  val immutableBippy = Partial[immutable.HashMap].values[Int]
+  def make[T](xs: T*) = immutableBippy[T] ++ xs.zipWithIndex
+  
+  val n0 = Partial[immutable.HashMap][String][Int] ++ Seq(("a", 1))
+  val n1 = Partial.apply[immutable.HashMap].apply[String].apply[Int] ++ Seq(("a", 1))
+  
+  def main(args: Array[String]): Unit = {
+    println(mutableBippy)
+    make('a' to 'z': _*).toList.sorted foreach println
+    assert(n0 == n1)
+  }
+}
+
+class A {
+  object Foo {
+    def apply[T] = Bar
+  }
+  object Bar {
+    def apply() = Foo
+  }
+
+  def f() = Foo
+  def g = f()[Int]()[String]()
+  def h = Foo[Foo.type]()[Foo.type]()
+}
diff --git a/test/files/run/virtpatmat_literal.scala b/test/files/run/virtpatmat_literal.scala
index cb72b1d2a5..5bd6b30791 100644
--- a/test/files/run/virtpatmat_literal.scala
+++ b/test/files/run/virtpatmat_literal.scala
@@ -1,8 +1,9 @@
 object Test extends App {
+ val a = 1
  1 match { 
    case 2 => println("FAILED") 
    case 1 => println("OK") 
-   case 1 => println("FAILED") 
+   case `a` => println("FAILED") 
  }
 
  val one = 1
diff --git a/test/files/run/virtpatmat_opt_sharing.check b/test/files/run/virtpatmat_opt_sharing.check
new file mode 100644
index 0000000000..d00491fd7e
--- /dev/null
+++ b/test/files/run/virtpatmat_opt_sharing.check
@@ -0,0 +1 @@
+1
diff --git a/test/files/run/virtpatmat_opt_sharing.flags b/test/files/run/virtpatmat_opt_sharing.flags
new file mode 100644
index 0000000000..9769db9257
--- /dev/null
+++ b/test/files/run/virtpatmat_opt_sharing.flags
@@ -0,0 +1 @@
+ -Yvirtpatmat -Xexperimental
diff --git a/test/files/run/virtpatmat_opt_sharing.scala b/test/files/run/virtpatmat_opt_sharing.scala
new file mode 100644
index 0000000000..119e3050ea
--- /dev/null
+++ b/test/files/run/virtpatmat_opt_sharing.scala
@@ -0,0 +1,10 @@
+object Test extends App {
+  virtMatch()
+  def virtMatch() = {
+    List(1, 3, 4, 7) match {
+      case 1 :: 3 :: 4 :: 5 :: x => println("nope")
+      case 1 :: 3 :: 4 :: 6 :: x => println("nope")
+      case 1 :: 3 :: 4 :: 7 :: x => println(1)
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/virtpatmat_unapplyprod.check b/test/files/run/virtpatmat_unapplyprod.check
new file mode 100644
index 0000000000..2660ff8f96
--- /dev/null
+++ b/test/files/run/virtpatmat_unapplyprod.check
@@ -0,0 +1,4 @@
+(2,3)
+(2,3)
+(2,3)
+List(true, false, true)
diff --git a/test/files/run/virtpatmat_unapplyprod.flags b/test/files/run/virtpatmat_unapplyprod.flags
new file mode 100644
index 0000000000..9769db9257
--- /dev/null
+++ b/test/files/run/virtpatmat_unapplyprod.flags
@@ -0,0 +1 @@
+ -Yvirtpatmat -Xexperimental
diff --git a/test/files/run/virtpatmat_unapplyprod.scala b/test/files/run/virtpatmat_unapplyprod.scala
new file mode 100644
index 0000000000..441e5e3968
--- /dev/null
+++ b/test/files/run/virtpatmat_unapplyprod.scala
@@ -0,0 +1,23 @@
+object Test extends App {
+  case class Foo(x: Int, y: String)
+
+  Foo(2, "3") match {
+    case Foo(x, y) => println((x, y))
+  }
+
+  case class FooSeq(x: Int, y: String, z: Boolean*)
+
+  FooSeq(2, "3") match {
+    case FooSeq(x, y) => println((x, y))
+  }
+
+  FooSeq(2, "3", true, false, true) match {
+    case FooSeq(x, y) => println("nope")
+    case FooSeq(x, y, true, false, true) => println((x, y))
+  }
+
+  FooSeq(1, "a", true, false, true) match {
+    case FooSeq(1, "a") => println("nope")
+    case FooSeq(1, "a", x@_* ) => println(x.toList)
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/xml-attribute.scala b/test/files/run/xml-attribute.scala
new file mode 100644
index 0000000000..8b261acc94
--- /dev/null
+++ b/test/files/run/xml-attribute.scala
@@ -0,0 +1,33 @@
+import xml.Node
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val noAttr = <t/>
+    val attrNull = <t a={ null: String }/>
+    val attrNone = <t a={ None: Option[Seq[Node]] }/>
+    val preAttrNull = <t p:a={ null: String }/>
+    val preAttrNone = <t p:a={ None: Option[Seq[Node]] }/>
+    assert(noAttr == attrNull)
+    assert(noAttr == attrNone)
+    assert(noAttr == preAttrNull)
+    assert(noAttr == preAttrNone)
+
+    val noAttrStr = "<t></t>"
+    assert(noAttr.toString() == noAttrStr)
+    assert(attrNull.toString() == noAttrStr)
+    assert(attrNone.toString() == noAttrStr)
+    assert(preAttrNull.toString() == noAttrStr)
+    assert(preAttrNone.toString() == noAttrStr)
+
+    val xml1 = <t b="1" d="2"/>
+    val xml2 = <t a={ null: String } p:a={ null: String } b="1" c={ null: String } d="2"/>
+    val xml3 = <t b="1" c={ null: String } d="2" a={ null: String } p:a={ null: String }/>
+    assert(xml1 == xml2)
+    assert(xml1 == xml3)
+
+    val xml1Str = "<t d=\"2\" b=\"1\"></t>"
+    assert(xml1.toString() == xml1Str)
+    assert(xml2.toString() == xml1Str)
+    assert(xml3.toString() == xml1Str)
+  }
+}
diff --git a/test/files/scalacheck/CheckEither.scala b/test/files/scalacheck/CheckEither.scala
index a7e50877a7..0145d3321f 100644
--- a/test/files/scalacheck/CheckEither.scala
+++ b/test/files/scalacheck/CheckEither.scala
@@ -8,7 +8,7 @@ import org.scalacheck.Test.{Params, check}
 import org.scalacheck.ConsoleReporter.testStatsEx
 import Function.tupled
 
-object CheckEither extends Properties("Either") {
+object Test extends Properties("Either") {
   implicit def arbitraryEither[X, Y](implicit xa: Arbitrary[X], ya: Arbitrary[Y]): Arbitrary[Either[X, Y]] = 
     Arbitrary[Either[X, Y]](oneOf(arbitrary[X].map(Left(_)), arbitrary[Y].map(Right(_))))
 
@@ -186,9 +186,3 @@ object CheckEither extends Properties("Either") {
     STest.checkProperties(STest.Params(testCallback = ConsoleReporter(0)), this)
   }
 }
-
-object Test {
-  def main(args: Array[String]): Unit = {
-    CheckEither.runTests()
-  }
-}
diff --git a/test/files/scalacheck/nan-ordering.scala b/test/files/scalacheck/nan-ordering.scala
new file mode 100644
index 0000000000..2094a46e37
--- /dev/null
+++ b/test/files/scalacheck/nan-ordering.scala
@@ -0,0 +1,130 @@
+import org.scalacheck._
+import Gen._
+import Prop._
+
+object Test extends Properties("NaN-Ordering") {
+
+  val specFloats: Gen[Float] = oneOf(
+    Float.MaxValue,
+    Float.MinPositiveValue,
+    Float.MinValue,
+    Float.NaN,
+    Float.NegativeInfinity,
+    Float.PositiveInfinity,
+    -0.0f,
+    +0.0f
+  )
+
+  property("Float min") = forAll(specFloats, specFloats) { (d1, d2) => {
+      val mathmin = math.min(d1, d2)
+      val numericmin = d1 min d2
+      mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+    }
+  }
+
+  property("Float max") = forAll(specFloats, specFloats) { (d1, d2) => {
+      val mathmax = math.max(d1, d2)
+      val numericmax = d1 max d2
+      mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+    }
+  }
+
+  val numFloat = implicitly[Numeric[Float]]
+
+  property("Float lt") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.lt(d1, d2) == d1 < d2 }
+
+  property("Float lteq") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.lteq(d1, d2) == d1 <= d2 }
+
+  property("Float gt") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.gt(d1, d2) == d1 > d2 }
+
+  property("Float gteq") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.gteq(d1, d2) == d1 >= d2 }
+
+  property("Float equiv") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.equiv(d1, d2) == (d1 == d2) }
+
+  property("Float reverse.min") = forAll(specFloats, specFloats) { (d1, d2) => {
+      val mathmin = math.min(d1, d2)
+      val numericmin = numFloat.reverse.min(d1, d2)
+      mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+    }
+  }
+
+  property("Float reverse.max") = forAll(specFloats, specFloats) { (d1, d2) => {
+      val mathmax = math.max(d1, d2)
+      val numericmax = numFloat.reverse.max(d1, d2)
+      mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+    }
+  }
+
+  property("Float reverse.lt") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.reverse.lt(d1, d2) == d2 < d1 }
+
+  property("Float reverse.lteq") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.reverse.lteq(d1, d2) == d2 <= d1 }
+
+  property("Float reverse.gt") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.reverse.gt(d1, d2) == d2 > d1 }
+
+  property("Float reverse.gteq") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.reverse.gteq(d1, d2) == d2 >= d1 }
+
+  property("Float reverse.equiv") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.reverse.equiv(d1, d2) == (d1 == d2) }
+
+
+  val specDoubles: Gen[Double] = oneOf(
+    Double.MaxValue,
+    Double.MinPositiveValue,
+    Double.MinValue,
+    Double.NaN,
+    Double.NegativeInfinity,
+    Double.PositiveInfinity,
+    -0.0,
+    +0.0
+  )
+
+  // ticket #5104
+  property("Double min") = forAll(specDoubles, specDoubles) { (d1, d2) => {
+    val mathmin = math.min(d1, d2)
+    val numericmin = d1 min d2
+    mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+  }
+  }
+
+  property("Double max") = forAll(specDoubles, specDoubles) { (d1, d2) => {
+    val mathmax = math.max(d1, d2)
+    val numericmax = d1 max d2
+    mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+  }
+  }
+
+  val numDouble = implicitly[Numeric[Double]]
+
+  property("Double lt") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.lt(d1, d2) == d1 < d2 }
+
+  property("Double lteq") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.lteq(d1, d2) == d1 <= d2 }
+
+  property("Double gt") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.gt(d1, d2) == d1 > d2 }
+
+  property("Double gteq") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.gteq(d1, d2) == d1 >= d2 }
+
+  property("Double equiv") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.equiv(d1, d2) == (d1 == d2) }
+
+  property("Double reverse.min") = forAll(specDoubles, specDoubles) { (d1, d2) => {
+    val mathmin = math.min(d1, d2)
+    val numericmin = numDouble.reverse.min(d1, d2)
+    mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+  }
+  }
+
+  property("Double reverse.max") = forAll(specDoubles, specDoubles) { (d1, d2) => {
+    val mathmax = math.max(d1, d2)
+    val numericmax = numDouble.reverse.max(d1, d2)
+    mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+  }
+  }
+
+  property("Double reverse.lt") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.reverse.lt(d1, d2) == d2 < d1 }
+
+  property("Double reverse.lteq") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.reverse.lteq(d1, d2) == d2 <= d1 }
+
+  property("Double reverse.gt") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.reverse.gt(d1, d2) == d2 > d1 }
+
+  property("Double reverse.gteq") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.reverse.gteq(d1, d2) == d2 >= d1 }
+
+  property("Double reverse.equiv") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.reverse.equiv(d1, d2) == (d1 == d2) }
+}
diff --git a/test/files/scalacheck/range.scala b/test/files/scalacheck/range.scala
index 56295f204c..72979115be 100644
--- a/test/files/scalacheck/range.scala
+++ b/test/files/scalacheck/range.scala
@@ -12,10 +12,16 @@ class Counter(r: Range) {
     if (cnt % 500000000L == 0L) {
       println("Working: %s %d %d" format (str, cnt, x))
     }
-    if (cnt > (Int.MaxValue.toLong + 1) * 2)
-      error("Count exceeds maximum possible for an Int Range")
-    if ((r.step > 0 && last.exists(_ > x)) || (r.step < 0 && last.exists(_ < x)))
-      error("Range wrapped: %d %s" format (x, last.toString))
+    if (cnt > (Int.MaxValue.toLong + 1) * 2) {
+      val msg = "Count exceeds maximum possible for an Int Range: %s" format str
+      println(msg) // exception is likely to be eaten by an out of memory error
+      sys error msg
+    }
+    if ((r.step > 0 && last.exists(_ > x)) || (r.step < 0 && last.exists(_ < x))) {
+      val msg = "Range %s wrapped: %d %s" format (str, x, last.toString)
+      println(msg) // exception is likely to be eaten by an out of memory error
+      sys error msg
+    }
     last = Some(x)
   }
 }
@@ -23,29 +29,40 @@ class Counter(r: Range) {
 abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   def myGen: Gen[Range]
 
-  val genRange = for {
-    start <- arbitrary[Int]
-    end <- arbitrary[Int]
-    step <- Gen.choose(1, (start - end).abs + 1)
-  } yield if (start < end) Range(start, end, step) else Range(start, end, -step)
-
-  val genReasonableSizeRange = for {
-    start <- choose(-Int.MinValue, Int.MaxValue)
-    end <- choose(-Int.MinValue, Int.MaxValue)
+  def genReasonableSizeRange = oneOf(genArbitraryRange, genBoundaryRange)
+    
+  def genArbitraryRange = for {
+    start <- choose(Int.MinValue, Int.MaxValue)
+    end <- choose(Int.MinValue, Int.MaxValue)
     step <- choose(-Int.MaxValue, Int.MaxValue)
   } yield Range(start, end, if (step == 0) 100 else step)
 
-  val genSmallRange = for {
+  def genBoundaryRange = for {
+    boundary <- oneOf(Int.MinValue, -1, 0, 1, Int.MaxValue)
+    isStart <- arbitrary[Boolean]
+    size <- choose(1, 100)
+    step <- choose(1, 101)
+  } yield {
+    val signum = if (boundary == 0) 1 else boundary.signum
+    if (isStart) Range(boundary, boundary - size * boundary.signum, - step * signum)
+    else         Range(boundary - size * boundary.signum, boundary, step * signum)
+  }
+
+
+  def genSmallRange = for {
     start <- choose(-100, 100)
     end <- choose(-100, 100)
     step <- choose(1, 1)
   } yield if (start < end) Range(start, end, step) else Range(start, end, -step)
 
-  val genRangeByOne = for {
-    start <- arbitrary[Int]
-    end <- arbitrary[Int]
-    if (end.toLong - start.toLong).abs <= 10000000L
-  } yield if (start < end) Range(start, end) else Range(end, start)
+  def genRangeByOne = oneOf(genRangeOpenByOne, genRangeClosedByOne)
+    
+  def genRangeOpenByOne = for {
+    r <- oneOf(genSmallRange, genBoundaryRange)
+    if (r.end.toLong - r.start.toLong).abs <= 10000000L
+  } yield if (r.start < r.end) Range(r.start, r.end) else Range(r.end, r.start)
+
+  def genRangeClosedByOne = for (r <- genRangeOpenByOne) yield r.start to r.end
 
   def str(r: Range) = "Range["+r.start+", "+r.end+", "+r.step+(if (r.isInclusive) "]" else ")")
 
@@ -71,7 +88,8 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
 
   def multiple(r: Range, x: Int) = (x.toLong - r.start) % r.step == 0
 
-  property("foreach.step") = forAll(myGen) { r =>
+  property("foreach.step") = forAllNoShrink(myGen) { r =>
+//    println("foreach.step "+str(r))
     var allValid = true
     val cnt = new Counter(r)
 //    println("--------------------")
@@ -84,6 +102,7 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   }
 
   property("foreach.inside.range") = forAll(myGen) { r =>
+//    println("foreach.inside.range "+str(r))
     var allValid = true
     var last: Option[Int] = None
     val cnt = new Counter(r)
@@ -94,6 +113,7 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   }
 
   property("foreach.visited.size") = forAll(myGen) { r =>
+//    println("foreach.visited.size "+str(r))
     var visited = 0L
     val cnt = new Counter(r)
     r foreach { x => cnt(x)
@@ -108,14 +128,17 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   }
 
   property("length") = forAll(myGen suchThat (r => expectedSize(r).toInt == expectedSize(r))) { r =>
+//    println("length "+str(r))
     (r.length == expectedSize(r)) :| str(r)
   }
 
   property("isEmpty") = forAll(myGen suchThat (r => expectedSize(r).toInt == expectedSize(r))) { r =>
+//    println("isEmpty "+str(r))
     (r.isEmpty == (expectedSize(r) == 0L)) :| str(r)
   }
 
   property("contains") = forAll(myGen, arbInt.arbitrary) { (r, x) =>
+//    println("contains "+str(r))
 //    println("----------------")
 //    println(str(r))
 //    println(x)
@@ -126,11 +149,13 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   }
 
   property("take") = forAll(myGen suchThat (r => expectedSize(r).toInt == expectedSize(r)), arbInt.arbitrary) { (r, x) =>
+//    println("take "+str(r))
     val t = r take x
     (t.size == (0 max x min r.size) && t.start == r.start && t.step == r.step) :| str(r)+" / "+str(t)+": "+x
   }
 
   property("init") = forAll(myGen suchThat (r => expectedSize(r).toInt == expectedSize(r))) { r =>
+//    println("init "+str(r))
     (r.size == 0) || {
       val t = r.init
       (t.size + 1 == r.size) && (t.isEmpty || t.head == r.head)
@@ -138,6 +163,7 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   }
 
   property("takeWhile") = forAll(myGen suchThat (r => expectedSize(r).toInt == expectedSize(r)), arbInt.arbitrary) { (r, x) =>
+//    println("takeWhile "+str(r))
     val t = (if (r.step > 0) r takeWhile (_ <= x) else r takeWhile(_ >= x))
     if (r.size == 0) {
       (t.size == 0) :| str(r)+" / "+str(t)+": "+x
@@ -148,6 +174,7 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
   }
 
   property("reverse.toSet.equal") = forAll(myGen) { r =>
+//    println("reverse.toSet.equal "+str(r))
     val reversed = r.reverse
     val aresame = r.toSet == reversed.toSet
     if (!aresame) {
@@ -157,7 +184,7 @@ abstract class RangeTest(kind: String) extends Properties("Range "+kind) {
       println(r.toSet)
       println(reversed.toSet)
     }
-    aresame
+    aresame :| str(r)
   }
 }
 
@@ -178,11 +205,11 @@ object InclusiveRangeTest extends RangeTest("inclusive") {
 }
 
 object ByOneRangeTest extends RangeTest("byOne") {
-  override def myGen = genSmallRange
+  override def myGen = genRangeByOne
 }
 
 object InclusiveByOneRangeTest extends RangeTest("inclusiveByOne") {
-  override def myGen = for (r <- genSmallRange) yield r.inclusive
+  override def myGen = for (r <- genRangeByOne) yield r.inclusive
 }
 
 object SmallValuesRange extends RangeTest("smallValues") {
@@ -207,9 +234,11 @@ object TooLargeRange extends Properties("Too Large Range") {
 object Test extends Properties("Range") {
   import org.scalacheck.{ Test => STest }
 
-  List(NormalRangeTest, InclusiveRangeTest, ByOneRangeTest, InclusiveByOneRangeTest, TooLargeRange) foreach { ps =>
-    STest.checkProperties(STest.Params(testCallback = ConsoleReporter(0)), ps)
-  }
+  include(NormalRangeTest)
+  include(InclusiveRangeTest)
+  include(ByOneRangeTest)
+  include(InclusiveByOneRangeTest)
+  include(TooLargeRange)
 }
 
 /* Mini-benchmark