14 files changed, 167 insertions, 0 deletions
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/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")_)(""))
+  }
+}