[GR-66817] Make --polyglot the default in AbstractLanguageLauncher

* Improve the --help and error messages for --native and --jvm.

Author: eregon

sdk/src/org.graalvm.launcher/src/org/graalvm/launcher/AbstractLanguageLauncher.java

@@ -289,14 +289,7 @@ final void launch(List<String> args) {
         validateArguments(polyglotOptions);
         argumentsProcessingDone();
 
-        Context.Builder builder;
-        if (isPolyglot()) {
-            builder = Context.newBuilder().options(polyglotOptions);
-        } else {
-            builder = Context.newBuilder(getDefaultLanguages()).options(polyglotOptions);
-        }
-
-        builder.allowAllAccess(true);
+        Context.Builder builder = Context.newBuilder().allowAllAccess(true).options(polyglotOptions);
         setupContextBuilder(builder);
 
         launch(builder);
@@ -305,16 +298,16 @@ final void launch(List<String> args) {
     /**
      * Process command line arguments by either saving the necessary state or adding it to the
      * {@code polyglotOptions}. Any unrecognized arguments should be accumulated and returned as a
-     * list. VM (--jvm/--native/--polyglot/--vm.*) and polyglot options (--language.option or
-     * --option) should be returned as unrecognized arguments to be automatically parsed and
-     * validated by {@link Launcher#parsePolyglotOption(String, Map, boolean, String)}.
-     *
+     * list. VM (--jvm/--native/--vm.*) and polyglot options (--language.option or --option) should
+     * be returned as unrecognized arguments to be automatically parsed and validated by
+     * {@link Launcher#parsePolyglotOption(String, Map, boolean, String)}.
+     * <p>
      * The {@code arguments} should not be modified, but doing so also has no effect.
-     *
+     * <p>
      * {@code polyglotOptions.put()} can be used to set launcher-specific default values when they
      * do not match the OptionKey's default.
-     *
-     * The {@code preprocessArguments} implementations can use {@link Engine} to inspect the the
+     * <p>
+     * The {@code preprocessArguments} implementations can use {@link Engine} to inspect the
      * installed {@link Engine#getLanguages() guest languages} and {@link Engine#getInstruments()
      * instruments}. But creating a {@link Context} or inspecting {@link Engine#getOptions() engine
      * options} is forbidden.
@@ -396,12 +389,15 @@ protected void runVersionAction(VersionAction action, Engine engine) {
     }
 
     /**
-     * The return value specifies what languages should be available by default when not using
-     * --polyglot. Note that TruffleLanguage.Registration#dependentLanguages() should be preferred
-     * in most cases.
+     * The return value used to specify what languages should be available by default when not using
+     * --polyglot. --polyglot is default since 26.0 so this is no longer used. Note that
+     * TruffleLanguage.Registration#dependentLanguages() should be preferred in most cases.
      *
+     * @deprecated no longer has any effect, all languages are always available for
+     *             AbstractLanguageLauncher.
      * @return an array of required language ids
      */
+    @Deprecated(since = "26.0")
     protected String[] getDefaultLanguages() {
         return new String[]{getLanguageId()};
     }

sdk/src/org.graalvm.launcher/src/org/graalvm/launcher/LanguageLauncherBase.java

@@ -74,7 +74,6 @@ public abstract class LanguageLauncherBase extends Launcher {
     private static final String WEBSITE_HEADER = "[website]";
 
     private static Engine tempEngine;
-    private boolean seenPolyglot;
     private VersionAction versionAction = VersionAction.None;
 
     static Engine getTempEngine() {
@@ -167,10 +166,6 @@ static List<Instrument> sortedInstruments(Engine engine) {
         return instruments;
     }
 
-    final boolean isPolyglot() {
-        return seenPolyglot;
-    }
-
     final void setupContextBuilder(Context.Builder builder) {
         Path logFile = getLogFile();
         if (logFile != null) {
@@ -214,7 +209,7 @@ protected boolean runLauncherAction() {
     protected boolean parseCommonOption(String defaultOptionPrefix, Map<String, String> polyglotOptions, boolean experimentalOptions, String arg) {
         switch (arg) {
             case "--polyglot":
-                seenPolyglot = true;
+                // the default, just ignore it
                 break;
             case "--version:graalvm":
                 versionAction = VersionAction.PrintAndExit;

sdk/src/org.graalvm.launcher/src/org/graalvm/launcher/Launcher.java

@@ -91,7 +91,6 @@
 
 public abstract class Launcher {
     private static final boolean STATIC_VERBOSE = Boolean.getBoolean("org.graalvm.launcher.verbose");
-    private static final boolean SHELL_SCRIPT_LAUNCHER = Boolean.getBoolean("org.graalvm.launcher.shell");
 
     /**
      * Default option description indentation.
@@ -480,15 +479,15 @@ protected final void setOptionIndent(int indent) {
     protected abstract OptionDescriptor findOptionDescriptor(String group, String key);
 
     /**
-     * Determines if the tool supports polyglot. Returns true, if {@code --polyglot} option is valid
-     * for this tool and polyglot launcher works for it. The default implementation returns false
-     * only when {@link #isStandalone()} is true.
+     * Deprecated, always returns true.
      *
-     * @return {@code true}, if polyglot is relevant in this launcher.
+     * @deprecated always returns true.
+     * @return {@code true}
      * @since 20.0
      */
+    @Deprecated(since = "26.0")
     protected boolean canPolyglot() {
-        return !isStandalone();
+        return true;
     }
 
     /**
@@ -517,7 +516,7 @@ private String[] executableNames(String basename) {
 
     /**
      * Returns the name of the main class for this launcher.
-     *
+     * <p>
      * Typically:
      *
      * <pre>
@@ -629,22 +628,13 @@ protected boolean runLauncherAction() {
      * @since 20.0
      */
     protected void printDefaultHelp(OptionCategory printCategory) {
-        final VMType defaultVMType = SHELL_SCRIPT_LAUNCHER ? VMType.JVM : this.getDefaultVMType();
-
         printHelp(printCategory);
         out.println();
         out.println("Runtime options:");
 
         setOptionIndent(45);
-        if (canPolyglot()) {
-            launcherOption("--polyglot", "Run with all other guest languages accessible.");
-        }
-        if (!SHELL_SCRIPT_LAUNCHER) {
-            launcherOption("--native", "Run using the native launcher with limited access to Java libraries" + (defaultVMType == VMType.Native ? " (default)" : "") + ".");
-        }
-        if (!isStandalone()) {
-            launcherOption("--jvm", "Run on the Java Virtual Machine with access to Java libraries" + (defaultVMType == VMType.JVM ? " (default)" : "") + ".");
-        }
+        launcherOption("--native", "Ensure to run in Native mode.");
+        launcherOption("--jvm", "Ensure to run in JVM mode.");
         // @formatter:off
         launcherOption("--vm.[option]",                 "Pass options to the host VM. To see available options, use '--help:vm'.");
         launcherOption("--log.file=<String>",           "Redirect guest languages logging into a given file.");
@@ -693,7 +683,7 @@ static String optionsTitle(String kind, OptionCategory optionCategory) {
      * the generic launcher / VM ones.
      *
      * @param defaultOptionPrefix (language) prefix for the options
-     * @param polyglotOptions options being built for the polyglot launcher
+     * @param polyglotOptions options being built for the polyglot context
      * @param unrecognizedArgs arguments (options) to evaluate
      * @since 20.0
      */
@@ -723,8 +713,8 @@ protected final void parseUnrecognizedOptions(String defaultOptionPrefix, Map<St
     /**
      * Parses an option, returning success. The method is called to parse `arg` option from the
      * commandline, not recognized by the application. The method may contribute to the
-     * `polyglotOptions` (in/out parameter, modifiable) to alter polyglot behaviour. If the option
-     * is recognized, the method must return {@code true}.
+     * `polyglotOptions` (in/out parameter, modifiable) to alter polyglot options. If the option is
+     * recognized, the method must return {@code true}.
      *
      * @param defaultOptionPrefix default prefix for the option names, derived from the launching
      *            application.
@@ -792,12 +782,12 @@ private void parseHelpArg(String arg) {
     void parsePolyglotOption(String defaultOptionPrefix, Map<String, String> polyglotOptions, boolean experimentalOptions, String arg) {
         if (arg.equals("--jvm")) {
             if (isAOT()) {
-                throw abort("should not reach here: jvm option failed to switch to JVM");
+                throw abort("--jvm is not supported in a Native standalone");
             }
             return;
         } else if (arg.equals("--native")) {
             if (!isAOT()) {
-                throw abort("native options are not supported on the JVM");
+                throw abort("--native is not supported in a JVM standalone");
             }
             return;
         } else if (arg.startsWith("--vm.") && arg.length() > "--vm.".length()) {
@@ -883,9 +873,6 @@ void parsePolyglotOption(String defaultOptionPrefix, Map<String, String> polyglo
     private Set<String> collectAllArguments() {
         Set<String> options = new LinkedHashSet<>();
         collectArguments(options);
-        if (canPolyglot()) {
-            options.add("--polyglot");
-        }
         if (!isStandalone()) {
             options.add("--jvm");
         }
@@ -1223,10 +1210,10 @@ protected final void maybeNativeExec(List<String> args, boolean isPolyglotLaunch
      * {@link #isAOT()} is true. If the result is to run native, then it applies VM options on the
      * current process.
      * <p>
-     * The method parses the {@code unrecognizedArgs} for --jvm/--native/--polyglot flags and --vm.*
-     * options. If JVM mode is requested, it execs a Java process configured with supported JVM
-     * parameters and system properties over this process - in this case, the method does not return
-     * (except errors).
+     * The method parses the {@code unrecognizedArgs} for --jvm/--native flags and --vm.* options.
+     * If JVM mode is requested, it execs a Java process configured with supported JVM parameters
+     * and system properties over this process - in this case, the method does not return (except
+     * errors).
      *
      * @param originalArgs the original arguments from main(), unmodified.
      * @param unrecognizedArgs a subset of {@code originalArgs} that was not recognized by
@@ -1245,7 +1232,6 @@ protected final void maybeNativeExec(List<String> originalArgs, List<String> unr
     void maybeExec(List<String> originalArgs, List<String> unrecognizedArgs, VMType defaultVmType, boolean thinLauncher) {
         assert isAOT();
         VMType vmType = null;
-        boolean polyglot = false;
         List<String> jvmArgs = new ArrayList<>();
         List<String> applicationArgs = new ArrayList<>(originalArgs);
 
@@ -1284,24 +1270,17 @@ void maybeExec(List<String> originalArgs, List<String> unrecognizedArgs, VMType
                     vmOptions.add(vmArg);
                 }
                 iterator.remove();
-            } else if (arg.equals("--polyglot")) {
-                polyglot = true;
             }
         }
-        boolean isDefaultVMType = false;
         if (vmType == null) {
             vmType = defaultVmType;
-            isDefaultVMType = true;
         }
 
         if (vmType == VMType.JVM) {
             for (String vmOption : vmOptions) {
                 jvmArgs.add('-' + vmOption);
             }
 
-            if (polyglot) {
-                applicationArgs.add(0, "--polyglot");
-            }
             assert !isStandalone();
             if (thinLauncher) {
                 Map<String, String> env = new HashMap<>();
@@ -1328,14 +1307,6 @@ void maybeExec(List<String> originalArgs, List<String> unrecognizedArgs, VMType
              * option values.
              */
             VMRuntime.initialize();
-
-            if (polyglot) {
-                assert jvmArgs.isEmpty();
-                if (isStandalone()) {
-                    throw abort("--polyglot option is only supported when this launcher is part of a GraalVM.");
-                }
-                executePolyglot(applicationArgs, Collections.emptyMap(), !isDefaultVMType);
-            }
         }
     }
 
@@ -1357,24 +1328,8 @@ protected void executeJVM(String classpath, List<String> jvmArgs, List<String> r
         nativeAccess.execJVM(classpath, jvmArgs, remainingArgs);
     }
 
-    @SuppressWarnings("unused")
-    @Deprecated(since = "20.3")
-    protected void executePolyglot(List<String> mainArgs, Map<String, String> polyglotOptions, boolean forceNative) {
-        executePolyglot(mainArgs, forceNative);
-    }
-
-    /**
-     * Called to execute the bin/polyglot launcher with the supplied options. Subclasses may
-     * eventually override and implement in a different way.
-     *
-     * @param mainArgs program arguments
-     */
-    protected void executePolyglot(List<String> mainArgs, boolean forceNative) {
-        nativeAccess.executePolyglot(mainArgs, forceNative);
-    }
-
     class Native {
-        // execve() to JVM/polyglot from native if needed.
+        // execve() to JVM from native if needed.
         // Only parses --jvm/--native to find the VMType and --vm.* to pass/set the VM options.
 
         private void setNativeOption(String arg) {
@@ -1528,18 +1483,6 @@ private void printNativeHelp() {
             printBasicNativeHelp();
         }
 
-        private void executePolyglot(List<String> args, boolean forceNative) {
-            List<String> command = new ArrayList<>(args.size() + 3);
-            Path executable = getGraalVMBinaryPath("polyglot");
-            if (forceNative) {
-                command.add("--native");
-            }
-            command.add("--use-launcher");
-            command.add(getMainClass());
-            command.addAll(args);
-            exec(executable, command);
-        }
-
         private void execJVM(String classpath, List<String> jvmArgs, List<String> args) {
             // TODO use String[] for command to avoid a copy later
             List<String> command = new ArrayList<>(jvmArgs.size() + args.size() + 4);

truffle/src/org.graalvm.polybench/src/org/graalvm/polybench/PolyBenchLauncher.java

@@ -301,11 +301,6 @@ protected String getLanguageId() {
         return "js";
     }
 
-    @Override
-    protected String[] getDefaultLanguages() {
-        return new String[0];
-    }
-
     @Override
     protected void printHelp(OptionCategory maxCategory) {
         try {