19 files changed, 251 insertions, 6 deletions
diff --git a/test/files/instrumented/InstrumentationTest.check b/test/files/instrumented/InstrumentationTest.check
new file mode 100644
index 0000000000..3652df270a
--- /dev/null
+++ b/test/files/instrumented/InstrumentationTest.check
@@ -0,0 +1,4 @@
+true
+Method call statistics:
+    1  scala/Predef$.println(Ljava/lang/Object;)V
+    1  scala/runtime/BoxesRunTime.boxToBoolean(Z)Ljava/lang/Boolean;
diff --git a/test/files/instrumented/InstrumentationTest.scala b/test/files/instrumented/InstrumentationTest.scala
new file mode 100644
index 0000000000..ec5314c624
--- /dev/null
+++ b/test/files/instrumented/InstrumentationTest.scala
@@ -0,0 +1,14 @@
+import scala.tools.partest.instrumented.Instrumentation._
+
+/** Tests if instrumentation itself works correctly */
+object Test {
+  def main(args: Array[String]) {
+    // force predef initialization before profiling
+    Predef
+    startProfiling()
+    // should box the boolean
+    println(true)
+    stopProfiling()
+    printStatistics()
+  }
+}
diff --git a/test/files/instrumented/README b/test/files/instrumented/README
new file mode 100644
index 0000000000..32d0ef2da5
--- /dev/null
+++ b/test/files/instrumented/README
@@ -0,0 +1,15 @@
+Tests in `instrumented` directory are executed the same way as in `run` but
+they have additional byte-code instrumentation performed for profiling. You
+should put your tests in `instrumented` directory if you are interested in
+method call counts. Examples include tests for specialization (you want to
+count boxing and unboxing method calls) or high-level tests for optimizer
+where you are interested if methods are successfuly inlined (so they should
+not be called at runtime) or closures are eliminated (so no constructors
+of closures are called).
+
+Check `scala.tools.partest.instrumented.Instrumentation` to learn how to
+use the instrumentation infrastructure.
+
+The instrumentation itself is achieved by attaching a Java agent to the forked
+VM process that injects calls to profiler. Check
+`scala.tools.partest.instrumented.Instrumentation`.
diff --git a/test/files/neg/t1286.check b/test/files/neg/t1286.check
index c937fb9cf1..912709613c 100644
--- a/test/files/neg/t1286.check
+++ b/test/files/neg/t1286.check
@@ -1,9 +1,5 @@
-a.scala:1: error: Companions 'object Foo' and 'trait Foo' must be defined in same file:
-  Found in t1286/b.scala and t1286/a.scala
-trait Foo {
-      ^
 b.scala:1: error: Companions 'trait Foo' and 'object Foo' must be defined in same file:
   Found in t1286/a.scala and t1286/b.scala
 object Foo extends Foo {
        ^
-two errors found
+one error found
diff --git a/test/files/neg/t5830.check b/test/files/neg/t5830.check
index 85cb84378f..726fac2a1e 100644
--- a/test/files/neg/t5830.check
+++ b/test/files/neg/t5830.check
@@ -1,4 +1,7 @@
 t5830.scala:6: error: unreachable code
     case 'a' => println("b") // unreachable
                        ^
-one error found
+t5830.scala:4: error: could not emit switch for @switch annotated match
+  def unreachable(ch: Char) = (ch: @switch) match {
+                                    ^
+two errors found
diff --git a/test/files/neg/t5956.check b/test/files/neg/t5956.check
new file mode 100644
index 0000000000..6641dac97f
--- /dev/null
+++ b/test/files/neg/t5956.check
@@ -0,0 +1,20 @@
+t5956.scala:1: warning: case classes without a parameter list have been deprecated;
+use either case objects or case classes with `()' as parameter list.
+object O { case class C[T]; class C }
+                          ^
+t5956.scala:2: warning: case classes without a parameter list have been deprecated;
+use either case objects or case classes with `()' as parameter list.
+object T { case class C[T]; case class C }
+                          ^
+t5956.scala:2: warning: case classes without a parameter list have been deprecated;
+use either case objects or case classes with `()' as parameter list.
+object T { case class C[T]; case class C }
+                                        ^
+t5956.scala:1: error: C is already defined as case class C
+object O { case class C[T]; class C }
+                                  ^
+t5956.scala:2: error: C is already defined as case class C
+object T { case class C[T]; case class C }
+                                       ^
+three warnings found
+two errors found
diff --git a/test/files/neg/t5956.scala b/test/files/neg/t5956.scala
new file mode 100644
index 0000000000..d985fa97a4
--- /dev/null
+++ b/test/files/neg/t5956.scala
@@ -0,0 +1,2 @@
+object O { case class C[T]; class C }
+object T { case class C[T]; case class C }
diff --git a/test/files/neg/t6011.check b/test/files/neg/t6011.check
new file mode 100644
index 0000000000..5b5a861e5b
--- /dev/null
+++ b/test/files/neg/t6011.check
@@ -0,0 +1,10 @@
+t6011.scala:4: error: unreachable code
+    case 'a' | 'c' => 1 // unreachable
+                      ^
+t6011.scala:10: error: unreachable code
+    case 'b' | 'a'  => 1 // unreachable
+                       ^
+t6011.scala:8: error: could not emit switch for @switch annotated match
+  def f2(ch: Char): Any = (ch: @annotation.switch) match {
+                                ^
+three errors found
diff --git a/test/files/neg/t6011.flags b/test/files/neg/t6011.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/neg/t6011.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
+\ No newline at end of file
diff --git a/test/files/neg/t6011.scala b/test/files/neg/t6011.scala
new file mode 100644
index 0000000000..a36cca7897
--- /dev/null
+++ b/test/files/neg/t6011.scala
@@ -0,0 +1,23 @@
+object Test {
+  def f(ch: Char): Any = ch match {
+    case 'a'  => 1
+    case 'a' | 'c' => 1 // unreachable
+  }
+
+  // won't be compiled to a switch since it has an unreachable (duplicate) case
+  def f2(ch: Char): Any = (ch: @annotation.switch) match {
+    case 'a' | 'b'  => 1
+    case 'b' | 'a'  => 1 // unreachable
+    case _ =>
+  }
+
+  // s'all good
+  def f3(ch: Char): Any = (ch: @annotation.switch) match {
+    case 'a' | 'b'  if (true: Boolean) => 1
+    case 'b' | 'a'  => 1 // ok
+    case _ => // need third case to check switch annotation (two-case switches are always okay to compile to if-then-else)
+  }
+
+
+  def main(args: Array[String]): Unit = f('a')
+}
+\ No newline at end of file
diff --git a/test/files/neg/t6048.check b/test/files/neg/t6048.check
new file mode 100644
index 0000000000..051f41877e
--- /dev/null
+++ b/test/files/neg/t6048.check
@@ -0,0 +1,10 @@
+t6048.scala:3: error: unreachable code
+    case _ if false => x // unreachable
+                       ^
+t6048.scala:8: error: unreachable code
+    case _ if false => x // unreachable
+                       ^
+t6048.scala:14: error: unreachable code
+    case 5 if true  => x // unreachable
+                       ^
+three errors found
diff --git a/test/files/neg/t6048.flags b/test/files/neg/t6048.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/neg/t6048.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
+\ No newline at end of file
diff --git a/test/files/neg/t6048.scala b/test/files/neg/t6048.scala
new file mode 100644
index 0000000000..803e651d19
--- /dev/null
+++ b/test/files/neg/t6048.scala
@@ -0,0 +1,22 @@
+class A {
+  def f1(x: Int) = x match {
+    case _ if false => x // unreachable
+    case 5          => x
+  }
+
+  def f2(x: Int) = x match {
+    case _ if false => x // unreachable
+    case 5 if true  => x
+  }
+
+  def f3(x: Int) = x match {
+    case _ => x
+    case 5 if true  => x // unreachable
+  }
+
+  def test1(x: Int) = x match {
+    case c if c < 0 => 0
+    case 1          => 1
+    case _          => 2
+  }
+}
diff --git a/test/files/pos/t6028/t6028_1.scala b/test/files/pos/t6028/t6028_1.scala
new file mode 100644
index 0000000000..6edb76069e
--- /dev/null
+++ b/test/files/pos/t6028/t6028_1.scala
@@ -0,0 +1,3 @@
+class C {
+	def foo(a: Int): Unit = () => a
+}
diff --git a/test/files/pos/t6028/t6028_2.scala b/test/files/pos/t6028/t6028_2.scala
new file mode 100644
index 0000000000..f44048c0ab
--- /dev/null
+++ b/test/files/pos/t6028/t6028_2.scala
@@ -0,0 +1,4 @@
+object Test {
+	// ensure that parameter names are untouched by lambdalift
+	new C().foo(a = 0)
+}
diff --git a/test/files/run/t6011b.check b/test/files/run/t6011b.check
new file mode 100644
index 0000000000..00750edc07
--- /dev/null
+++ b/test/files/run/t6011b.check
@@ -0,0 +1 @@
+3
diff --git a/test/files/run/t6011b.scala b/test/files/run/t6011b.scala
new file mode 100644
index 0000000000..3d405e0705
--- /dev/null
+++ b/test/files/run/t6011b.scala
@@ -0,0 +1,11 @@
+object Test extends App {
+  var cond = true
+
+  // should not generate a switch
+  def f(ch: Char): Int = ch match {
+    case 'a' if cond => 1
+    case 'z' | 'a' => 2
+  }
+
+  println(f('a') + f('z')) // 3
+}
+\ No newline at end of file
diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check
new file mode 100644
index 0000000000..dca61115ad
--- /dev/null
+++ b/test/files/run/t6028.check
@@ -0,0 +1,84 @@
+[[syntax trees at end of                lambdalift]] // newSource1
+package <empty> {
+  class T extends Object {
+    <paramaccessor> val T$$classParam: Int = _;
+    def <init>(classParam: Int): T = {
+      T.super.<init>();
+      ()
+    };
+    private[this] val field: Int = 0;
+    <stable> <accessor> def field(): Int = T.this.field;
+    def foo(methodParam: Int): Function0 = {
+      val methodLocal: Int = 0;
+      {
+        (new anonymous class $anonfun$foo$1(T.this, methodParam, methodLocal): Function0)
+      }
+    };
+    def bar(barParam: Int): Object = {
+      @volatile var MethodLocalObject$module: scala.runtime.VolatileObjectRef = new scala.runtime.VolatileObjectRef(<empty>);
+      T.this.MethodLocalObject$1(barParam, MethodLocalObject$module)
+    };
+    def tryy(tryyParam: Int): Function0 = {
+      var tryyLocal: scala.runtime.IntRef = new scala.runtime.IntRef(0);
+      {
+        (new anonymous class $anonfun$tryy$1(T.this, tryyParam, tryyLocal): Function0)
+      }
+    };
+    @SerialVersionUID(0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable {
+      def <init>($outer: T, methodParam$1: Int, methodLocal$1: Int): anonymous class $anonfun$foo$1 = {
+        $anonfun$foo$1.super.<init>();
+        ()
+      };
+      final def apply(): Int = $anonfun$foo$1.this.apply$mcI$sp();
+      <specialized> def apply$mcI$sp(): Int = $anonfun$foo$1.this.$outer.T$$classParam.+($anonfun$foo$1.this.$outer.field()).+($anonfun$foo$1.this.methodParam$1).+($anonfun$foo$1.this.methodLocal$1);
+      <synthetic> <paramaccessor> private[this] val $outer: T = _;
+      <synthetic> <stable> def T$$anonfun$$$outer(): T = $anonfun$foo$1.this.$outer;
+      final <bridge> def apply(): Object = scala.Int.box($anonfun$foo$1.this.apply());
+      <synthetic> <paramaccessor> private[this] val methodParam$1: Int = _;
+      <synthetic> <paramaccessor> private[this] val methodLocal$1: Int = _
+    };
+    abstract trait MethodLocalTrait$1 extends Object {
+      <synthetic> <stable> def T$MethodLocalTrait$$$outer(): T
+    };
+    object MethodLocalObject$2 extends Object with T#MethodLocalTrait$1 {
+      def <init>($outer: T, barParam$1: Int): ... = {
+        MethodLocalObject$2.super.<init>();
+        MethodLocalObject$2.this.$asInstanceOf[T#MethodLocalTrait$1$class]()./*MethodLocalTrait$1$class*/$init$(barParam$1);
+        ()
+      };
+      <synthetic> <paramaccessor> private[this] val $outer: T = _;
+      <synthetic> <stable> def T$MethodLocalObject$$$outer(): T = MethodLocalObject$2.this.$outer;
+      <synthetic> <stable> def T$MethodLocalTrait$$$outer(): T = MethodLocalObject$2.this.$outer
+    };
+    final <stable> private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: scala.runtime.VolatileObjectRef): ... = {
+      MethodLocalObject$module$1.elem = new ...(T.this, barParam$1);
+      MethodLocalObject$module$1.elem.$asInstanceOf[...]()
+    };
+    abstract trait MethodLocalTrait$1$class extends Object with T#MethodLocalTrait$1 {
+      def /*MethodLocalTrait$1$class*/$init$(barParam$1: Int): Unit = {
+        ()
+      };
+      scala.this.Predef.print(scala.Int.box(barParam$1))
+    };
+    @SerialVersionUID(0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable {
+      def <init>($outer: T, tryyParam$1: Int, tryyLocal$1: scala.runtime.IntRef): anonymous class $anonfun$tryy$1 = {
+        $anonfun$tryy$1.super.<init>();
+        ()
+      };
+      final def apply(): Unit = $anonfun$tryy$1.this.apply$mcV$sp();
+      <specialized> def apply$mcV$sp(): Unit = try {
+        $anonfun$tryy$1.this.tryyLocal$1.elem = $anonfun$tryy$1.this.tryyParam$1
+      } finally ();
+      <synthetic> <paramaccessor> private[this] val $outer: T = _;
+      <synthetic> <stable> def T$$anonfun$$$outer(): T = $anonfun$tryy$1.this.$outer;
+      final <bridge> def apply(): Object = {
+        $anonfun$tryy$1.this.apply();
+        scala.runtime.BoxedUnit.UNIT
+      };
+      <synthetic> <paramaccessor> private[this] val tryyParam$1: Int = _;
+      <synthetic> <paramaccessor> private[this] val tryyLocal$1: scala.runtime.IntRef = _
+    }
+  }
+}
+
+warning: there were 1 feature warnings; re-run with -feature for details
diff --git a/test/files/run/t6028.scala b/test/files/run/t6028.scala
new file mode 100644
index 0000000000..cab17535fc
--- /dev/null
+++ b/test/files/run/t6028.scala
@@ -0,0 +1,21 @@
+import scala.tools.partest._
+import java.io.{Console => _, _}
+
+object Test extends DirectTest {
+
+  override def extraSettings: String = "-usejavacp -Xprint:lambdalift -d " + testOutput.path
+
+  override def code = """class T(classParam: Int) {
+                        |  val field: Int = 0
+                        |  def foo(methodParam: Int) = {val methodLocal = 0 ; () => classParam + field + methodParam + methodLocal }
+                        |  def bar(barParam: Int) = { trait MethodLocalTrait { print(barParam) }; object MethodLocalObject extends MethodLocalTrait; MethodLocalObject }
+                        |  def tryy(tryyParam: Int) = { var tryyLocal = 0; () => try { tryyLocal = tryyParam } finally () }
+                        |}
+                        |""".stripMargin.trim
+
+  override def show(): Unit = {
+    Console.withErr(System.out) {
+      compile()
+    }
+  }
+}