src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java

rev 2989 : JDK-8058150

@@ -23,33 +23,44 @@
  * questions.
  */
 package com.sun.tools.javac.main;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
 
 import com.sun.tools.doclint.DocLint;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Source;
+import com.sun.tools.javac.file.BaseFileManager;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.Profile;
 import com.sun.tools.javac.jvm.Target;
 import com.sun.tools.javac.main.OptionHelper.GrumpyHelper;
-import com.sun.tools.javac.file.BaseFileManager;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProviderFactory;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Log.PrefixKind;
+import com.sun.tools.javac.util.Log.WriterKind;
 import com.sun.tools.javac.util.Options;
 import com.sun.tools.javac.util.PropagatedException;
 
 /**
  * Shared option and argument handling for command line and API usage of javac.

@@ -270,10 +281,67 @@
      *      ILLEGAL_ARGUMENT
      */
     private boolean processArgs(Iterable<String> args,
             Set<Option> allowableOpts, OptionHelper helper,
             boolean allowOperands, boolean checkFileManager) {
+        if (!doProcessArgs(args, allowableOpts, helper, allowOperands, checkFileManager))
+            return false;
+
+        String platformString = options.get(Option.RELEASE);
+
+        checkOptionAllowed(platformString == null,
+                option -> error("err.release.bootclasspath.conflict", option.getText()),
+                Option.BOOTCLASSPATH, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
+                Option.XBOOTCLASSPATH_PREPEND, Option.ENDORSEDDIRS, Option.EXTDIRS, Option.SOURCE,
+                Option.TARGET);
+
+        if (platformString != null) {
+            PlatformProvider platformProvider = lookupPlatformProvider(platformString);
+
+            if (platformProvider == null) {
+                error("err.unsupported.release.version", platformString);
+                return false;
+            }
+
+            options.put(Option.SOURCE, platformProvider.getSourceVersion());
+            options.put(Option.TARGET, platformProvider.getTargetVersion());
+
+            context.put(PlatformProvider.class, platformProvider);
+
+            if (!doProcessArgs(platformProvider.getAdditionalOptions(), allowableOpts, helper, allowOperands, checkFileManager))
+                return false;
+
+            Collection<Path> platformCP = platformProvider.getPlatformPath();
+
+            if (platformCP != null) {
+                JavaFileManager fm = getFileManager();
+
+                if (!(fm instanceof StandardJavaFileManager)) {
+                    error("err.release.not.standard.file.manager");
+                    return false;
+                }
+
+                try {
+                    StandardJavaFileManager sfm = (StandardJavaFileManager) fm;
+
+                    sfm.setLocationFromPaths(StandardLocation.PLATFORM_CLASS_PATH, platformCP);
+                } catch (IOException ex) {
+                    log.printLines(PrefixKind.JAVAC, "msg.io");
+                    ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
+                    return false;
+                }
+            }
+        }
+
+        options.notifyListeners();
+
+        return true;
+    }
+
+    private boolean doProcessArgs(Iterable<String> args,
+            Set<Option> allowableOpts, OptionHelper helper,
+            boolean allowOperands, boolean checkFileManager) {
         JavaFileManager fm = checkFileManager ? getFileManager() : null;
         Iterator<String> argIter = args.iterator();
         while (argIter.hasNext()) {
             String arg = argIter.next();
             if (arg.isEmpty()) {

@@ -313,15 +381,12 @@
             } else {
                 if (option.process(helper, arg)) {
                     return false;
                 }
             }
-
         }
 
-        options.notifyListeners();
-
         return true;
     }
 
     /**
      * Validates the overall consistency of the options and operands

@@ -403,11 +468,11 @@
             }
         }
 
         boolean lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);
 
-        if (lintOptions && source.compareTo(Source.DEFAULT) < 0) {
+        if (lintOptions && source.compareTo(Source.DEFAULT) < 0 && !options.isSet(Option.RELEASE)) {
             JavaFileManager fm = getFileManager();
             if (fm instanceof BaseFileManager) {
                 if (((BaseFileManager) fm).isDefaultBootClassPath())
                     log.warning(LintCategory.OPTIONS, "source.no.bootclasspath", source.name);
             }

@@ -433,10 +498,22 @@
             log.warning(LintCategory.OPTIONS, "option.obsolete.suppression");
 
         return !errors;
     }
 
+    private PlatformProvider lookupPlatformProvider(String platform) {
+        Iterable<PlatformProviderFactory> factories =
+                ServiceLoader.load(PlatformProviderFactory.class, Arguments.class.getClassLoader());
+        return StreamSupport.stream(factories.spliterator(), false)
+                            .flatMap(factory -> StreamSupport.stream(factory.createPlatformProviders()
+                                                                            .spliterator(),
+                                                                     false))
+                            .filter(provider -> platform.equals(provider.getName()))
+                            .findFirst()
+                            .orElse(null);
+    }
+
     /**
      * Returns true if there are no files or classes specified for use.
      * @return true if there are no files or classes specified for use
      */
     public boolean isEmpty() {

@@ -526,10 +603,22 @@
             return false;
         }
         return true;
     }
 
+    private interface ErrorReporter {
+        void report(Option o);
+    }
+
+    void checkOptionAllowed(boolean allowed, ErrorReporter r, Option... opts) {
+        if (!allowed) {
+            Stream.of(opts)
+                  .filter(options :: isSet)
+                  .forEach(r :: report);
+        }
+    }
+
     void error(String key, Object... args) {
         errors = true;
         switch (errorMode) {
             case ILLEGAL_ARGUMENT: {
                 String msg = log.localize(PrefixKind.JAVAC, key, args);