Remove broken plugins

Author: abashev

CONTRIBUTING.md

@@ -3,21 +3,29 @@
 The team welcomes contributions!  To make changes:
 
 - Fork the repo and make a branch
-- Write your code (ideally with tests) and make sure the CircleCI build passes
+- Write your code (ideally with tests) and make sure the GitHub Actions build passes
+  (`mise run build` locally, `mise run ci:build` to exercise the workflow itself)
 - Open a PR (optionally linking to a github issue)
 
 ## Local development
 
-We recommend using [Intellij IDEA Community Edition](https://www.jetbrains.com/idea/) for Java projects. You'll need Java 8 on your machine.
+We recommend using [Intellij IDEA Community Edition](https://www.jetbrains.com/idea/) for Java projects.
+
+Install the tooling with [mise](https://mise.jdx.dev/) — it pins the bootstrap JDK and `act`:
 
 1. Fork the repository
-1. Generate the IDE configuration: `./gradlew idea`
-1. Import projects into Intellij: `open *.ipr`
+1. `mise trust && mise install`
+1. `mise run build`
+1. Import the project into IntelliJ
+
+See [Building and testing locally](README.md#building-and-testing-locally) for the full set of
+tasks, how to run the CI workflows under `act`, and which JDKs the build needs.
 
 Tips:
 
-- run `./gradlew checkstyleMain checkstyleTest` locally to make sure your code conforms to the code-style.
+- run `mise run format` before pushing; the build fails if the repo is not formatted with the
+  formatter it builds.
 
 ## Working on `:idea-plugin`
 
-Tip: run `./gradlew runIde` to spin up an instance of IntelliJ with the plugin applied.
+Tip: run `mise run idea` to spin up an instance of IntelliJ with the plugin applied.

README.md

@@ -125,7 +125,7 @@ replaced with something a stranger can run.
 | Changelog | Palantir changelog-app (`.changelog.yml`) | Release Drafter, changelog entry in the PR template |
 | Version pinning | `gradle-consistent-versions` (`versions.props` / `versions.lock`) | Version catalog (`gradle/libs.versions.toml`) + Gradle dependency locking |
 | Static analysis | `gradle-baseline`, `baseline-error-prone`, `suppressible-error-prone`, `baseline-null-away`, `.baseline/` | `net.ltgt.errorprone` + NullAway directly; vendor the checkstyle config (checkstyle is disabled in this build today anyway) |
-| JDK provisioning | `gradle-jdks`, `gradle-jdks-latest`, `gradle-jdks-settings`, `gradle/jdks/**`, `palantir.jdk.setup.enabled` | Gradle toolchains + foojay resolver locally; `actions/setup-java` and `graalvm/setup-graalvm` in CI |
+| JDK provisioning | ~~`gradle-jdks`, `gradle-jdks-latest`, `gradle-jdks-settings`, `gradle/jdks/**`, `palantir.jdk.setup.enabled`, a patched `gradlew`~~ | **Done** — Gradle toolchains resolved from JDKs that mise installs locally and `actions/setup-java` / `graalvm/setup-graalvm` install in CI |
 | Version string | `gradle-git-version` + `CIRCLE_TAG` | `git describe` / `GITHUB_REF_NAME` |
 | API compatibility | `gradle-revapi` (`.palantir/revapi.yml`) | japicmp, or revapi's own plugin |
 | IntelliJ plugin publish | `com.palantir.external-publish-intellij` | `org.jetbrains.intellij.platform` + `publishPlugin` with a marketplace token |
@@ -165,18 +165,19 @@ point at.
 | Gradle plugin | ✅ | — | — | — | — | — |
 | IntelliJ plugin | ✅ | — | — | — | — | — |
 | Eclipse plugin | ✅ | — | — | — | — | — |
-| Native image | ⚠️ | ✅ | ✅ | ❌ | ❌ | ❌ |
+| Native image | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ |
 
-✅ built and uploaded by [`ci.yml`](.github/workflows/ci.yml) · ⚠️ built, but as a side effect of
-`assemble` rather than by a job of its own · ❌ missing · — not applicable
+✅ built and uploaded by [`ci.yml`](.github/workflows/ci.yml) · ❌ missing · — not applicable
+
+Every native image now comes from a job of its own, on a GraalVM installed by
+`graalvm/setup-graalvm`, never as a side effect of `./gradlew build` — pass `-PnativeImage=true`
+to wire it back into the lifecycle tasks.
 
 Remaining gaps, each a self-contained PR:
 
-- [ ] macOS x86-64 (`macos-13` runner)
 - [ ] Windows x86-64 — the coordinate already exists in `NativeImageFormatProviderPlugin`, nothing
       produces the binary
 - [ ] linux musl / Alpine
-- [ ] Give linux x86-64 its own `nativeCompile` job instead of relying on `build`
 
 ### Phase 2 — Republish under neutral coordinates
 
@@ -366,11 +367,15 @@ mise run format                 # format this repo with the formatter it builds
 mise tasks                      # everything else
 ```
 
-The Gradle build provisions its own JDKs — Amazon Corretto 21 for the daemon and GraalVM CE 23 for
-`nativeCompile`, pinned in `gradle/jdks/**` — and ignores whatever is on `PATH`, because
-`gradle.properties` sets `org.gradle.java.installations.auto-detect=false`. The first build
-therefore downloads about 500 MB before it compiles anything. All of it comes from public vendor
-URLs (corretto.aws, github.com/graalvm), not from any private mirror.
+Nothing inside the build downloads a JDK. `mise.toml` pins all three the build uses — Temurin 17
+(library target), Temurin 21 (daemon and runtime target) and GraalVM Community 23 (the native
+image) — and Gradle resolves its toolchains from them; `org.gradle.java.installations.auto-download`
+is off, so a missing JDK is an error you can read rather than a silent download. CI installs the
+same three with `actions/setup-java` and `graalvm/setup-graalvm`.
+
+GraalVM specifically has to come from outside Gradle: unpacking a JDK Gradle downloaded itself does
+not preserve the symlink GraalVM ships at `bin/native-image`, and `nativeCompile` then fails on an
+empty, unexecutable file.
 
 ### Running CI locally
 

build.gradle

@@ -15,28 +15,23 @@ buildscript {
         classpath 'com.palantir.gradle.guide:gradle-guide:1.27.0'
         classpath 'com.palantir.gradle.idea-configuration:gradle-idea-configuration:0.11.0'
         classpath 'com.palantir.gradle.idea-language-injector:gradle-idea-language-injector:0.5.0'
-        classpath 'com.palantir.gradle.plugintesting:gradle-plugin-testing:0.54.0'
-        // Not applied: versions come from gradle/libs.versions.toml now. It is on the
-        // classpath only because com.palantir.gradle-plugin-testing links against
-        // VersionsLockExtension and fails to instantiate without it. Applying it is what
-        // breaks Gradle 9 (unsafe cross-project configuration resolution); merely having the
-        // jar present does not. Goes away with gradle-plugin-testing itself.
-        classpath 'com.palantir.gradle.consistentversions:gradle-consistent-versions:3.19.0'
         classpath 'com.palantir.javaformat:gradle-palantir-java-format:2.97.0'
         classpath 'com.palantir.suppressible-error-prone:gradle-suppressible-error-prone:2.28.0'
         classpath 'me.champeau.jmh:jmh-gradle-plugin:0.7.3'
-        classpath 'com.palantir.gradle.revapi:gradle-revapi:2.3.0'
     }
 }
 
 apply plugin: 'com.palantir.failure-reports'
 apply plugin: 'com.palantir.git-version'
 apply plugin: 'com.palantir.gradle-guide'
 apply plugin: 'com.palantir.idea-language-injector'
-apply plugin: 'com.palantir.baseline'
+// Not the `com.palantir.baseline` aggregate: it also applies baseline-format (Spotless) and
+// baseline-class-uniqueness, and both are incompatible with the configuration cache at their
+// latest versions — Spotless fails serialising its Groovy extension, checkClassUniqueness casts
+// a ResolvingFileCollection to Configuration. The rest of what baseline gives us is applied
+// per project below, so error-prone and the JUnit wiring survive.
 apply plugin: 'com.palantir.baseline-error-prone-root'
 apply plugin: 'com.palantir.baseline-java-versions'
-apply plugin: 'com.palantir.baseline-java-versions'
 
 // GitHub Actions sets GITHUB_REF_TYPE=tag on a tag build; otherwise derive the
 // version from git history (needs a full clone: actions/checkout fetch-depth: 0).
@@ -48,13 +43,51 @@ version System.env.GITHUB_REF_TYPE == 'tag' ? System.env.GITHUB_REF_NAME : gitVe
 // what .github/workflows/ci.yml's `native` jobs do.
 ext.nativeImageRequested = Boolean.parseBoolean(providers.gradleProperty('nativeImage').getOrElse('false'))
 
+// The javac internals the formatter parses with. Was baseline's `moduleJvmArgs`, which is
+// dropped because it resolves its extension at execution time and the configuration cache
+// forbids that — so the exports are handed to javac and to the test JVMs here instead.
+def javacInternalExports = [
+        'jdk.compiler/com.sun.tools.javac.api',
+        'jdk.compiler/com.sun.tools.javac.code',
+        'jdk.compiler/com.sun.tools.javac.file',
+        'jdk.compiler/com.sun.tools.javac.main',
+        'jdk.compiler/com.sun.tools.javac.parser',
+        'jdk.compiler/com.sun.tools.javac.tree',
+        'jdk.compiler/com.sun.tools.javac.util',
+]
+
 allprojects {
     apply plugin: 'com.palantir.baseline-null-away'
+    apply plugin: 'com.palantir.baseline-encoding'
+    apply plugin: 'com.palantir.baseline-immutables'
+    apply plugin: 'com.palantir.baseline-java-compiler-diagnostics'
+    apply plugin: 'com.palantir.baseline-java-compiler-heap'
+    apply plugin: 'com.palantir.baseline-java-properties'
+    apply plugin: 'com.palantir.baseline-prefer-project-modules'
+    apply plugin: 'com.palantir.baseline-reproducibility'
+    apply plugin: 'com.palantir.baseline-test-heap'
+    apply plugin: com.palantir.baseline.plugins.BaselineTesting
     apply plugin: 'com.palantir.java-format'
     apply plugin: 'com.palantir.jakarta-package-alignment'
     group = 'com.palantir.javaformat'
     version = rootProject.version
 
+    tasks.withType(JavaCompile).configureEach {
+        options.compilerArgs.addAll(javacInternalExports.collect { "--add-exports=${it}=ALL-UNNAMED".toString() })
+    }
+
+    tasks.withType(Test).configureEach {
+        jvmArgs(javacInternalExports.collect { "--add-exports=${it}=ALL-UNNAMED".toString() })
+    }
+
+    tasks.withType(Javadoc).configureEach {
+        options.addMultilineStringsOption('-add-exports')
+                .setValue(javacInternalExports.collect { "${it}=ALL-UNNAMED".toString() })
+        // baseline used to silence doclint; these sources carry inherited javadoc from
+        // google-java-format that has never satisfied it (unknown tags, malformed HTML).
+        options.addStringOption('Xdoclint:none', '-quiet')
+    }
+
     repositories {
         mavenCentral() { metadataSources { mavenPom(); ignoreGradleMetadataRedirection() } }
         gradlePluginPortal()

eclipse_plugin/build.gradle

@@ -14,7 +14,7 @@
 
 plugins {
     id 'java-library'
-    id 'dev.equo.p2deps' version '1.7.3'
+    id 'dev.equo.p2deps' version '1.7.8'
 }
 
 p2deps {

gradle-palantir-java-format/build.gradle

@@ -1,7 +1,5 @@
 apply plugin: 'java-gradle-plugin'
-apply plugin: 'com.palantir.revapi'
 apply plugin: 'groovy'
-apply plugin: 'com.palantir.gradle-plugin-testing'
 
 configurations {
     pluginClasspath {
@@ -24,14 +22,19 @@ dependencies {
     testImplementation libs.junit.jupiter
     testImplementation libs.assertj
     testImplementation libs.jackson.dataformat.xml
+    // @Language on the XML fixtures; used to arrive transitively via gradle-plugin-testing.
+    testImplementation libs.jetbrainsAnnotations
 
     testRuntimeOnly libs.junit.vintage.engine
 
-    pluginClasspath libs.spotless.gradlePlugin
+    // Plain Gradle TestKit drives the generated projects; see
+    // src/test/java/com/palantir/javaformat/gradle/testing/GradleTestProject.java.
+    testImplementation gradleTestKit()
 
-    gradlePluginForTesting libs.consistentVersions.gradlePlugin
-    gradlePluginForTesting libs.spotless.gradlePlugin
-    gradlePluginForTesting libs.baseline.gradlePlugin
+    // Third-party plugins the generated test projects apply. java-gradle-plugin injects this
+    // alongside the plugin under test, so `plugins { id '...' }` resolves them without a version.
+    pluginClasspath libs.spotless.gradlePlugin
+    pluginClasspath libs.baseline.gradlePlugin
 }
 
 gradlePlugin {
@@ -70,7 +73,10 @@ gradlePlugin {
 }
 
 tasks.withType(PluginUnderTestMetadata).configureEach {
-    pluginClasspath.from += configurations.pluginClasspath
+    // `from(...)`, not `from += ...`: the latter reads the collection and reassigns it, dropping the
+    // task dependency on `jar` that java-gradle-plugin put there. It only shows up on a clean build,
+    // where the jar has not been produced yet.
+    pluginClasspath.from(configurations.pluginClasspath)
 }
 
 configurations {
@@ -106,16 +112,28 @@ tasks.register("copyNativeImage", Copy.class) {
 
 // Split in two so the jar build does not need a GraalVM image: every test reads
 // impl.classpath, only the four that drive the binary read nativeImage.path.
+//
+// Everything the doLast bodies touch is captured here, at configuration time: reaching for
+// `configurations` or `tasks` from inside them would pull the whole script into the task and
+// the configuration cache rejects that.
+def implFiles = configurations.impl
+def implClasspathFile = layout.buildDirectory.file("impl.classpath")
+def nativeImageDir = layout.buildDirectory.dir("nativeImage")
+def nativeImagePathFile = layout.buildDirectory.file("nativeImage.path")
+
 def writeImplClasspath = tasks.register("writeImplClasspath") {
+    inputs.files(implFiles)
+    outputs.file(implClasspathFile)
     doLast {
-        file("$buildDir/impl.classpath").text = configurations.impl.asPath
+        implClasspathFile.get().asFile.text = implFiles.asPath
     }
 }
 
 def writeNativeImagePath = tasks.register("writeNativeImagePath") {
     inputs.files(tasks.named("copyNativeImage"))
+    outputs.file(nativeImagePathFile)
     doLast {
-        file("$buildDir/nativeImage.path").text = tasks.named("copyNativeImage").get().getOutputs().getFiles().getSingleFile().listFiles()[0].getAbsolutePath()
+        nativeImagePathFile.get().asFile.text = nativeImageDir.get().asFile.listFiles()[0].absolutePath
     }
 }
 
@@ -135,7 +153,3 @@ tasks.named("test").configure {
         exclude '**/FormatDiffTest.class'
     }
 }
-
-gradleTestUtils {
-    configurationCacheEnabled = true
-}

gradle-palantir-java-format/src/test/java/com/palantir/javaformat/gradle/PalantirJavaFormatIdeaPluginTest.java

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package com.palantir.javaformat.gradle;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -23,20 +22,16 @@
 import com.fasterxml.jackson.dataformat.xml.XmlMapper;
 import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
 import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
-import com.palantir.gradle.testing.execution.GradleInvoker;
-import com.palantir.gradle.testing.files.arbitrary.ArbitraryFile;
-import com.palantir.gradle.testing.junit.DisabledConfigurationCache;
-import com.palantir.gradle.testing.junit.GradlePluginTests;
-import com.palantir.gradle.testing.project.RootProject;
+import com.palantir.javaformat.gradle.testing.GradleTestProject;
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
+import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-@GradlePluginTests
-@DisabledConfigurationCache
 class PalantirJavaFormatIdeaPluginTest {
 
     private static final String NATIVE_IMAGE_FILE = new File("build/nativeImage.path").getAbsolutePath();
@@ -46,28 +41,30 @@ class PalantirJavaFormatIdeaPluginTest {
 
     private static final ObjectMapper XML_MAPPER = new XmlMapper();
 
+    @TempDir
+    private Path projectDir;
+
     @ParameterizedTest(name = "extraGradleProperties={0}")
     @ValueSource(strings = {"", "palantir.native.formatter=true"})
-    void idea_configures_xml_files(String extraGradleProperties, GradleInvoker gradle, RootProject rootProject)
-            throws IOException {
-
-        rootProject.gradlePropertiesFile().appendLine(extraGradleProperties);
-
-        rootProject.buildGradle().plugins().add("com.palantir.java-format-idea").add("idea");
-
-        rootProject.buildGradle().append("""
-            dependencies {
-                palantirJavaFormat project.files() // no need to store the real thing in here
-                %s
-            }
-            """, extraGradleProperties.isBlank() ? "" : NATIVE_CONFIG);
-
-        gradle.withArgs("idea").buildsSuccessfully();
-
-        ArbitraryFile pjfXmlFile = rootProject.file(".idea/palantir-java-format.xml");
-        pjfXmlFile.assertThat().exists();
-
-        Project xmlContent = XML_MAPPER.readValue(pjfXmlFile.path().toFile(), Project.class);
+    void idea_configures_xml_files(String extraGradleProperties) throws IOException {
+        GradleTestProject project = new GradleTestProject(projectDir)
+                .plugins("com.palantir.java-format-idea", "idea")
+                .gradleProperties(extraGradleProperties)
+                .buildGradle(
+                        """
+                        dependencies {
+                            palantirJavaFormat project.files() // no need to store the real thing in here
+                            %s
+                        }
+                        """,
+                        extraGradleProperties.isBlank() ? "" : NATIVE_CONFIG);
+
+        project.succeeds("idea");
+
+        assertThat(project.file(".idea/palantir-java-format.xml")).exists();
+
+        Project xmlContent =
+                XML_MAPPER.readValue(project.file(".idea/palantir-java-format.xml").toFile(), Project.class);
 
         assertThat(xmlContent.components()).anyMatch(c -> "PalantirJavaFormatSettings".equals(c.name()));
 
@@ -81,10 +78,9 @@ void idea_configures_xml_files(String extraGradleProperties, GradleInvoker gradl
             assertThat(allOptions).anyMatch(o -> "nativeImageClassPath".equals(o.name()));
         }
 
-        ArbitraryFile workspaceXmlFile = rootProject.file(".idea/workspace.xml");
-        workspaceXmlFile.assertThat().exists();
+        assertThat(project.file(".idea/workspace.xml")).exists();
 
-        Project workspaceContent = XML_MAPPER.readValue(workspaceXmlFile.path().toFile(), Project.class);
+        Project workspaceContent = XML_MAPPER.readValue(project.file(".idea/workspace.xml").toFile(), Project.class);
 
         assertThat(workspaceContent.components()).anyMatch(c -> "FormatOnSaveOptions".equals(c.name()));
         assertThat(workspaceContent.components()).anyMatch(c -> "OptimizeOnSaveOptions".equals(c.name()));
@@ -93,16 +89,14 @@ void idea_configures_xml_files(String extraGradleProperties, GradleInvoker gradl
     @JsonIgnoreProperties(ignoreUnknown = true)
     private record Project(
             @JacksonXmlProperty(localName = "component") @JacksonXmlElementWrapper(useWrapping = false)
-            List<Component> components) {}
+                    List<Component> components) {}
 
     @JsonIgnoreProperties(ignoreUnknown = true)
     private record Component(
             @JacksonXmlProperty(isAttribute = true) String name,
-
             @JacksonXmlProperty(localName = "option") @JacksonXmlElementWrapper(useWrapping = false)
-            List<Option> options) {}
+                    List<Option> options) {}
 
     @JsonIgnoreProperties(ignoreUnknown = true)
-    private record Option(
-            @JacksonXmlProperty(isAttribute = true) String name) {}
+    private record Option(@JacksonXmlProperty(isAttribute = true) String name) {}
 }