8 files changed, 128 insertions, 0 deletions
diff --git a/test/files/neg/t9286a.check b/test/files/neg/t9286a.check
new file mode 100644
index 0000000000..2bc7c0cf15
--- /dev/null
+++ b/test/files/neg/t9286a.check
@@ -0,0 +1,7 @@
+t9286a.scala:6: error: name clash between defined and inherited member:
+def foo(o: (String,)): Unit in class T and
+private def foo(o: (Any,)): Unit at line 6
+have same type after erasure: (o: Tuple1)Unit
+   private def foo(o: Tuple1[Any]) = ()
+               ^
+one error found
diff --git a/test/files/neg/t9286a.scala b/test/files/neg/t9286a.scala
new file mode 100644
index 0000000000..0375ac591f
--- /dev/null
+++ b/test/files/neg/t9286a.scala
@@ -0,0 +1,13 @@
+class T {
+  def foo(o: Tuple1[String]) = ()
+}
+
+class U extends T {
+   private def foo(o: Tuple1[Any]) = ()
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new U().foo(null) // IllegalAccessError:  tried to access method U.foo(Lscala/Tuple1;)V from class Test$
+  }
+}
diff --git a/test/files/neg/t9286b.check b/test/files/neg/t9286b.check
new file mode 100644
index 0000000000..89a191bfee
--- /dev/null
+++ b/test/files/neg/t9286b.check
@@ -0,0 +1,7 @@
+t9286b.scala:2: error: name clash between defined and inherited member:
+def foo: Int in class C and
+private def foo[A]: Int at line 2
+have same type after erasure: ()Int
+class D extends C { private def foo[A] = 0 }
+                                ^
+one error found
diff --git a/test/files/neg/t9286b.scala b/test/files/neg/t9286b.scala
new file mode 100644
index 0000000000..5c23075426
--- /dev/null
+++ b/test/files/neg/t9286b.scala
@@ -0,0 +1,5 @@
+class C { def foo = 0 }
+class D extends C { private def foo[A] = 0 }
+
+class E { private def foo = 0 }
+class F extends E { def foo[A] = 0 } // okay
diff --git a/test/files/neg/t9286c.check b/test/files/neg/t9286c.check
new file mode 100644
index 0000000000..785cb3f937
--- /dev/null
+++ b/test/files/neg/t9286c.check
@@ -0,0 +1,7 @@
+t9286c.scala:8: error: name clash between defined and inherited member:
+def foo(m: M[_ >: String]): Int in trait T and
+private def foo(m: M[_ >: Any]): Int at line 8
+have same type after erasure: (m: M)Int
+    def foo(m: M[_ >: Any]) = 0 // Expected: "same type after erasure"
+        ^
+one error found
diff --git a/test/files/neg/t9286c.scala b/test/files/neg/t9286c.scala
new file mode 100644
index 0000000000..3df08dcfe6
--- /dev/null
+++ b/test/files/neg/t9286c.scala
@@ -0,0 +1,14 @@
+class M[_]
+trait T {
+  def foo(m: M[_ >: String]) = 42
+}
+
+object Test {
+  def t: T = new T {
+    def foo(m: M[_ >: Any]) = 0 // Expected: "same type after erasure"
+  }
+  def main(args: Array[String]): Unit = {
+    val m: M[String] = null
+    t.foo(m) // VeriyError: Duplicate method name&signature
+  }
+}
diff --git a/test/files/run/lambda-serialization-gc.scala b/test/files/run/lambda-serialization-gc.scala
new file mode 100644
index 0000000000..8fa0b4b402
--- /dev/null
+++ b/test/files/run/lambda-serialization-gc.scala
@@ -0,0 +1,40 @@
+import java.io._
+
+import java.net.URLClassLoader
+
+class C {
+  def serializeDeserialize[T <: AnyRef](obj: T) = {
+    val buffer = new ByteArrayOutputStream
+    val out = new ObjectOutputStream(buffer)
+    out.writeObject(obj)
+    val in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray))
+    in.readObject.asInstanceOf[T]
+  }
+
+  serializeDeserialize((c: String) => c.length)
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    test()
+  }
+
+  def test(): Unit = {
+    val loader = getClass.getClassLoader.asInstanceOf[URLClassLoader]
+    val loaderCClass = classOf[C]
+    def deserializedInThrowawayClassloader = {
+      val throwawayLoader: java.net.URLClassLoader = new java.net.URLClassLoader(loader.getURLs, ClassLoader.getSystemClassLoader) {
+        val maxMemory = Runtime.getRuntime.maxMemory()
+        val junk = new Array[Byte]((maxMemory / 2).toInt)
+      }
+      val clazz = throwawayLoader.loadClass("C")
+      assert(clazz != loaderCClass)
+      clazz.newInstance()
+    }
+    (1 to 4) foreach { i =>
+      // This would OOM by the third iteration if we leaked `throwawayLoader` during
+      // deserialization.
+      deserializedInThrowawayClassloader
+    }
+  }
+}
diff --git a/test/files/run/lambda-serialization.scala b/test/files/run/lambda-serialization.scala
new file mode 100644
index 0000000000..46b26d7c5e
--- /dev/null
+++ b/test/files/run/lambda-serialization.scala
@@ -0,0 +1,35 @@
+import java.io.{ByteArrayInputStream, ObjectInputStream, ObjectOutputStream, ByteArrayOutputStream}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    roundTrip
+  }
+
+  def roundTrip(): Unit = {
+    val c = new Capture("Capture")
+    val lambda = (p: Param) => ("a", p, c)
+    val reconstituted1 = serializeDeserialize(lambda).asInstanceOf[Object => Any]
+    val p = new Param
+    assert(reconstituted1.apply(p) == ("a", p, c))
+    val reconstituted2 = serializeDeserialize(lambda).asInstanceOf[Object => Any]
+    assert(reconstituted1.getClass == reconstituted2.getClass)
+
+    val reconstituted3 = serializeDeserialize(reconstituted1)
+    assert(reconstituted3.apply(p) == ("a", p, c))
+
+    val specializedLambda = (p: Int) => List(p, c).length
+    assert(serializeDeserialize(specializedLambda).apply(42) == 2)
+    assert(serializeDeserialize(serializeDeserialize(specializedLambda)).apply(42) == 2)
+  }
+
+  def serializeDeserialize[T <: AnyRef](obj: T) = {
+    val buffer = new ByteArrayOutputStream
+    val out = new ObjectOutputStream(buffer)
+    out.writeObject(obj)
+    val in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray))
+    in.readObject.asInstanceOf[T]
+  }
+}
+
+case class Capture(s: String) extends Serializable
+class Param