Merge pull request scala#6151 from retronym/merge/2.10.x-to-2.11.x-20171027

Merge 2.10.x + PR 6113 to 2.11.x [ci: last-only]

Author: retronym

bincompat-forward.whitelist.conf

@@ -628,6 +628,16 @@ filter {
     {
         matchName="scala.reflect.api.SerializedTypeTag.serialVersionUID"
         problemName=MissingFieldProblem
+    },
+
+    {
+        matchName="scala.reflect.io.ZipArchive.ensureDir"
+        problemName=MissingMethodProblem
+    },
+    {
+        matchName="scala.reflect.io.JavaToolsPlatformArchive"
+        problemName=MissingClassProblem
     }
+
   ]
 }

src/compiler/scala/tools/ant/templates/tool-unix.tmpl

@@ -160,7 +160,7 @@ while [[ $# -gt 0 ]]; do
       shift 2
       ;;
     -nobootcp)
-      unset usebootcp
+      usebootcp="false"
       shift
       ;;
     -usebootcp)
@@ -189,15 +189,22 @@ declare -a classpath_args
 
 # default to the boot classpath for speed, except on cygwin/mingw/msys because
 # JLine on Windows requires a custom DLL to be loaded.
-unset usebootcp
-if [[ -z "$cygwin$mingw$msys" ]]; then
+if [[ "$usebootcp" != "false" && -z "$cygwin$mingw$msys" ]]; then
   usebootcp="true"
 fi
 
 # If using the boot classpath, also pass an empty classpath
 # to java to suppress "." from materializing.
-if [[ -n $usebootcp ]]; then
+if [[ "$usebootcp" == "true" ]]; then
   classpath_args=("-Xbootclasspath/a:$TOOL_CLASSPATH" -classpath "\"\"")
+  # Note that the version numbers go 1.7, 1.8, 9, 10, ...
+  java_release="$(cat $JAVA_HOME/release | grep JAVA_VERSION)"
+  if [[ ! "$java_release" =~ JAVA_VERSION=\"1\. ]]; then
+    # Java 9 removed sun.boot.class.path, and the supposed replacement to at least see
+    # the appended boot classpath (jdk.boot.class.path.append) is not visible.
+    # So we have to pass a custom system property that PathResolver will find.
+    classpath_args+=("-Dscala.boot.class.path=$TOOL_CLASSPATH")
+  fi
 else
   classpath_args=(-classpath "$TOOL_CLASSPATH")
 fi

src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala

@@ -1692,17 +1692,17 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
       def div(tk: TypeKind) { emitPrimitive(divOpcodes, tk) }
       def rem(tk: TypeKind) { emitPrimitive(remOpcodes, tk) }
 
-      def invokespecial(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, false)
+      def invokespecial(owner: String, name: String, desc: String, itf: Boolean) {
+        jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, itf)
       }
-      def invokestatic(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false)
+      def invokestatic(owner: String, name: String, desc: String, itf: Boolean) {
+        jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, itf)
       }
-      def invokeinterface(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, true)
+      def invokeinterface(owner: String, name: String, desc: String, itf: Boolean) {
+        jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, itf)
       }
-      def invokevirtual(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false)
+      def invokevirtual(owner: String, name: String, desc: String, itf: Boolean) {
+        jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, itf)
       }
 
       def goTo(label: asm.Label) { jmethod.visitJumpInsn(Opcodes.GOTO, label) }
@@ -2190,15 +2190,20 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
             jmethod.visitFieldInsn(asm.Opcodes.PUTSTATIC, thisName, strMODULE_INSTANCE_FIELD, thisDescr)
           }
         }
