Merge branch '2.10.x' into topic/merge-v2.10.2-RC1-35-ga54d86b-to-master

Conflicts:
	src/partest/scala/tools/partest/DirectTest.scala

4 files changed, 36 insertions, 11 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 385bf2dade..75fb043070 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -533,7 +533,10 @@ abstract class Constructors extends Transform with ast.TreeDSL {
 
       /* Return a pair consisting of (all statements up to and including superclass and trait constr calls, rest) */
       def splitAtSuper(stats: List[Tree]) = {
-        def isConstr(tree: Tree) = (tree.symbol ne null) && tree.symbol.isConstructor
+        def isConstr(tree: Tree): Boolean = tree match {
+          case Block(_, expr) => isConstr(expr)  // SI-6481 account for named argument blocks
+          case _              => (tree.symbol ne null) && tree.symbol.isConstructor
+        }
         val (pre, rest0) = stats span (!isConstr(_))
         val (supercalls, rest) = rest0 span (isConstr(_))
         (pre ::: supercalls, rest)
diff --git a/src/partest/scala/tools/partest/DirectTest.scala b/src/partest/scala/tools/partest/DirectTest.scala
index 7f9ca3a321..953b5e5535 100644
--- a/src/partest/scala/tools/partest/DirectTest.scala
+++ b/src/partest/scala/tools/partest/DirectTest.scala
@@ -6,6 +6,7 @@
 package scala.tools.partest
 
 import scala.tools.nsc._
+import settings.ScalaVersion
 import util.{ SourceFile, BatchSourceFile, CommandLineParser }
 import reporters.{Reporter, ConsoleReporter}
 
@@ -97,4 +98,30 @@ abstract class DirectTest extends App {
   final def log(msg: => Any) {
     if (isDebug) Console.err println msg
   }
+
+  /**
+   * Run a test only if the current java version is at least the version specified.
+   */
+  def testUnderJavaAtLeast[A](version: String)(yesRun: =>A) = new TestUnderJavaAtLeast(version, { yesRun })
+
+  class TestUnderJavaAtLeast[A](version: String, yesRun: => A) {
+    val javaVersion = System.getProperty("java.specification.version")
+
+    // the "ScalaVersion" class parses Java specification versions just fine
+    val requiredJavaVersion = ScalaVersion(version)
+    val executingJavaVersion = ScalaVersion(javaVersion)
+    val shouldRun = executingJavaVersion >= requiredJavaVersion
+    val preamble = if (shouldRun) "Attempting" else "Doing fallback for"
+
+    def logInfo() = log(s"$preamble java $version specific test under java version $javaVersion")
+ 
+   /*
+    * If the current java version is at least 'version' then 'yesRun' is evaluated
+    * otherwise 'fallback' is 
+    */
+    def otherwise(fallback: =>A): A = {
+      logInfo()
+      if (shouldRun) yesRun else fallback
+    }
+  }
 }
diff --git a/src/reflect/scala/reflect/internal/CapturedVariables.scala b/src/reflect/scala/reflect/internal/CapturedVariables.scala
index 2c5e87b95d..ef9646b80f 100644
--- a/src/reflect/scala/reflect/internal/CapturedVariables.scala
+++ b/src/reflect/scala/reflect/internal/CapturedVariables.scala
@@ -30,7 +30,7 @@ trait CapturedVariables { self: SymbolTable =>
     def refType(valueRef: Map[Symbol, Symbol], objectRefClass: Symbol) =
       if (isPrimitiveValueClass(symClass) && symClass != UnitClass) valueRef(symClass).tpe
       else if (erasedTypes) objectRefClass.tpe
-      else appliedType(objectRefClass, tpe)
+      else appliedType(objectRefClass, tpe1)
     if (vble.hasAnnotation(VolatileAttr)) refType(volatileRefClass, VolatileObjectRefClass)
     else refType(refClass, ObjectRefClass)
   }
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index a3684f602f..16405a88b4 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -581,15 +581,10 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
             loadBytes[Array[String]]("scala.reflect.ScalaLongSignature") match {
               case Some(slsig) =>
                 info(s"unpickling Scala $clazz and $module with long Scala signature")
-                val byteSegments = slsig map (_.getBytes)
-                val lens = byteSegments map ByteCodecs.decode
-                val bytes = Array.ofDim[Byte](lens.sum)
-                var len = 0
-                for ((bs, l) <- byteSegments zip lens) {
-                  bs.copyToArray(bytes, len, l)
-                  len += l
-                }
-                unpickler.unpickle(bytes, 0, clazz, module, jclazz.getName)
+                val encoded = slsig flatMap (_.getBytes)
+                val len = ByteCodecs.decode(encoded)
+                val decoded = encoded.take(len)
+                unpickler.unpickle(decoded, 0, clazz, module, jclazz.getName)
               case None =>
                 // class does not have a Scala signature; it's a Java class
                 info("translating reflection info for Java " + jclazz) //debug