add replacement reflect classes for native-image

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

@@ -17,7 +17,8 @@
 package com.palantir.javaformat.gradle
 
 class ConfigureJavaFormatterXml {
-    static void configureJavaFormat(Node rootNode, List<URI> uris) {
+
+    static void configureJavaFormat(Node rootNode, List<URI> uris, URI nativeImageUri, Boolean useLegacyUris) {
         def settings = matchOrCreateChild(rootNode, 'component', [name: 'PalantirJavaFormatSettings'])
         // enable
         matchOrCreateChild(settings, 'option', [name: 'enabled']).attributes().put('value', 'true')
@@ -28,6 +29,12 @@ class ConfigureJavaFormatterXml {
         uris.forEach { URI uri ->
             listItems.appendNode('option', [value: uri])
         }
+        // configure nativeImageClasspath
+        matchOrCreateChild(settings, 'option', [name: 'nativeImageClassPath']).attributes().put('value', nativeImageUri)
+
+        // configure default classPath to use
+        String defaultClassPath = useLegacyUris ? "implementationClassPath" : "nativeImageClassPath"
+        matchOrCreateChild(settings, 'option', [name: 'defaultClassPath']).attributes().put('value', defaultClassPath)
     }
 
     static void configureExternalDependencies(Node rootNode) {

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

@@ -29,6 +29,7 @@
 import java.net.URI;
 import java.nio.charset.Charset;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import javax.xml.parsers.ParserConfigurationException;
@@ -47,23 +48,31 @@ public void apply(Project rootProject) {
                 "May only apply com.palantir.java-format-idea to the root project");
 
         rootProject.getPlugins().apply(PalantirJavaFormatProviderPlugin.class);
-
+        Boolean useLegacyFormatter = Optional.ofNullable(rootProject.findProperty("palantir.legacy.formatter"))
+                .map(value -> Boolean.getBoolean((String) value))
+                .orElse(false);
         rootProject.getPluginManager().withPlugin("idea", ideaPlugin -> {
             Configuration implConfiguration =
                     rootProject.getConfigurations().getByName(PalantirJavaFormatProviderPlugin.CONFIGURATION_NAME);
 
-            configureLegacyIdea(rootProject, implConfiguration);
-            configureIntelliJImport(rootProject, implConfiguration);
+            Configuration nativeImplConfiguration = rootProject
+                    .getConfigurations()
+                    .getByName(PalantirJavaFormatProviderPlugin.NATIVE_CONFIGURATION_NAME);
+
+            configureLegacyIdea(rootProject, implConfiguration, nativeImplConfiguration, useLegacyFormatter);
+            configureIntelliJImport(rootProject, implConfiguration, nativeImplConfiguration, useLegacyFormatter);
         });
     }
 
-    private static void configureLegacyIdea(Project project, Configuration implConfiguration) {
+    private static void configureLegacyIdea(
+            Project project, Configuration implConfiguration, Configuration nativeImplConfiguration, Boolean useLegacyFormatter) {
         IdeaModel ideaModel = project.getExtensions().getByType(IdeaModel.class);
         ideaModel.getProject().getIpr().withXml(xmlProvider -> {
             // this block is lazy
             List<URI> uris =
                     implConfiguration.getFiles().stream().map(File::toURI).collect(Collectors.toList());
-            ConfigureJavaFormatterXml.configureJavaFormat(xmlProvider.asNode(), uris);
+            URI nativeUri = nativeImplConfiguration.getSingleFile().toURI();
+            ConfigureJavaFormatterXml.configureJavaFormat(xmlProvider.asNode(), uris, nativeUri, useLegacyFormatter);
             ConfigureJavaFormatterXml.configureExternalDependencies(xmlProvider.asNode());
         });
 
@@ -72,7 +81,8 @@ private static void configureLegacyIdea(Project project, Configuration implConfi
         });
     }
 
-    private static void configureIntelliJImport(Project project, Configuration implConfiguration) {
+    private static void configureIntelliJImport(
+            Project project, Configuration implConfiguration, Configuration nativeImplConfiguration, Boolean useLegacyFormatter) {
         // Note: we tried using 'org.jetbrains.gradle.plugin.idea-ext' and afterSync triggers, but these are currently
         // very hard to manage as the tasks feel disconnected from the Sync operation, and you can't remove them once
         // you've added them. For that reason, we accept that we have to resolve this configuration at
@@ -84,9 +94,11 @@ private static void configureIntelliJImport(Project project, Configuration implC
             List<URI> uris =
                     implConfiguration.getFiles().stream().map(File::toURI).collect(Collectors.toList());
 
+            URI nativeImageUri = nativeImplConfiguration.getSingleFile().toURI();
+
             createOrUpdateIdeaXmlFile(
                     project.file(".idea/palantir-java-format.xml"),
-                    node -> ConfigureJavaFormatterXml.configureJavaFormat(node, uris));
+                    node -> ConfigureJavaFormatterXml.configureJavaFormat(node, uris, nativeImageUri, useLegacyFormatter));
             createOrUpdateIdeaXmlFile(
                     project.file(".idea/externalDependencies.xml"),
                     node -> ConfigureJavaFormatterXml.configureExternalDependencies(node));
@@ -95,7 +107,7 @@ private static void configureIntelliJImport(Project project, Configuration implC
 
             // Still configure legacy idea if using intellij import
             updateIdeaXmlFileIfExists(project.file(project.getName() + ".ipr"), node -> {
-                ConfigureJavaFormatterXml.configureJavaFormat(node, uris);
+                ConfigureJavaFormatterXml.configureJavaFormat(node, uris, nativeImageUri, useLegacyFormatter);
                 ConfigureJavaFormatterXml.configureExternalDependencies(node);
             });
             updateIdeaXmlFileIfExists(project.file(project.getName() + ".iws"), node -> {
@@ -130,7 +142,7 @@ private static void updateIdeaXmlFile(File configurationFile, Consumer<Node> con
         configure.accept(rootNode);
 
         try (BufferedWriter writer = Files.newWriter(configurationFile, Charset.defaultCharset());
-                PrintWriter printWriter = new PrintWriter(writer)) {
+             PrintWriter printWriter = new PrintWriter(writer)) {
             XmlNodePrinter nodePrinter = new XmlNodePrinter(printWriter);
             nodePrinter.setPreserveWhitespace(true);
             nodePrinter.print(rootNode);

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

@@ -18,7 +18,6 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
-import java.util.Optional;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
@@ -28,59 +27,61 @@ public final class PalantirJavaFormatProviderPlugin implements Plugin<Project> {
 
     static final String CONFIGURATION_NAME = "palantirJavaFormat";
 
+    static final String NATIVE_CONFIGURATION_NAME = "palantirJavaFormatNative";
+
     @Override
     public void apply(Project rootProject) {
         Preconditions.checkState(
                 rootProject == rootProject.getRootProject(),
                 "May only apply com.palantir.java-format-provider to the root project");
-        Boolean legacyFormatter = Optional.ofNullable(rootProject.findProperty("palantir.legacy.formatter"))
-                .map(value -> Boolean.getBoolean((String) value))
-                .orElse(false);
+
+        String implementationVersion = JavaFormatExtension.class.getPackage().getImplementationVersion();
 
         Configuration configuration = rootProject.getConfigurations().create(CONFIGURATION_NAME);
         configuration.setDescription("Internal configuration for resolving the palantir-java-format implementation");
         configuration.setVisible(false);
         configuration.setCanBeConsumed(false);
         configuration.setCanBeResolved(true);
+        configuration.defaultDependencies(deps -> {
+            deps.add(rootProject
+                    .getDependencies()
+                    .create(ImmutableMap.of(
+                            "group",
+                            "com.palantir.javaformat",
+                            "name",
+                            "palantir-java-format",
+                            "version",
+                            implementationVersion)));
+        });
 
-        if (legacyFormatter) {
-            configuration.defaultDependencies(deps -> {
-                deps.add(rootProject
-                        .getDependencies()
-                        .create(ImmutableMap.of(
-                                "group",
-                                "com.palantir.javaformat",
-                                "name",
-                                "palantir-java-format",
-                                "version",
-                                JavaFormatExtension.class.getPackage().getImplementationVersion())));
-            });
-        } else {
-            configuration.defaultDependencies(deps -> {
-                deps.add(rootProject
-                        .getDependencies()
-                        .create(ImmutableMap.of(
-                                "group",
-                                "com.palantir.javaformat",
-                                "name",
-                                "palantir-java-format-native",
-                                "version",
-                                JavaFormatExtension.class.getPackage().getImplementationVersion(),
-                                "classifier",
-                                "nativeImage",
-                                "ext",
-                                "sh")));
-            });
-            configuration
-                    .getAttributes()
-                    .attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
-            rootProject.getDependencies().registerTransform(ExecutableTransform.class, transformSpec -> {
-                transformSpec.getFrom().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "sh");
-                transformSpec
-                        .getTo()
-                        .attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
-            });
-        }
+        Configuration nativeConfiguration = rootProject.getConfigurations().create(NATIVE_CONFIGURATION_NAME);
+        nativeConfiguration.setDescription(
+                "Internal configuration for resolving the palantir-java-format implementation");
+        nativeConfiguration.setVisible(false);
+        nativeConfiguration.setCanBeConsumed(false);
+        nativeConfiguration.setCanBeResolved(true);
+        nativeConfiguration.defaultDependencies(deps -> {
+            deps.add(rootProject
+                    .getDependencies()
+                    .create(ImmutableMap.of(
+                            "group",
+                            "com.palantir.javaformat",
+                            "name",
+                            "palantir-java-format-native",
+                            "version",
+                            implementationVersion,
+                            "classifier",
+                            "nativeImage",
+                            "ext",
+                            "sh")));
+        });
+        nativeConfiguration
+                .getAttributes()
+                .attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
+        rootProject.getDependencies().registerTransform(ExecutableTransform.class, transformSpec -> {
+            transformSpec.getFrom().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "sh");
+            transformSpec.getTo().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
+        });
 
         rootProject.getExtensions().create("palantirJavaFormat", JavaFormatExtension.class, configuration);
     }

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

@@ -31,8 +31,7 @@ public void apply(Project project) {
         project.getPluginManager().withPlugin("java", _javaPlugin -> {
             SPOTLESS_PLUGINS.forEach(
                     spotlessPluginId -> project.getPluginManager().withPlugin(spotlessPluginId, _spotlessPlugin -> {
-                        SpotlessInterop.addSpotlessJavaStep(
-                                project, PalantirJavaFormatProviderPlugin.CONFIGURATION_NAME);
+                        SpotlessInterop.addSpotlessJavaStep(project);
                     }));
         });
     }

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

@@ -34,24 +34,24 @@ final class SpotlessInterop {
     private SpotlessInterop() {
     }
 
-    static void addSpotlessJavaStep(Project project, String configurationName) {
+    static void addSpotlessJavaStep(Project project) {
         SpotlessExtension spotlessExtension = project.getExtensions().getByType(SpotlessExtension.class);
-        spotlessExtension.java(java -> java.addStep(addSpotlessJavaFormatStep(project, configurationName)));
+        spotlessExtension.java(java -> java.addStep(addSpotlessJavaFormatStep(project)));
     }
 
-    static FormatterStep addSpotlessJavaFormatStep(Project project, String configurationName) {
+    static FormatterStep addSpotlessJavaFormatStep(Project project) {
         Boolean legacyFormatter = Optional.ofNullable(project.findProperty("palantir.legacy.formatter"))
                 .map(value -> Boolean.getBoolean((String) value))
                 .orElse(false);
         if (legacyFormatter) {
             logger.info("Using the legacy palantir-java-formatter");
             return PalantirJavaFormatStep.create(
-                    project.getRootProject().getConfigurations().getByName(configurationName),
+                    project.getRootProject().getConfigurations().getByName(PalantirJavaFormatProviderPlugin.CONFIGURATION_NAME),
                     project.getRootProject().getExtensions().getByType(JavaFormatExtension.class));
         } else {
             logger.info("Using the native-image palantir-java-formatter");
             return NativePalantirJavaFormatStep.create(
-                    project.getRootProject().getConfigurations().getByName(configurationName));
+                    project.getRootProject().getConfigurations().getByName(PalantirJavaFormatProviderPlugin.NATIVE_CONFIGURATION_NAME));
         }
     }
 }

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

@@ -58,6 +58,7 @@ class ConfigureJavaFormatterXmlTest extends Specification {
                 <option value="bar"/>
               </list>
             </option>
+            <option name="nativeImageClassPath" value="nativeFoo"/>
           </component>
         </root>
         """.stripIndent()
@@ -67,7 +68,7 @@ class ConfigureJavaFormatterXmlTest extends Specification {
         def node = new XmlParser().parseText(MISSING_ENTIRE_BLOCK)
 
         when:
-        ConfigureJavaFormatterXml.configureJavaFormat(node, ['foo', 'bar'].collect { URI.create(it) })
+        ConfigureJavaFormatterXml.configureJavaFormat(node, ['foo', 'bar'].collect { URI.create(it) }, URI.create('nativeFoo'))
 
         then:
         xmlToString(node) == EXPECTED
@@ -77,7 +78,7 @@ class ConfigureJavaFormatterXmlTest extends Specification {
         def node = new XmlParser().parseText(MISSING_CLASS_PATH)
 
         when:
-        ConfigureJavaFormatterXml.configureJavaFormat(node, ['foo', 'bar'].collect { URI.create(it) })
+        ConfigureJavaFormatterXml.configureJavaFormat(node, ['foo', 'bar'].collect { URI.create(it) },  URI.create('nativeFoo'))
 
         then:
         xmlToString(node) == """\
@@ -91,6 +92,7 @@ class ConfigureJavaFormatterXmlTest extends Specification {
                 <option value="bar"/>
               </list>
             </option>
+            <option name="nativeImageClassPath" value="nativeFoo"/>
           </component>
         </root>
         """.stripIndent()
@@ -100,7 +102,7 @@ class ConfigureJavaFormatterXmlTest extends Specification {
         def node = new XmlParser().parseText(EXISTING_CLASS_PATH)
 
         when:
-        ConfigureJavaFormatterXml.configureJavaFormat(node, ['foo', 'bar'].collect { URI.create(it) })
+        ConfigureJavaFormatterXml.configureJavaFormat(node, ['foo', 'bar'].collect { URI.create(it) }, URI.create('nativeFoo'))
 
         then:
         xmlToString(node) == EXPECTED

idea-plugin/src/main/java/com/palantir/javaformat/intellij/FormatterProvider.java

@@ -31,6 +31,7 @@
 import com.intellij.openapi.util.BuildNumber;
 import com.intellij.openapi.util.SystemInfo;
 import com.palantir.javaformat.bootstrap.BootstrappingFormatterService;
+import com.palantir.javaformat.bootstrap.NativeImageFormatterService;
 import com.palantir.javaformat.java.FormatterService;
 import java.io.IOException;
 import java.net.MalformedURLException;
@@ -64,11 +65,18 @@ Optional<FormatterService> get(Project project, PalantirJavaFormatSettings setti
                 project,
                 getSdkVersion(project),
                 settings.getImplementationClassPath(),
-                settings.injectedVersionIsOutdated()));
+                settings.getNativeImageClassPath(),
+                settings.getDefaultClassPath(),
+                settings.injectedVersionIsOutdated()
+        ));
     }
 
     @SuppressWarnings("for-rollout:Slf4jLogsafeArgs")
     private static Optional<FormatterService> createFormatter(FormatterCacheKey cacheKey) {
+        if (cacheKey.defaultClassPath.orElse("implementationClassPath").equals("nativeImageClassPath")) {
+            log.info("Using the native formatter with classpath: {}", cacheKey.nativeImageClassPath.get());
+            return Optional.of(new NativeImageFormatterService(Path.of(cacheKey.nativeImageClassPath.get())));
+        }
         if (cacheKey.jdkMajorVersion.isEmpty()) {
             return Optional.empty();
         }
@@ -90,6 +98,7 @@ private static Optional<FormatterService> createFormatter(FormatterCacheKey cach
         log.info("Using in-process formatter for jdk version {}", jdkMajorVersion);
         URL[] implementationUrls = toUrlsUnchecked(implementationClasspath);
         ClassLoader classLoader = new URLClassLoader(implementationUrls, FormatterService.class.getClassLoader());
+        // TODO(crogoz): actually load the Bootrapper
         return ServiceLoader.load(FormatterService.class, classLoader).findFirst();
     }
 
@@ -209,17 +218,24 @@ private static final class FormatterCacheKey {
         private final Project project;
         private final OptionalInt jdkMajorVersion;
         private final Optional<List<URI>> implementationClassPath;
+        private final Optional<URI> nativeImageClassPath;
+        private final Optional<String> defaultClassPath;
         private final boolean useBundledImplementation;
 
         FormatterCacheKey(
                 Project project,
                 OptionalInt jdkMajorVersion,
                 Optional<List<URI>> implementationClassPath,
+                Optional<URI> nativeImageClassPath,
+                Optional<String> defaultClassPath,
                 boolean useBundledImplementation) {
             this.project = project;
             this.jdkMajorVersion = jdkMajorVersion;
             this.implementationClassPath = implementationClassPath;
+            this.nativeImageClassPath = nativeImageClassPath;
+            this.defaultClassPath = defaultClassPath;
             this.useBundledImplementation = useBundledImplementation;
+
         }
 
         @Override
@@ -234,12 +250,14 @@ public boolean equals(Object o) {
             return Objects.equals(jdkMajorVersion, that.jdkMajorVersion)
                     && useBundledImplementation == that.useBundledImplementation
                     && Objects.equals(project, that.project)
-                    && Objects.equals(implementationClassPath, that.implementationClassPath);
+                    && Objects.equals(implementationClassPath, that.implementationClassPath)
+                    && Objects.equals(nativeImageClassPath, that.nativeImageClassPath)
+                    && Objects.equals(defaultClassPath, that.defaultClassPath);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(project, jdkMajorVersion, implementationClassPath, useBundledImplementation);
+            return Objects.hash(project, jdkMajorVersion, implementationClassPath, nativeImageClassPath, defaultClassPath, useBundledImplementation);
         }
     }
 }