+        val itf = if (receiver.isJavaDefined)
+          (if (receiver.isModuleClass) receiver.linkedClassOfClass else receiver).isJavaInterface
+        else
+          receiver.isInterface
+        def checkInterfaceTarget() = if (itf && settings.target.value != "jvm-1.8") reporter.error(call.pos, "Static methods in interface require -target:jvm-1.8")
 
         style match {
-          case Static(true)                            => dbg("invokespecial");  jcode.invokespecial  (jowner, jname, jtype)
-          case Static(false)                           => dbg("invokestatic");   jcode.invokestatic   (jowner, jname, jtype)
-          case Dynamic if needsInterfaceCall(receiver) => dbg("invokinterface"); jcode.invokeinterface(jowner, jname, jtype)
-          case Dynamic                                 => dbg("invokevirtual");  jcode.invokevirtual  (jowner, jname, jtype)
+          case Static(true)                            => dbg("invokespecial");  jcode.invokespecial  (jowner, jname, jtype, itf)
+          case Static(false)                           => dbg("invokestatic");   jcode.invokestatic   (jowner, jname, jtype, itf); checkInterfaceTarget();
+          case Dynamic if needsInterfaceCall(receiver) => dbg("invokinterface"); jcode.invokeinterface(jowner, jname, jtype, itf)
+          case Dynamic                                 => dbg("invokevirtual");  jcode.invokevirtual  (jowner, jname, jtype, itf)
           case SuperCall(_)                            =>
             dbg("invokespecial")
-            jcode.invokespecial(jowner, jname, jtype)
+            jcode.invokespecial(jowner, jname, jtype, itf)
             initModule()
         }
       } // end of genCode()'s genCallMethod()
@@ -2331,11 +2336,11 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
           def genObjsInstr() = (instr: @unchecked) match {
             case BOX(kind) =>
               val MethodNameAndType(mname, mdesc) = jBoxTo(kind)
-              jcode.invokestatic(BoxesRunTime, mname, mdesc)
+              jcode.invokestatic(BoxesRunTime, mname, mdesc, itf = false)
 
             case UNBOX(kind) =>
               val MethodNameAndType(mname, mdesc) = jUnboxTo(kind)
-              jcode.invokestatic(BoxesRunTime, mname, mdesc)
+              jcode.invokestatic(BoxesRunTime, mname, mdesc, itf = false)
 
             case NEW(REFERENCE(cls)) =>
               val className = javaName(cls)
@@ -2373,7 +2378,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
             /* Special handling to access native Array.clone() */
             case call @ CALL_METHOD(definitions.Array_clone, Dynamic) =>
               val target: String = javaType(call.targetTypeKind).getInternalName
-              jcode.invokevirtual(target, "clone", mdesc_arrayClone)
+              jcode.invokevirtual(target, "clone", mdesc_arrayClone, itf = false)
 
             case call @ CALL_METHOD(method, style) => genCallMethod(call)
 
@@ -2718,7 +2723,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
             jcode.invokespecial(
               StringBuilderClassName,
               INSTANCE_CONSTRUCTOR_NAME,
-              mdesc_arglessvoid
+              mdesc_arglessvoid,
+              itf = false
             )
 
           case StringConcat(el) =>
@@ -2729,11 +2735,12 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
             jcode.invokevirtual(
               StringBuilderClassName,
               "append",
-              asm.Type.getMethodDescriptor(StringBuilderType, Array(jtype): _*)
+              asm.Type.getMethodDescriptor(StringBuilderType, Array(jtype): _*),
+              itf = false
             )
 
           case EndConcat =>
-            jcode.invokevirtual(StringBuilderClassName, "toString", mdesc_toString)
+            jcode.invokevirtual(StringBuilderClassName, "toString", mdesc_toString, itf = false)
 
           case _ => abort("Unimplemented primitive " + primitive)
         }

src/compiler/scala/tools/util/PathResolver.scala

@@ -10,14 +10,15 @@ package util
 import java.net.URL
 import scala.tools.reflect.WrappedProperties.AccessControl
 import scala.tools.nsc.Settings
