SpotlessApply uses by default the Java formatter

README.md

@@ -182,6 +182,25 @@ shortcut.
 
 ![Install plugin from disk](./docs/images/install_plugin_from_disk.png)
 
+## Java 21 Support
+
+In [1211](https://github.com/palantir/palantir-java-format/pull/1211) we shipped Java 21 support. In order to use the 
+Java 21 formatting capabilities, ensure that either: 
+
+- the Gradle daemon and the Intellij Project SDK are set to Java 21
+- or that the gradle property `palantir.native.formatter=true`. This will run the formatter as a native image, 
+- independent of the Gradle daemon/Intellij project JDK version. 
+
+### Native image formatter
+
+[This comment](https://github.com/palantir/palantir-java-format/issues/952#issuecomment-2575750610) explains why we 
+switched to a native image for the formatter. The startup time for the native image esp. in Intellij is >10x faster than
+spinning up a new JVM process that does the formatting.
+However, the throughput of running the native image for a large set of files (eg. running `./gradlew spotlessApply`) is 
+considerably slower (eg. 30s using the Java implementation vs 1m20s using the native image implementation). Therefore,
+when running the formatter from `spotlessApply` we will default to using the Java implementation (if the Java version >= 21).
+
+
 ## Future works
 
 - [ ] preserve [NON-NLS markers][] - these are comments that are used when implementing NLS internationalisation, and need to stay on the same line with the strings they come after.

changelog/@unreleased/pr-1243.v2.yml

@@ -0,0 +1,5 @@
+type: fix
+fix:
+  description: SpotlessApply uses Java 21 version
+  links:
+  - https://github.com/palantir/palantir-java-format/pull/1243

gradle-palantir-java-format/src/main/groovy/com/palantir/javaformat/gradle/PalantirJavaFormatIdeaPlugin.java

@@ -60,7 +60,7 @@ public void apply(Project rootProject) {
     }
 
     private static Optional<Configuration> maybeGetNativeImplConfiguration(Project rootProject) {
-        return NativeImageFormatProviderPlugin.shouldUseNativeImage(rootProject)
+        return NativeImageFormatProviderPlugin.isNativeImageConfigured(rootProject)
                 ? Optional.of(rootProject
                         .getConfigurations()
                         .getByName(NativeImageFormatProviderPlugin.NATIVE_CONFIGURATION_NAME))

gradle-palantir-java-format/src/main/groovy/com/palantir/javaformat/gradle/PalantirJavaFormatPlugin.java

@@ -46,7 +46,7 @@ public void apply(Project project) {
             // TODO(dfox): in the future we may want to offer a simple 'format' task so people don't need to use
             // spotless to try out our formatter
             project.getTasks().register("formatDiff", FormatDiffTask.class, task -> {
-                if (NativeImageFormatProviderPlugin.shouldUseNativeImage(project)) {
+                if (NativeImageFormatProviderPlugin.isNativeImageConfigured(project)) {
                     task.getNativeImage().fileProvider(getNativeImplConfiguration(project));
                 }
             });
@@ -76,13 +76,13 @@ public FormatDiffTask() {
         @TaskAction
         public final void formatDiff() throws IOException, InterruptedException {
             if (getNativeImage().isPresent()) {
-                log.info("Using the native-image to format");
+                log.info("Using the native-image formatter");
                 FormatDiff.formatDiff(
                         getProject().getProjectDir().toPath(),
                         new NativeImageFormatterService(
                                 getNativeImage().get().getAsFile().toPath()));
             } else {
-                log.info("Using legacy java formatter");
+                log.info("Using the Java-based formatter");
                 JavaFormatExtension extension =
                         getProject().getRootProject().getExtensions().getByType(JavaFormatExtension.class);
                 FormatterService formatterService = extension.serviceLoad();

gradle-palantir-java-format/src/main/java/com/palantir/javaformat/gradle/NativeImageFormatProviderPlugin.java

@@ -37,7 +37,7 @@ public void apply(Project rootProject) {
                 rootProject == rootProject.getRootProject(),
                 "May only apply com.palantir.java-format-provider to the root project");
 
-        if (!shouldUseNativeImage(rootProject)) {
+        if (!isNativeImageConfigured(rootProject)) {
             log.info("Skipping native image configuration as it is not supported on this platform");
             return;
         }
@@ -68,7 +68,7 @@ public void apply(Project rootProject) {
         });
     }
 
-    public static boolean shouldUseNativeImage(Project project) {
+    public static boolean isNativeImageConfigured(Project project) {
         return isNativeImageSupported() && isNativeFlagEnabled(project);
     }
 

gradle-palantir-java-format/src/main/java/com/palantir/javaformat/gradle/SpotlessInterop.java

@@ -19,6 +19,7 @@
 import com.diffplug.spotless.FormatterStep;
 import com.palantir.javaformat.gradle.spotless.NativePalantirJavaFormatStep;
 import com.palantir.javaformat.gradle.spotless.PalantirJavaFormatStep;
+import org.gradle.api.JavaVersion;
 import org.gradle.api.Project;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
@@ -38,13 +39,19 @@ static void addSpotlessJavaStep(Project project) {
     }
 
     static FormatterStep addSpotlessJavaFormatStep(Project project) {
-        if (NativeImageFormatProviderPlugin.shouldUseNativeImage(project)) {
-            logger.info("Using the native-image palantir-java-formatter");
+
+        if (NativeImageFormatProviderPlugin.isNativeImageConfigured(project)
+                // Native images have lower throughput than Java implementations. This logic gets called by the
+                // Gradle spotlessApply step, which formats a full project.
+                // If we are already running on java 21, then we can run the spotlessApply logic using the Java
+                // formatter. Otherwise, we need to run the native-image.
+                && JavaVersion.current().compareTo(JavaVersion.VERSION_21) < 0) {
+            logger.info("Using the native-image formatter");
             return NativePalantirJavaFormatStep.create(project.getRootProject()
                     .getConfigurations()
                     .getByName(NativeImageFormatProviderPlugin.NATIVE_CONFIGURATION_NAME));
         }
-        logger.info("Using the legacy palantir-java-formatter");
+        logger.info("Using the Java-based formatter {}", JavaVersion.current());
         return PalantirJavaFormatStep.create(
                 project.getRootProject()
                         .getConfigurations()

gradle-palantir-java-format/src/test/groovy/com/palantir/javaformat/gradle/PalantirJavaFormatPluginTest.groovy

@@ -93,8 +93,8 @@ class PalantirJavaFormatPluginTest extends IntegrationTestKitSpec {
         '''.stripIndent()
 
         where:
-        extraGradleProperties    | expectedOutput
-        ""                          | "Using legacy java formatter"
-        "palantir.native.formatter=true"  | "Using the native-image to format"
+        extraGradleProperties | expectedOutput
+        "" | "Using the Java-based formatter"
+        "palantir.native.formatter=true" |  "Using the native-image formatter"
     }
 }

gradle-palantir-java-format/src/test/groovy/com/palantir/javaformat/gradle/PalantirJavaFormatSpotlessPluginTest.groovy

@@ -16,30 +16,69 @@
 package com.palantir.javaformat.gradle
 
 import nebula.test.IntegrationTestKitSpec
+import nebula.test.functional.internal.classpath.ClasspathAddingInitScriptBuilder
 import spock.lang.Unroll
 
+import java.nio.charset.StandardCharsets
+import java.nio.file.Path
+import java.util.concurrent.TimeUnit
+import java.util.stream.Collectors
+import java.util.stream.Stream
+
 class PalantirJavaFormatSpotlessPluginTest extends IntegrationTestKitSpec {
     /** ./gradlew writeImplClasspath generates this file. */
     private static final CLASSPATH_FILE = new File("build/impl.classpath").absolutePath
     private static final NATIVE_IMAGE_FILE = new File("build/nativeImage.path")
     private static final NATIVE_CONFIG = String.format("palantirJavaFormatNative files(\"%s\")", NATIVE_IMAGE_FILE.text)
 
-
     @Unroll
-    def "formats with spotless when spotless is applied"(String extraGradleProperties, String expectedOutput) {
+    def "formats with spotless when spotless is applied"(String extraGradleProperties, String javaVersion, String expectedOutput) {
         def extraDependencies = extraGradleProperties.isEmpty() ? "" : NATIVE_CONFIG
+        settingsFile << """
+             buildscript {
+                repositories {
+                    mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } }
+                    gradlePluginPortal() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } }
+                }
+                 dependencies {
+                     classpath 'com.palantir.gradle.jdks:gradle-jdks-settings:0.62.0'
+                 }
+             }
+            apply plugin: 'com.palantir.jdks.settings'
+        """.stripIndent(true)
+
         buildFile << """
+             buildscript {
+                repositories {
+                    mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } }
+                    gradlePluginPortal() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } }
+                }
+                 dependencies {
+                     classpath 'com.palantir.baseline:gradle-baseline-java:6.21.0'
+                     classpath 'com.palantir.gradle.jdks:gradle-jdks:0.62.0'
+                     classpath 'com.palantir.gradle.jdkslatest:gradle-jdks-latest:0.17.0'
+                 }
+             }
+
             // The 'com.diffplug.spotless:spotless-plugin-gradle' dependency is already added by palantir-java-format
             plugins {
                 id 'java'
-                id 'com.palantir.java-format'
+            }
+
+            apply plugin: 'com.palantir.java-format'     
+            apply plugin: 'com.palantir.baseline-java-versions'
+            apply plugin: 'com.palantir.jdks'
+            apply plugin: 'com.palantir.jdks.latest'
+
+            javaVersions {
+                libraryTarget = ${javaVersion}
             }
 
-            dependencies {
-                palantirJavaFormat files(file("${CLASSPATH_FILE}").text.split(':'))
-                EXTRA_CONFIGURATION
+            jdks {
+                daemonTarget = ${javaVersion}
             }
-        """.replace("EXTRA_CONFIGURATION", extraDependencies).stripIndent()
+
+        """.stripIndent()
 
         // Add jvm args to allow spotless and formatter gradle plugins to run with Java 16+
         file('gradle.properties') << """
@@ -48,27 +87,92 @@ class PalantirJavaFormatSpotlessPluginTest extends IntegrationTestKitSpec {
           --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED \
           --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED \
           --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+        palantir.jdk.setup.enabled=true
         """.stripIndent()
         file('gradle.properties') << extraGradleProperties
+        runTasks('wrapper')
 
         buildFile << """
             apply plugin: 'com.diffplug.spotless'
+
+            dependencies {
+                palantirJavaFormat files(file("${CLASSPATH_FILE}").text.split(':'))
+                ${extraDependencies}
+            }
         """.stripIndent()
 
         file('src/main/java/Main.java').text = invalidJavaFile
 
+
         when:
-        def result = runTasks('spotlessApply', '--info')
+        def result = runGradlewTasks('spotlessApply', '--info')
 
         then:
-        result.output.contains(expectedOutput)
+        result.standardOutput.contains(expectedOutput)
         file('src/main/java/Main.java').text == validJavaFile
 
         where:
-        extraGradleProperties   | expectedOutput
-        "" | "Using the legacy palantir-java-formatter"
-        "palantir.native.formatter=true"  | "Using the native-image"
+        extraGradleProperties               | javaVersion   | expectedOutput
+        ""                                  | 21            | "Using the Java-based formatter"
+        "palantir.native.formatter=true"    | 21            | "Using the Java-based formatter"
+        "palantir.native.formatter=true"    | 17            | "Using the native-image formatter"
+
+    }
+
+    private static Iterable<File> getBuildPluginClasspathInjector() {
+        return getPluginClasspathInjector(Path.of("../gradle-palantir-java-format/build/pluginUnderTestMetadata/plugin-under-test-metadata.properties"))
+    }
+
+    private static Iterable<File> getPluginClasspathInjector(Path path) {
+        File propertiesFile = path.toFile()
+        Properties properties = new Properties()
+        propertiesFile.withInputStream { inputStream ->
+            properties.load(inputStream)
+        }
+        String classpath = properties.getProperty('implementation-classpath')
+        return classpath.split(File.pathSeparator).collect { new File(it) }
+    }
+
+    private GradlewExecutionResult runGradlewTasks(String... tasks) {
+        ProcessBuilder processBuilder = getProcessBuilder(tasks)
+        Process process = processBuilder.start()
+        String output = readAllInput(process.getInputStream())
+        process.waitFor(1, TimeUnit.MINUTES)
+        GradlewExecutionResult result = new GradlewExecutionResult(process.exitValue(), output)
+        assert result.success
+        return result
+    }
+
+    final class GradlewExecutionResult {
+
+        private final Boolean success
+        private final String standardOutput
+        private final Throwable failure
+
+        GradlewExecutionResult(int exitValue, String output) {
+            this.success = exitValue == 0
+            this.standardOutput =  output
+            this.failure = exitValue != 0 ? new RuntimeException(String.format("Build failed with exitCode %s", exitValue)) : null
+        }
+    }
+
+    static String readAllInput(InputStream inputStream) {
+        try (Stream<String> lines =
+                new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)).lines()) {
+            return lines.collect(Collectors.joining("\n"));
+        }
+    }
 
+    private ProcessBuilder getProcessBuilder(String... tasks) {
+        File initScript = new File(projectDir, "init.gradle")
+        ClasspathAddingInitScriptBuilder.build(initScript, getBuildPluginClasspathInjector().toList())
+        List<String> arguments = ["./gradlew", "--init-script", initScript.toPath().toString()]
+        Arrays.asList(tasks).forEach(arguments::add)
+        ProcessBuilder processBuilder = new ProcessBuilder()
+                .command(arguments)
+                .directory(projectDir)
+                .redirectErrorStream(true)
+        return processBuilder
     }
 
     def validJavaFile = '''\