Add support for alternative system images to the compiler

This PR adds a new `-system` / `--system` setting to scalac which mimics its counterpart in javac.

This fixes the biggest problem (at least for us) of scala/bug#13015. It is now possible to compile code against an older system image without enforcing strict module access. scalac generally does not enforce modules (scala/scala-dev#529) but it does when using `-release` (with class lookup based on `ct.sym`) and there was no way to opt out of these restrictions.

The usual opt-out in javac is `--add-exports` but it is not supported for system modules in combination with `--release` (https://bugs.openjdk.org/browse/JDK-8178152) so there is no expectation that scalac could support it. Instead the solution for javac is to replace `--release` with a combination of `-source`, `-target` and a system image for the target version via `--system`. This combination, unlike `--release`, can be used with `--add-exports`. If scalac adds full module support at a later time (with access restrictions enabled by default) it will also need to support `--add-exports` and allow its use in combination with `--system`.

I am also un-deprecating `-target` (which was deprecated in favor of `-release`) because it now has a legitimate use in combination with an alternative system image (just like in javac where it serves the same purpose and is not deprecated, either).

# Conflicts:
#	src/compiler/scala/tools/nsc/Global.scala
#	src/compiler/scala/tools/nsc/classpath/DirectoryClassPath.scala
#	src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala

Author: szeiger

src/compiler/scala/tools/nsc/Global.scala

@@ -138,7 +138,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
   def optimizerClassPath(base: ClassPath): ClassPath =
     base match {
       case AggregateClassPath(entries) if entries.head.isInstanceOf[CtSymClassPath] =>
-        JrtClassPath(release = None, unsafe = None, closeableRegistry) match {
+        JrtClassPath(release = None, settings.systemPathValue, unsafe = None, closeableRegistry) match {
           case jrt :: _ => AggregateClassPath(jrt +: entries.drop(1))
           case _ => base
         }

src/compiler/scala/tools/nsc/classpath/DirectoryClassPath.scala

@@ -15,6 +15,7 @@ package scala.tools.nsc.classpath
 import java.io.{Closeable, File}
 import java.net.{URI, URL}
 import java.nio.file._
+import java.util.Collections
 
 import scala.collection.JavaConverters._
 import scala.reflect.internal.JDK9Reflectors
@@ -130,9 +131,9 @@ trait JFileDirectoryLookup[FileEntryType <: ClassRepresentation] extends Directo
 }
 
 object JrtClassPath {
-  private val jrtClassPathCache = new FileBasedCache[Unit, JrtClassPath]()
+  private val jrtClassPathCache = new FileBasedCache[Option[String], JrtClassPath]()
   private val ctSymClassPathCache = new FileBasedCache[String, CtSymClassPath]()
-  def apply(release: Option[String], unsafe: Option[List[String]], closeableRegistry: CloseableRegistry): List[ClassPath] =
+  def apply(release: Option[String], systemPath: Option[String], unsafe: Option[List[String]], closeableRegistry: CloseableRegistry): List[ClassPath] =
     if (!isJavaAtLeast("9")) Nil
     else {
       // TODO escalate errors once we're sure they are fatal
@@ -148,14 +149,14 @@ object JrtClassPath {
           val ct = createCt(version, closeableRegistry)
           unsafe match {
             case Some(pkgs) if pkgs.nonEmpty =>
-              createJrt(closeableRegistry) match {
+              createJrt(systemPath, closeableRegistry) match {
                 case Nil      => ct
                 case jrt :: _ => ct :+ new FilteringJrtClassPath(jrt, pkgs: _*)
               }
             case _ => ct
           }
         case _ =>
-          createJrt(closeableRegistry)
+          createJrt(systemPath, closeableRegistry)
       }
     }
   private def createCt(v: String, closeableRegistry: CloseableRegistry): List[ClassPath] =
@@ -168,10 +169,15 @@ object JrtClassPath {
     } catch {
       case NonFatal(_) => Nil
     }
-  private def createJrt(closeableRegistry: CloseableRegistry): List[JrtClassPath] =
+  private def createJrt(systemPath: Option[String], closeableRegistry: CloseableRegistry): List[JrtClassPath] =
     try {
-      val fs = FileSystems.getFileSystem(URI.create("jrt:/"))
-      val classPath = jrtClassPathCache.getOrCreate((), Nil, () => new JrtClassPath(fs), closeableRegistry, checkStamps = false)
+      val classPath = jrtClassPathCache.getOrCreate(systemPath, Nil, () => {
+        val fs = systemPath match {
+          case Some(javaHome) => FileSystems.newFileSystem(URI.create("jrt:/"), Collections.singletonMap("java.home", javaHome))
+          case None => FileSystems.getFileSystem(URI.create("jrt:/"))
+        }
+        new JrtClassPath(fs, systemPath.isDefined)
+      }, closeableRegistry, checkStamps = false)
       List(classPath)
     } catch {
       case _: ProviderNotFoundException | _: FileSystemNotFoundException => Nil
@@ -199,7 +205,7 @@ final class FilteringJrtClassPath(delegate: JrtClassPath, allowed: String*) exte
   *
   * The implementation assumes that no classes exist in the empty package.
   */
-final class JrtClassPath(fs: FileSystem) extends ClassPath with NoSourcePaths {
+final class JrtClassPath(fs: FileSystem, closeFS: Boolean) extends ClassPath with NoSourcePaths with Closeable {
   type F = Path
   private val dir: Path = fs.getPath("/packages")
 
@@ -245,6 +251,9 @@ final class JrtClassPath(fs: FileSystem) extends ClassPath with NoSourcePaths {
       }.take(1).toList.headOption
     }
   }
+
+  def close(): Unit =
+    if (closeFS) fs.close()
 }
 
 /**

src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala

@@ -37,6 +37,7 @@ trait StandardScalaSettings { _: MutableSettings =>
   val javaextdirs =       PathSetting ("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs)
   val sourcepath =        PathSetting ("-sourcepath", "Specify location(s) of source files.", "") // Defaults.scalaSourcePath
   val rootdir =           PathSetting ("-rootdir", "The absolute path of the project root directory, usually the git/scm checkout. Used by -Wconf.", "") withAbbreviation "--root-directory"
+  val systemPath =        PathSetting ("-system", "Override location of Java system modules", "") withAbbreviation "--system"
 
   /** Other settings.
    */
@@ -66,6 +67,7 @@ trait StandardScalaSettings { _: MutableSettings =>
     .withAbbreviation("--release")
     .withAbbreviation("-java-output-version")
   def releaseValue: Option[String] = release.valueSetByUser
+  def systemPathValue: Option[String] = systemPath.valueSetByUser
   val target =
     ChoiceSetting("-target", "target", "Target platform for object files. All JVM 1.5 - 1.7 targets are deprecated.", AllTargetVersions, DefaultTargetVersion)
     .withPreSetHook(normalizeTarget)

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

@@ -273,7 +273,7 @@ final class PathResolver(settings: Settings, closeableRegistry: CloseableRegistr
       sourcesInPath(sourcePath)                     // 7. The Scala source path.
     )
 
-    private def jrt: List[ClassPath] = JrtClassPath.apply(settings.releaseValue, settings.unsafe.valueSetByUser, closeableRegistry)
+    private def jrt: List[ClassPath] = JrtClassPath.apply(settings.releaseValue, settings.systemPathValue, settings.unsafe.valueSetByUser, closeableRegistry)
 
     lazy val containers = basis.flatten.distinct