11 files changed, 196 insertions, 0 deletions
diff --git a/test/files/neg/t5091.check b/test/files/neg/t5091.check
new file mode 100644
index 0000000000..abd24e3145
--- /dev/null
+++ b/test/files/neg/t5091.check
@@ -0,0 +1,9 @@
+t5091.scala:8: error: recursive value xxx needs type
+    val param = bar(xxx)
+                    ^
+t5091.scala:7: warning: type-checking the invocation of method foo checks if the named argument expression 'param = ...' is a valid assignment
+in the current scope. The resulting type inference error (see above) can be fixed by providing an explicit type in the local definition for param.
+    val xxx = foo(param = null)
+                        ^
+one warning found
+one error found
diff --git a/test/files/neg/t5091.scala b/test/files/neg/t5091.scala
new file mode 100644
index 0000000000..217e83f66d
--- /dev/null
+++ b/test/files/neg/t5091.scala
@@ -0,0 +1,11 @@
+object RecursiveValueNeedsType {
+
+  def foo(param: String) = 42
+  def bar(n: Int) = 42
+
+  {
+    val xxx = foo(param = null)
+    val param = bar(xxx)
+  }
+  
+}
diff --git a/test/files/pos/t5217.scala b/test/files/pos/t5217.scala
new file mode 100644
index 0000000000..1fe3f5696f
--- /dev/null
+++ b/test/files/pos/t5217.scala
@@ -0,0 +1,17 @@
+// private types and terms of companion module are
+// available in scope of ctor params.
+// before 2.10.1, class B in object A cannot be accessed in object A
+object A {
+  private class B
+  private val b: B = new B
+  private type C = Int
+  def apply(): A = new A()
+}
+// if not private, then default arg results in:
+// private class B escapes its defining scope as part of type A.B
+class A private (b: A.B = A.b, c: A.C = 42)
+
+object C {
+  private class B
+}
+class C(b: C.B)
diff --git a/test/files/pos/t6051.scala b/test/files/pos/t6051.scala
new file mode 100644
index 0000000000..854524feb9
--- /dev/null
+++ b/test/files/pos/t6051.scala
@@ -0,0 +1,19 @@
+object Foo1 {
+  def foo(x: Int, y: Int = 10) = x*y
+  lazy val y = foo(x = 20)
+}
+
+object Foo2 {
+  def foo(x: Int, y: Int = 10) = x*y
+  val y = foo(x = 20)
+}
+
+object Foo3 {
+  def foo(x: Int, y: Int = 10) = x*y
+  def y = foo(x = 20)
+}
+
+object Foo4 {
+  def foo(x: Int, y: Int = 10) = x*y
+  var y = foo(x = 20)
+}
diff --git a/test/files/run/repl-javap-lambdas.scala b/test/files/run/repl-javap-lambdas.scala
new file mode 100644
index 0000000000..15e5bf6877
--- /dev/null
+++ b/test/files/run/repl-javap-lambdas.scala
@@ -0,0 +1,23 @@
+import scala.tools.partest.JavapTest
+import scala.tools.nsc.Settings
+
+// see repl-javap-memfun.java for the complementary version
+object Test extends JavapTest {
+  override def transformSettings(s: Settings) = { s.Ydelambdafy.value = "method" ; s }
+  def code = """
+    |object Betty {
+    | List(1,2,3) count (_ % 2 != 0)
+    | def f = List(1,2,3) filter (_ % 2 != 0) map (_ * 2)
+    | def g = List(1,2,3) filter (_ % 2 == 0) map (_ * 3) map (_ + 1)
+    |}
+    |:javap -fun Betty#g
+  """.stripMargin
+
+  // three anonfuns of Betty#g
+  override def yah(res: Seq[String]) = {
+    import PartialFunction.{ cond => when }
+    val r = """\s*private static final .* \$anonfun\$\d+\(.*""".r
+    def filtered = res filter (when(_) { case r(_*) => true })
+    3 == filtered.size
+  }
+}
diff --git a/test/files/run/repl-javap-memfun.scala b/test/files/run/repl-javap-memfun.scala
index d2b4243c8b..d10ebcb399 100644
--- a/test/files/run/repl-javap-memfun.scala
+++ b/test/files/run/repl-javap-memfun.scala
@@ -1,6 +1,10 @@
 import scala.tools.partest.JavapTest
