javac: support extra compiler args

Author: georgewfraser

package.json

@@ -66,6 +66,13 @@
                     },
                     "description": "Relative paths from workspace root to .jar files, .zip files, or folders that should be included in the Java class path"
                 },
+                "java.extraCompilerArgs": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Extra compiler args, for example [\"--enable-preview\",\"-source 21\"]."
+                },
                 "java.docPath": {
                     "type": "array",
                     "items": {

src/main/java/org/javacs/CompileBatch.java

@@ -103,7 +103,7 @@ public void close() {
     private static ReusableCompiler.Borrow batchTask(
             JavaCompilerService parent, Collection<? extends JavaFileObject> sources) {
         parent.diags.clear();
-        var options = options(parent.classPath, parent.addExports);
+        var options = options(parent.classPath, parent.addExports, parent.extraArgs);
         return parent.compiler.getTask(parent.fileManager, parent.diags::add, options, List.of(), sources);
     }
 
@@ -112,7 +112,7 @@ private static String joinPath(Collection<Path> classOrSourcePath) {
         return classOrSourcePath.stream().map(Path::toString).collect(Collectors.joining(File.pathSeparator));
     }
 
-    private static List<String> options(Set<Path> classPath, Set<String> addExports) {
+    private static List<String> options(Set<Path> classPath, Set<String> addExports, List<String> extraArgs) {
         var list = new ArrayList<String>();
 
         Collections.addAll(list, "-classpath", joinPath(classPath));
@@ -133,6 +133,7 @@ private static List<String> options(Set<Path> classPath, Set<String> addExports)
                 "-Xlint:unchecked",
                 "-Xlint:varargs",
                 "-Xlint:static");
+        list.addAll(extraArgs);
         for (var export : addExports) {
             list.add("--add-exports");
             list.add(export + "=ALL-UNNAMED");

src/main/java/org/javacs/JavaCompilerService.java

@@ -12,6 +12,7 @@ class JavaCompilerService implements CompilerProvider {
     // Not modifiable! If you want to edit these, you need to create a new instance
     final Set<Path> classPath, docPath;
     final Set<String> addExports;
+    final List<String> extraArgs;
     final ReusableCompiler compiler = new ReusableCompiler();
     final Docs docs;
     final Set<String> jdkClasses = ScanClassPath.jdkTopLevelClasses(), classPathClasses;
@@ -21,7 +22,7 @@ class JavaCompilerService implements CompilerProvider {
     // TODO intercept files that aren't in the batch and erase method bodies so compilation is faster
     final SourceFileManager fileManager;
 
-    JavaCompilerService(Set<Path> classPath, Set<Path> docPath, Set<String> addExports) {
+    JavaCompilerService(Set<Path> classPath, Set<Path> docPath, Set<String> addExports, List<String> extraArgs) {
         System.err.println("Class path:");
         for (var p : classPath) {
             System.err.println("  " + p);
@@ -34,6 +35,7 @@ class JavaCompilerService implements CompilerProvider {
         this.classPath = Collections.unmodifiableSet(classPath);
         this.docPath = Collections.unmodifiableSet(docPath);
         this.addExports = Collections.unmodifiableSet(addExports);
+        this.extraArgs = Collections.unmodifiableList(new ArrayList<>(extraArgs));
         this.docs = new Docs(docPath);
         this.classPathClasses = ScanClassPath.classPathTopLevelClasses(classPath);
         this.fileManager = new SourceFileManager();

src/main/java/org/javacs/JavaLanguageServer.java

@@ -93,11 +93,12 @@ private JavaCompilerService createCompiler() {
 
         var externalDependencies = externalDependencies();
         var classPath = classPath();
+        var extraArgs = extraCompilerArgs();
         var addExports = addExports();
         // If classpath is specified by the user, don't infer anything
         if (!classPath.isEmpty()) {
             javaEndProgress();
-            return new JavaCompilerService(classPath, docPath(), addExports);
+            return new JavaCompilerService(classPath, docPath(), addExports, extraArgs);
         }
         // Otherwise, combine inference with user-specified external dependencies
         else {
@@ -110,7 +111,7 @@ private JavaCompilerService createCompiler() {
             var docPath = infer.buildDocPath();
 
             javaEndProgress();
-            return new JavaCompilerService(classPath, docPath, addExports);
+            return new JavaCompilerService(classPath, docPath, addExports, extraArgs);
         }
     }
 
@@ -134,6 +135,20 @@ private Set<Path> classPath() {
         return paths;
     }
 
+    private List<String> extraCompilerArgs() {
+        if (!settings.has("extraCompilerArgs")) return List.of();
+        var array = settings.getAsJsonArray("extraCompilerArgs");
+        var args = new ArrayList<String>();
+        for (var each : array) {
+            for (var arg : each.getAsString().split("\\s+")) {
+                if (!arg.isEmpty()) {
+                    args.add(arg);
+                }
+            }
+        }
+        return args;
+    }
+
     private Set<Path> docPath() {
         if (!settings.has("docPath")) return Set.of();
         var array = settings.getAsJsonArray("docPath");

src/test/examples/compiler-args-project/UsesPreviewStringTemplate.java

@@ -0,0 +1,6 @@
+class UsesPreviewStringTemplate {
+    void test(String name) {
+        String message = STR."hello \{name}";
+        System.out.println(message);
+    }
+}

src/test/java/org/javacs/BenchmarkPruner.java

@@ -56,7 +56,7 @@ private static JavaCompilerService createCompiler() {
             var workspaceRoot = Paths.get(".").normalize().toAbsolutePath();
             FileStore.setWorkspaceRoots(Set.of(workspaceRoot));
             var classPath = new InferConfig(workspaceRoot).classPath();
-            return new JavaCompilerService(classPath, Collections.emptySet(), Collections.emptySet());
+            return new JavaCompilerService(classPath, Collections.emptySet(), Collections.emptySet(), List.of());
         }
 
         private static void quietBenchmarkLogging() {

src/test/java/org/javacs/ExtraCompilerArgsTest.java

@@ -0,0 +1,69 @@
+package org.javacs;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.notNullValue;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import org.javacs.lsp.Diagnostic;
+import org.javacs.lsp.DiagnosticSeverity;
+import org.javacs.lsp.DidChangeConfigurationParams;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExtraCompilerArgsTest {
+    private static final Path WORKSPACE_ROOT = Paths.get("src/test/examples/compiler-args-project").normalize();
+    private static final Path FILE = WORKSPACE_ROOT.resolve("UsesPreviewStringTemplate.java").normalize();
+
+    private final List<Diagnostic> diagnostics = new ArrayList<>();
+
+    @Before
+    public void clearDiagnostics() {
+        diagnostics.clear();
+    }
+
+    @Test
+    public void reportsErrorWithoutExtraCompilerArgs() {
+        var server = LanguageServerFixture.getJavaLanguageServer(WORKSPACE_ROOT, diagnostics::add);
+
+        server.lint(List.of(FILE));
+
+        assertThat(firstError(), notNullValue());
+    }
+
+    @Test
+    public void appliesExtraCompilerArgsFromSettings() {
+        var server = LanguageServerFixture.getJavaLanguageServer(WORKSPACE_ROOT, diagnostics::add);
+        var change = new DidChangeConfigurationParams();
+        var settings = new JsonObject();
+        var java = new JsonObject();
+        var args = new JsonArray();
+        args.add("--enable-preview");
+        args.add("-source");
+        args.add("21");
+        java.add("extraCompilerArgs", args);
+        settings.add("java", java);
+        change.settings = settings;
+
+        server.didChangeConfiguration(change);
+        server.lint(List.of(FILE));
+
+        assertThat(firstError(), nullValue());
+    }
+
+    private Diagnostic firstError() {
+        Diagnostic error = null;
+        for (var diagnostic : diagnostics) {
+            if (diagnostic.severity == DiagnosticSeverity.Error) {
+                error = diagnostic;
+                break;
+            }
+        }
+        return error;
+    }
+}