-import scala.tools.nsc.util.{ ClassFileLookup, ClassPath, JavaClassPath }
+import scala.tools.nsc.util.{ ClassFileLookup, ClassPath, DirectoryClassPath, JavaClassPath }
 import scala.reflect.io.{ File, Directory, Path, AbstractFile }
 import scala.reflect.runtime.ReflectionUtils
 import ClassPath.{ JavaContext, DefaultJavaContext, join, split }
 import PartialFunction.condOpt
 import scala.language.postfixOps
 import scala.tools.nsc.classpath.{ AggregateFlatClassPath, ClassPathFactory, FlatClassPath, FlatClassPathFactory }
 import scala.tools.nsc.settings.ClassPathRepresentationType
+import scala.reflect.io.JavaToolsPlatformArchive
 
 // Loosely based on the draft specification at:
 // https://wiki.scala-lang.org/display/SIW/Classpath
@@ -268,9 +269,18 @@ abstract class PathResolverBase[BaseClassPathType <: ClassFileLookup[AbstractFil
 
     import classPathFactory._
 
+    private def javaBootClasspath = {
+      val cp = classesInPath(javaBootClassPath)
+      def okay = cp.exists(_.findClass("java/lang/Object.class").isDefined)
+      val isFlat = settings.YclasspathImpl.value == ClassPathRepresentationType.Flat
+      if (scala.util.Properties.isJavaAtLeast("9") && !isFlat && !okay)
+        cp :+ new DirectoryClassPath(new JavaToolsPlatformArchive(), DefaultJavaContext).asInstanceOf[BaseClassPathType]
+      else cp
+    }
+
     // Assemble the elements!
     def basis = List[Traversable[BaseClassPathType]](
-      classesInPath(javaBootClassPath),             // 1. The Java bootstrap class path.
+      javaBootClasspath,                            // 1. The Java bootstrap class path.
       contentsOfDirsInPath(javaExtDirs),            // 2. The Java extension class path.
       classesInExpandedPath(javaUserClassPath),     // 3. The Java application class path.
       classesInPath(scalaBootClassPath),            // 4. The Scala boot class path.

src/library/scala/util/Properties.scala

@@ -164,29 +164,56 @@ private[scala] trait PropertiesTrait {
   def scalaCmd              = if (isWin) "scala.bat" else "scala"
   def scalacCmd             = if (isWin) "scalac.bat" else "scalac"
 
+
   /** Compares the given specification version to the specification version of the platform.
-   *
-   * @param version a specification version of the form "major.minor"
-   * @return `true` iff the specification version of the current runtime
-   * is equal to or higher than the version denoted by the given string.
-   * @throws NumberFormatException if the given string is not a version string
-   *
-   * @example {{{
-   * // In this example, the runtime's Java specification is assumed to be at version 1.7.
-   * isJavaAtLeast("1.6")            // true
-   * isJavaAtLeast("1.7")            // true
-   * isJavaAtLeast("1.8")            // false
-   * }}}
-   */
+    *
+    *  @param version a specification version number (legacy forms acceptable)
+    *  @return `true` if the specification version of the current runtime
+    *    is equal to or higher than the version denoted by the given string.
+    *  @throws NumberFormatException if the given string is not a version string
+    *
+    *  @example {{{
+    *  // In this example, the runtime's Java specification is assumed to be at version 8.
+    *  isJavaAtLeast("1.8")            // true
+    *  isJavaAtLeast("8")              // true
+    *  isJavaAtLeast("9")              // false
+    *  isJavaAtLeast("9.1")            // false
+    *  isJavaAtLeast("1.9")            // throws
+    *  }}}
+    */
   def isJavaAtLeast(version: String): Boolean = {
-    def parts(x: String) = {
-      val i = x.indexOf('.')
-      if (i < 0) throw new NumberFormatException("Not a version: " + x)
-      (x.substring(0, i), x.substring(i+1, x.length))
+    def versionOf(s: String, depth: Int): (Int, String) =
+      s.indexOf('.') match {
+        case 0 =>
+          (-2, s.substring(1))
+        case 1 if depth == 0 && s.charAt(0) == '1' =>
+          val r0 = s.substring(2)
+          val (v, r) = versionOf(r0, 1)
+          val n = if (v > 8 || r0.isEmpty) -2 else v   // accept 1.8, not 1.9 or 1.
+          (n, r)
+        case -1 =>
+          val n = if (!s.isEmpty) s.toInt else if (depth == 0) -2 else 0
+          (n, "")
+        case i  =>
+          val r = s.substring(i + 1)
+          val n = if (depth < 2 && r.isEmpty) -2 else s.substring(0, i).toInt
+          (n, r)
+      }
+    def compareVersions(s: String, v: String, depth: Int): Int = {
+      if (depth >= 3) 0
+      else {
+        val (sn, srest) = versionOf(s, depth)
+        val (vn, vrest) = versionOf(v, depth)
+        if (vn < 0) -2
+        else if (sn < vn) -1
+        else if (sn > vn) 1
+        else compareVersions(srest, vrest, depth + 1)
+      }
+    }
+    compareVersions(javaSpecVersion, version, 0) match {
+      case -2 => throw new NumberFormatException(s"Not a version: $version")
+      case i  => i >= 0
     }
-    val (v, _v) = parts(version)
-    val (s, _s) = parts(javaSpecVersion)
-    s.toInt >= v.toInt && _s.toInt >= _v.toInt
   }
 
   // provide a main method so version info can be obtained by running this

src/reflect/scala/reflect/internal/Symbols.scala

@@ -3252,7 +3252,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def isAnonOrRefinementClass = isAnonymousClass || isRefinementClass
     override def isAnonymousClass        = name containsName tpnme.ANON_CLASS_NAME
     override def isConcreteClass         = !(this hasFlag ABSTRACT | TRAIT)
-    override def isJavaInterface         = hasAllFlags(JAVA | TRAIT)
+    override def isJavaInterface         = hasAllFlags(JAVA | TRAIT) || hasJavaAnnotationFlag
     override def isNestedClass           = !isTopLevel
     override def isNumericValueClass     = definitions.isNumericValueClass(this)
     override def isNumeric               = isNumericValueClass

src/reflect/scala/reflect/io/AbstractFile.scala

@@ -11,6 +11,7 @@ package io
 import java.io.{ FileOutputStream, IOException, InputStream, OutputStream, BufferedOutputStream, ByteArrayOutputStream }
 import java.io.{ File => JFile }
 import java.net.URL
+
 import scala.collection.mutable.ArrayBuffer
 import scala.reflect.internal.util.Statistics
 

src/reflect/scala/reflect/io/ZipArchive.scala

@@ -9,10 +9,11 @@ package io
 
 import java.net.URL
 import java.io.{ IOException, InputStream, ByteArrayInputStream, FilterInputStream }
-import java.io.{ File => JFile }
-import java.util.zip.{ ZipEntry, ZipFile, ZipInputStream }
+import java.io.{File => JFile}
+import java.util.zip.{ZipEntry, ZipFile, ZipInputStream}
 import java.util.jar.Manifest
-import scala.collection.{ immutable, mutable }
+
+import scala.collection.{immutable, mutable}
 import scala.collection.convert.WrapAsScala.asScalaIterator
 import scala.annotation.tailrec
 
@@ -64,7 +65,7 @@ import ZipArchive._
 abstract class ZipArchive(override val file: JFile) extends AbstractFile with Equals {
   self =>
 
-  override def underlyingSource = Some(this)
+  override def underlyingSource: Some[AbstractFile] = Some(this)
   def isDirectory = true
   def lookupName(name: String, directory: Boolean) = unsupported()
   def lookupNameUnchecked(name: String, directory: Boolean) = unsupported()
@@ -78,7 +79,7 @@ abstract class ZipArchive(override val file: JFile) extends AbstractFile with Eq
   sealed abstract class Entry(path: String) extends VirtualFile(baseName(path), path) {
     // have to keep this name for compat with sbt's compiler-interface
     def getArchive: ZipFile = null
-    override def underlyingSource = Some(self)
+    override def underlyingSource: Some[AbstractFile] = Some(self)
     override def toString = self.path + "(" + path + ")"
   }
 
@@ -94,7 +95,7 @@ abstract class ZipArchive(override val file: JFile) extends AbstractFile with Eq
     }
   }
 
-  private def ensureDir(dirs: mutable.Map[String, DirEntry], path: String, zipEntry: ZipEntry): DirEntry =
+  protected def ensureDir(dirs: mutable.Map[String, DirEntry], path: String, zipEntry: ZipEntry): DirEntry =
     //OPT inlined from getOrElseUpdate; saves ~50K closures on test run.
     // was:
     // dirs.getOrElseUpdate(path, {
@@ -290,3 +291,48 @@ final class ManifestResources(val url: URL) extends ZipArchive(null) {
     }
   }
 }
+
+
+final class JavaToolsPlatformArchive() extends ZipArchive(new java.io.File(System.getProperty("java.home"))) {
+  def iterator: Iterator[Entry] = {
+    import javax.tools._
+    import java.nio.charset.Charset
+    import scala.collection.JavaConverters._
+    val fileManager = ToolProvider.getSystemJavaCompiler.getStandardFileManager(new DiagnosticCollector, java.util.Locale.getDefault, Charset.defaultCharset)
+    val root    = new DirEntry("/")
+    val dirs    = mutable.HashMap[String, DirEntry]("/" -> root)
+    val files: java.lang.Iterable[JavaFileObject] = fileManager.list(StandardLocation.PLATFORM_CLASS_PATH, "", java.util.EnumSet.of(JavaFileObject.Kind.CLASS), true)
+
+    for (f <- files.iterator().asScala) {
+      val binaryName = fileManager.inferBinaryName(StandardLocation.PLATFORM_CLASS_PATH, f)
+      val relativePath = binaryName.replace('.', '/') + ".class"
+      val (packNameDotted, simpleName) = relativePath.lastIndexOf('/') match {
+        case -1 => ("", binaryName)
+        case i => (relativePath.substring(0, i + 1), relativePath.substring(i + 1))
+      }
+      val dir = if (packNameDotted.isEmpty) root else ensureDir(dirs, packNameDotted, null)
+      class FileEntry() extends Entry(relativePath) {
+        override def getArchive   = null
+        override def lastModified = 0L
+        override def input        = f.openInputStream()
+        override def sizeOption   = None
+      }
+      val entry = new FileEntry()
+      dir.entries(simpleName) = entry
+    }
+    root.iterator
+  }
+
+  def name         = file.getName
+  def path         = file.getPath
+  def input        = unsupported
+  def lastModified = file.lastModified
+
+  override def sizeOption = None
+  override def canEqual(other: Any) = other.isInstanceOf[JavaToolsPlatformArchive]
+  override def hashCode() = file.hashCode
+  override def equals(that: Any) = that match {
+    case x: JavaToolsPlatformArchive => true
+    case _                 => false
+  }
+}

test/files/run/classfile-format-51.scala

@@ -81,7 +81,7 @@ object Test extends DirectTest {
 
     val test = cw.visitMethod(ACC_PUBLIC + ACC_FINAL, "test", s"()Ljava/lang/String;", null, null)
     test.visitCode()
-    val bootstrapHandle = new Handle(H_INVOKESTATIC, invokerClassName, bootstrapMethodName, bootStrapMethodType)
+    val bootstrapHandle = new Handle(H_INVOKESTATIC, invokerClassName, bootstrapMethodName, bootStrapMethodType, false)
     test.visitInvokeDynamicInsn("invoke", targetMethodType, bootstrapHandle)
     test.visitInsn(ARETURN)
     test.visitMaxs(1, 1)

test/files/run/t8852a.scala

@@ -5,6 +5,9 @@ import scala.tools.partest._
 object Test extends CompilerTest {
   import global._
 
+
+  override def extraSettings: String = super.extraSettings + " -target:jvm-1.8"
+
   override lazy val units: List[CompilationUnit] = {
     // This test itself does not depend on JDK8.
     javaCompilationUnits(global)(staticMethodInInterface) ++