+import scala.tools.nsc.Settings
 
+// see repl-javap-lambdas.scala for the complementary version
 object Test extends JavapTest {
+  // asserting the default
+  override def transformSettings(s: Settings) = { s.Ydelambdafy.value = "inline" ; s }
   def code = """
     |object Betty {
     | List(1,2,3) count (_ % 2 != 0)
diff --git a/test/files/run/t6541-option.scala b/test/files/run/t6541-option.scala
new file mode 100644
index 0000000000..2c10c9e09d
--- /dev/null
+++ b/test/files/run/t6541-option.scala
@@ -0,0 +1,19 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  def code = """
+:setting -Xsource:2.12
+case class C12(clazz: Class[_])
+val o: Option[Class[T] forSome { type T}] = C12.unapply(C12(classOf[String]))
+
+:setting -Xsource:2.11
+import scala.language.existentials
+case class C11(clazz: Class[_])
+val o: Option[Class[T]] forSome { type T } = C11.unapply(C11(classOf[String]))
+  """
+
+  override def show() = {
+    val r = eval().mkString("\n")
+    assert(!(r.contains("warning") || r.contains("error")), r)
+  }
+}
diff --git a/test/files/run/t6541.flags b/test/files/run/t6541.flags
new file mode 100644
index 0000000000..68d0ddfec2
--- /dev/null
+++ b/test/files/run/t6541.flags
@@ -0,0 +1 @@
+-feature -Xfatal-warnings -Xsource:2.12
+\ No newline at end of file
diff --git a/test/files/run/t6541.scala b/test/files/run/t6541.scala
new file mode 100644
index 0000000000..f127143691
--- /dev/null
+++ b/test/files/run/t6541.scala
@@ -0,0 +1,25 @@
+class A
+class B[T](x: T)
+case class C(a: A, b: B[_])
+
+case class D(a: A, b: B[_]*)
+
+case class E(c: Class[_])
+
+object Test extends App {
+  def f1(c: C) = c match {
+    case C(a, b) => ()
+  }
+
+  def f2(d: D) = d match {
+    case D(a, b1, b2) => ()
+  }
+
+  def f3(e: E) = e match {
+    case E(c) => ()
+  }
+
+  f1(C(new A, new B(1)))
+  f2(D(new A, new B(1), new B(2)))
+  f3(E(classOf[E]))
+}
diff --git a/test/files/run/xMigration.check b/test/files/run/xMigration.check
new file mode 100644
index 0000000000..378f7bb6c3
--- /dev/null
+++ b/test/files/run/xMigration.check
@@ -0,0 +1,49 @@
+Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> Map(1 -> "eis").values    // no warn
+res0: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:none
+
+scala> Map(1 -> "eis").values    // no warn
+res1: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:any
+
+scala> Map(1 -> "eis").values    // warn
+<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+`values` returns `Iterable[B]` rather than `Iterator[B]`.
+              Map(1 -> "eis").values    // warn
+                              ^
+res2: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:2.8
+
+scala> Map(1 -> "eis").values    // no warn
+res3: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:2.7
+
+scala> Map(1 -> "eis").values    // warn
+<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+`values` returns `Iterable[B]` rather than `Iterator[B]`.
+              Map(1 -> "eis").values    // warn
+                              ^
+res4: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:2.11
+
+scala> Map(1 -> "eis").values    // no warn
+res5: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration      // same as :any
+
+scala> Map(1 -> "eis").values    // warn
+<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+`values` returns `Iterable[B]` rather than `Iterator[B]`.
+              Map(1 -> "eis").values    // warn
+                              ^
+res6: Iterable[String] = MapLike(eis)
+
+scala> :quit
diff --git a/test/files/run/xMigration.scala b/test/files/run/xMigration.scala
new file mode 100644
index 0000000000..688e878397
--- /dev/null
+++ b/test/files/run/xMigration.scala
@@ -0,0 +1,19 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  def code = """
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration:none
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration:any
+Map(1 -> "eis").values    // warn
+:setting -Xmigration:2.8
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration:2.7
+Map(1 -> "eis").values    // warn
+:setting -Xmigration:2.11
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration      // same as :any
+Map(1 -> "eis").values    // warn
+  """
+}