Merge remote-tracking branch 'origin/2.10.x' into pr/merge-210

* commit 'd392d56d6bf8b0ae9072b354e4ec68becd0df679':
  SI-4602 Disable unreliable test of fsc path absolutization
  Update a checkfile from a recent fix.
  SI-7018 Fix memory leak in Attachments.
  SI-4733 - fsc no longer creates a single temp directory for all users.
  Bumped partest MaxPermSize to 128m.
  SI-6891 Fix value class + tailrec crasher.
  Ill-scoped reference checking in TreeCheckers
  Make value classes TreeCheckers friendly
  SI-4602 Make fsc absolutize source file names
  SI-6863 Fix verify error in captured var inited from expr with try/catch
  SI-6932 Remove Batchable trait plus minor clean-ups
  Fix SI-6932 by enabling linearization of callback execution for the internal execution context of Future
  SI-6443 Expand test coverage with varargs, by-name.
  SI-6443 Widen dependent param types in uncurry

Conflicts:
	src/reflect/scala/reflect/internal/Trees.scala
	test/partest

8 files changed, 196 insertions, 0 deletions

diff --git a/test/files/run/t6135.scala b/test/files/run/t6135.scala
new file mode 100644
index 0000000000..c0f8f3fd1d
--- /dev/null
+++ b/test/files/run/t6135.scala
@@ -0,0 +1,13 @@
+object Test extends App {
+  class A { class V }
+
+  abstract class B[S] {
+    def foo(t: S, a: A)(v: a.V)
+  }
+
+  val b1 = new B[String] {
+    def foo(t: String, a: A)(v: a.V) = () // Bridge method required here!
+  }
+
+  b1.foo("", null)(null)
+}
diff --git a/test/files/run/t6443-by-name.check b/test/files/run/t6443-by-name.check
new file mode 100644
index 0000000000..6f98fa4a28
--- /dev/null
+++ b/test/files/run/t6443-by-name.check
@@ -0,0 +1,3 @@
+1
+foo
+foo
diff --git a/test/files/run/t6443-by-name.scala b/test/files/run/t6443-by-name.scala
new file mode 100644
index 0000000000..bfd9bf9791
--- /dev/null
+++ b/test/files/run/t6443-by-name.scala
@@ -0,0 +1,18 @@
+object Test {
+
+	def main(args: Array[String]) {
+		def foo = {println("foo"); 0}
+		lazyDep(X)(foo)
+	}
+
+  trait T {
+  	type U
+  }
+  object X extends T { type U = Int }
+
+	def lazyDep(t: T)(u: => t.U) {
+		println("1")
+		u
+		u
+	}
+}
diff --git a/test/files/run/t6443-varargs.check b/test/files/run/t6443-varargs.check
new file mode 100644
index 0000000000..257cc5642c
--- /dev/null
+++ b/test/files/run/t6443-varargs.check
@@ -0,0 +1 @@
+foo
diff --git a/test/files/run/t6443-varargs.scala b/test/files/run/t6443-varargs.scala
new file mode 100644
index 0000000000..9cbae3e99c
--- /dev/null
+++ b/test/files/run/t6443-varargs.scala
@@ -0,0 +1,16 @@
+object Test {
+
+	def main(args: Array[String]) {
+		def foo = {println("foo"); 0}
+		lazyDep(X)(foo)
+	}
+
+  trait T {
+  	type U
+  }
+  object X extends T { type U = Int }
+
+	def lazyDep(t: T)(us: t.U*) {
+		List(us: _*)
+	}
+}
diff --git a/test/files/run/t6443.scala b/test/files/run/t6443.scala
new file mode 100644
index 0000000000..67fe2cab22
--- /dev/null
+++ b/test/files/run/t6443.scala
@@ -0,0 +1,15 @@
+class Base
+class Derived extends Base
+
+trait A {
+  def foo(d: String)(d2: d.type): Base
+  val s = ""
+  def bar: Unit = foo(s)(s)
+}
+object B extends A {
+  def foo(d: String)(d2: d.type): D forSome { type D <: S; type S <: Derived } = {d2.isEmpty; null} // Bridge method required here!
+}
+
+object Test extends App {
+  B.bar
+}
diff --git a/test/files/run/t6443b.scala b/test/files/run/t6443b.scala
new file mode 100644
index 0000000000..9320b1dcfe
--- /dev/null
+++ b/test/files/run/t6443b.scala
@@ -0,0 +1,16 @@
+trait A {
+  type D >: Null <: C
+  def foo(d: D)(d2: d.type): Unit
+  trait C {
+    def bar: Unit = foo(null)(null)
+  }
+}
+object B extends A {
+  class D extends C
+
+  def foo(d: D)(d2: d.type): Unit = () // Bridge method required here!
+}
+
+object Test extends App {
+  new B.D().bar
+}
diff --git a/test/files/run/t6863.scala b/test/files/run/t6863.scala
new file mode 100644
index 0000000000..d77adb6af4
--- /dev/null
+++ b/test/files/run/t6863.scala
@@ -0,0 +1,114 @@
+/** Make sure that when a variable is captured its initialization expression is handled properly */
+object Test {
+  def lazyVal() = {
+  	// internally lazy vals become vars which are initialized with "_", so they need to be tested just like vars do
+  	lazy val x = "42"
+    assert({ () => x }.apply == "42")    
+  }
+  def ident() = {
+    val y = "42"
+    var x = y
+    assert({ () => x }.apply == "42")    
+  }
+  def apply() = {
+    def y(x : Int) = x.toString
+    var x = y(42)
+    assert({ () => x }.apply == "42")        
+  }
+  def literal() = {
+    var x = "42"
+    assert({ () => x }.apply == "42")    
+  }
+  def `new`() = {
+    var x = new String("42")
+    assert({ () => x }.apply == "42")            
+  }
+  def select() = {
+    object Foo{val bar = "42"}
+    var x = Foo.bar
+    assert({ () => x }.apply == "42")            
+  }
+  def `throw`() = {
+    var x = if (true) "42" else throw new Exception("42")
+    assert({ () => x }.apply == "42")            
+  }
+  def assign() = {
+    var y = 1
+    var x = y = 42
+    assert({ () => x}.apply == ())
+  }
+  def valDef() = {
+    var x = {val y = 42}
+    assert({ () => x}.apply == ())
+  }
+  def `return`(): String = {
+    var x = if (true) return "42" else ()
+    assert({ () => x}.apply == ())
+    "42"
+  }
+  def tryFinally() = {
+    var x = try { "42" } finally ()
+    assert({ () => x }.apply == "42")
+  }
+  def tryCatch() = {
+    var x = try { "42" } catch { case _ => "43" }
+    assert({ () => x }.apply == "42")
+  }
+  def `if`() = {
+  	var x = if (true) ()
+    assert({ () => x }.apply == ())
+  }
+  def ifElse() = {
+    var x = if(true) "42" else "43" 
+    assert({ () => x }.apply == "42")
+  }
+  def matchCase() = {
+    var x = 100 match {
+       case 100 => "42"
+      case _ => "43"
+    }
+    assert({ () => x }.apply == "42")
+  }
+  def block() = {
+    var x = {
+      val y = 42
+      "42"
+    }
+    assert({ () => x }.apply == "42")
+  }
+  def labelDef() = {
+    var x = 100 match { 
+      case 100 => try "42" finally ()
+    }
+    assert({ () => x }.apply == "42")
+  }
+  def nested() = {
+    var x = {
+      val y = 42
+        if(true) try "42" catch {case _ => "43"}
+        else "44"       
+    }
+    assert({ () => x }.apply == "42")
+  }
+  def main(args: Array[String]) {
+  	lazyVal()
+    ident()
+    apply()
+    literal()
+    `new`()
+    select()
+    `throw`()
+    assign()
+    valDef()
+    `return`()
+    tryFinally()
+    tryCatch()
+    ifElse()
+    `if`()
+    matchCase()
+    block()
+    labelDef()
+    nested()
+  }
+}
+