#1566: Add Argfile class for handling javac argfile creation.

Author: yegor256

src/main/java/com/qulice/errorprone/Argfile.java

@@ -0,0 +1,79 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+package com.qulice.errorprone;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.List;
+
+/**
+ * A {@code javac} argfile materialised on disk.
+ *
+ * <p>Wraps a list of command-line tokens and writes them to a single
+ * file in {@code javac}'s argfile format — one double-quoted token per
+ * line with backslashes and double quotes escaped — so even very long
+ * classpaths and source lists stay below the Windows
+ * {@code CreateProcess} command-line limit when passed to {@code javac}
+ * as {@code @path}. The {@code -J} launcher flags must NOT be included
+ * here; {@code javac} forbids them inside argfiles.</p>
+ *
+ * @since 1.0
+ */
+public final class Argfile {
+
+    /**
+     * Where the argfile will be written.
+     */
+    private final File place;
+
+    /**
+     * Tokens to write, in order, one per line.
+     */
+    private final List<String> args;
+
+    /**
+     * Constructor.
+     * @param place Target file path
+     * @param args Tokens to write
+     */
+    public Argfile(final File place, final List<String> args) {
+        this.place = place;
+        this.args = args;
+    }
+
+    /**
+     * Write the argfile and return its path.
+     * @return The path of the just-written argfile
+     */
+    public File save() {
+        final StringBuilder content = new StringBuilder(this.args.size() * 64);
+        for (final String arg : this.args) {
+            content.append('"');
+            for (int idx = 0; idx < arg.length(); idx += 1) {
+                final char chr = arg.charAt(idx);
+                if (chr == '\\' || chr == '"') {
+                    content.append('\\');
+                }
+                content.append(chr);
+            }
+            content.append('"').append(System.lineSeparator());
+        }
+        try {
+            Files.writeString(
+                this.place.toPath(),
+                content.toString(),
+                StandardCharsets.UTF_8
+            );
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(
+                String.format("Unable to write argfile %s", this.place), ex
+            );
+        }
+        return this.place;
+    }
+}

src/main/java/com/qulice/errorprone/ErrorProneValidator.java

@@ -140,41 +140,54 @@ private List<String> run(final List<File> sources) {
     }
 
     /**
-     * Build the {@code javac} command line.
+     * Build the {@code javac} command line. To stay below the
+     * Windows {@code CreateProcess} 32 KB command-line limit even on
+     * projects with thousands of sources or long classpaths, every
+     * argument other than the launcher itself and the {@code -J}
+     * flags (which {@code javac} forbids inside argfiles) is written
+     * to a temporary argfile and passed as {@code @argfile}.
      * @param sources Java source files to feed
      * @return Argv
      */
     private List<String> command(final List<File> sources) {
         final List<String> command = new ArrayList<>(
-            sources.size() + ErrorProneValidator.JVM_FLAGS.size() + 11
+            ErrorProneValidator.JVM_FLAGS.size() + 2
         );
         command.add(ErrorProneValidator.javac());
         for (final String flag : ErrorProneValidator.JVM_FLAGS) {
             command.add("-J".concat(flag));
         }
-        command.add("-XDcompilePolicy=simple");
-        command.add("-XDaddTypeAnnotationsToSymbol=true");
-        command.add("--should-stop=ifError=FLOW");
-        command.add("-proc:none");
-        command.add("-Xplugin:ErrorProne");
-        command.add("-processorpath");
-        command.add(ErrorProneValidator.pluginClasspath());
         final File outdir = new File(this.env.tempdir(), "errorprone-classes");
         if (!outdir.exists() && !outdir.mkdirs()) {
             throw new IllegalStateException(
                 String.format("Unable to create %s", outdir)
             );
         }
-        command.add("-d");
-        command.add(outdir.getAbsolutePath());
+        final List<String> args = new ArrayList<>(sources.size() + 11);
+        args.add("-XDcompilePolicy=simple");
+        args.add("-XDaddTypeAnnotationsToSymbol=true");
+        args.add("--should-stop=ifError=FLOW");
+        args.add("-proc:none");
+        args.add("-Xplugin:ErrorProne");
+        args.add("-processorpath");
+        args.add(ErrorProneValidator.pluginClasspath());
+        args.add("-d");
+        args.add(outdir.getAbsolutePath());
         final Collection<String> classpath = this.env.classpath();
         if (!classpath.isEmpty()) {
-            command.add("-classpath");
-            command.add(String.join(File.pathSeparator, classpath));
+            args.add("-classpath");
+            args.add(String.join(File.pathSeparator, classpath));
         }
         for (final File source : sources) {
-            command.add(source.getAbsolutePath());
+            args.add(source.getAbsolutePath());
         }
+        command.add(
+            "@".concat(
+                new Argfile(
+                    new File(this.env.tempdir(), "errorprone-args.txt"), args
+                ).save().getAbsolutePath()
+            )
+        );
         return command;
     }
 

src/test/java/com/qulice/errorprone/ArgfileTest.java

@@ -0,0 +1,55 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+package com.qulice.errorprone;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.List;
+import org.hamcrest.MatcherAssert;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/**
+ * Test case for {@link Argfile}.
+ * @since 1.0
+ */
+final class ArgfileTest {
+
+    @Test
+    void writesQuotedTokensOnePerLine(@TempDir final File dir) throws Exception {
+        final File path = new File(dir, "args.txt");
+        new Argfile(
+            path,
+            List.of("-classpath", "C:\\one\\two.jar;C:\\Program Files\\x.jar")
+        ).save();
+        MatcherAssert.assertThat(
+            "argfile must escape backslashes and keep one token per line",
+            Files.readString(path.toPath(), StandardCharsets.UTF_8),
+            Matchers.equalTo(
+                String.join(
+                    System.lineSeparator(),
+                    "\"-classpath\"",
+                    "\"C:\\\\one\\\\two.jar;C:\\\\Program Files\\\\x.jar\"",
+                    ""
+                )
+            )
+        );
+    }
+
+    @Test
+    void escapesEmbeddedDoubleQuotes(@TempDir final File dir) throws Exception {
+        final File path = new File(dir, "args.txt");
+        new Argfile(path, List.of("a\"b")).save();
+        MatcherAssert.assertThat(
+            "embedded double quotes must be backslash-escaped",
+            Files.readString(path.toPath(), StandardCharsets.UTF_8),
+            Matchers.equalTo(
+                String.join(System.lineSeparator(), "\"a\\\"b\"", "")
+            )
+        );
+    }
+}