Take the plugin descriptor from PluginAware, not from PluginManager

The IntelliJ plugin found its own descriptor through
PluginManager.findEnabledPlugin(PluginId), which 2026.2 marks
@ApiStatus.Internal, as it does every other way of looking a plugin up
by id or by class; the plugin verifier reports the usage against IU-262.

The formatting service now implements PluginAware, so the platform hands
it the descriptor of the plugin that declares it in plugin.xml, and
FormatterProvider.getPluginDescriptor() reaches that service through the
formattingService extension point. Both are public API in 2024.2 and in
2026.2. The bundled formatter is still found under <plugin dir>/impl and
the settings page still shows the plugin's version.

A service the tests create with `new` is given the descriptor of the one
the platform created, before the extension point is masked.

Author: abashev

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

@@ -18,10 +18,8 @@
 
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.LoadingCache;
-import com.google.common.base.Preconditions;
-import com.intellij.ide.plugins.IdeaPluginDescriptor;
-import com.intellij.ide.plugins.PluginManager;
-import com.intellij.openapi.extensions.PluginId;
+import com.intellij.formatting.service.FormattingService;
+import com.intellij.openapi.extensions.PluginDescriptor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.SystemInfo;
 import com.palantir.javaformat.bootstrap.BootstrappingFormatterService;
@@ -43,17 +41,20 @@
 final class FormatterProvider {
     private static final Logger log = LoggerFactory.getLogger(FormatterProvider.class);
 
-    static final String PLUGIN_ID = "open-java-format";
-
     // Cache to avoid resolving the formatter every time we want to format from IntelliJ
     private final LoadingCache<FormatterCacheKey, Optional<FormatterService>> implementationCache =
             Caffeine.newBuilder().maximumSize(1).build(FormatterProvider::createFormatter);
 
-    static IdeaPluginDescriptor getPluginDescriptor() {
-        return Preconditions.checkNotNull(
-                PluginManager.getInstance().findEnabledPlugin(PluginId.getId(PLUGIN_ID)),
-                "Couldn't find our own plugin: %s",
-                PLUGIN_ID);
+    /**
+     * The descriptor of this plugin: where its version and the directory of the bundled formatter come from. The
+     * platform hands it to the formatting service when it creates that service from plugin.xml (PluginAware), and the
+     * extension point finds the service by class. Every way of looking a plugin up by id or by class became
+     * {@code @ApiStatus.Internal} in 2026.2; PluginAware and the extension point are public API in every supported IDE.
+     */
+    static PluginDescriptor getPluginDescriptor() {
+        return FormattingService.EP_NAME
+                .findExtensionOrFail(PalantirJavaFormatFormattingService.class)
+                .getPluginDescriptor();
     }
 
     Optional<FormatterService> get(Project project, PalantirJavaFormatSettings settings) {
@@ -89,7 +90,7 @@ private static List<Path> getProvidedImplementationUrls(List<URI> implementation
     @SuppressWarnings("for-rollout:Slf4jLogsafeArgs")
     private static List<Path> getBundledImplementationUrls() {
         // Load from the jars bundled with the plugin.
-        IdeaPluginDescriptor ourPlugin = getPluginDescriptor();
+        PluginDescriptor ourPlugin = getPluginDescriptor();
         Path implDir = ourPlugin.getPluginPath().resolve("impl");
         log.debug("Using open-java-format implementation bundled with plugin: {}", implDir);
         return listDirAsUrlsUnchecked(implDir);

open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java

@@ -18,13 +18,16 @@
 
 import static java.util.Comparator.comparing;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Range;
 import com.intellij.formatting.service.AsyncDocumentFormattingService;
 import com.intellij.formatting.service.AsyncFormattingRequest;
 import com.intellij.ide.highlighter.JavaFileType;
 import com.intellij.ide.impl.TrustedProjects;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.extensions.PluginAware;
+import com.intellij.openapi.extensions.PluginDescriptor;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.NlsSafe;
@@ -38,12 +41,28 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import javax.annotation.Nullable;
 import org.jetbrains.annotations.NotNull;
 
-class PalantirJavaFormatFormattingService extends AsyncDocumentFormattingService {
+class PalantirJavaFormatFormattingService extends AsyncDocumentFormattingService implements PluginAware {
     private static final Logger logger = Logger.getInstance(PalantirJavaFormatFormattingService.class);
     private final FormatterProvider formatterProvider = new FormatterProvider();
 
+    // The platform sets this right after creating the service from plugin.xml: the descriptor of the plugin that
+    // declared it, which is how the plugin learns its own path and version (see FormatterProvider.getPluginDescriptor).
+    // A service created with `new`, as the tests do, has to be given the descriptor itself.
+    @Nullable
+    private PluginDescriptor pluginDescriptor;
+
+    @Override
+    public void setPluginDescriptor(@NotNull PluginDescriptor pluginDescriptor) {
+        this.pluginDescriptor = pluginDescriptor;
+    }
+
+    PluginDescriptor getPluginDescriptor() {
+        return Preconditions.checkNotNull(pluginDescriptor, "The platform has not set the plugin descriptor");
+    }
+
     @Override
     protected FormattingTask createFormattingTask(@NotNull AsyncFormattingRequest request) {
         Project project = request.getContext().getProject();

open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurableTest.java

@@ -92,6 +92,14 @@ public void readsAndWritesTheEnabledSetting() throws Throwable {
         assertThat(settings.isEnabled()).isTrue();
     }
 
+    @Test
+    public void showsTheVersionOfThePlugin() {
+        // The "Plugin version" row: the version the platform read from the plugin's own descriptor, not "unknown".
+        assertThat(settings.getImplementationVersion())
+                .hasValueSatisfying(
+                        version -> assertThat(FormatterVersion.parse(version)).isPresent());
+    }
+
     private static Optional<JCheckBox> findCheckBox(Component root) {
         if (root instanceof JCheckBox checkBox) {
             return Optional.of(checkBox);

open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingServiceTest.java

@@ -63,6 +63,9 @@ public void setUp() throws Exception {
         fixture.setUp();
 
         delegatingFormatter = new DelegatingFormatter();
+        // Only the service the platform creates from plugin.xml is handed the plugin descriptor. This one is created
+        // here, so it takes the descriptor from that service before masking it.
+        delegatingFormatter.setPluginDescriptor(FormatterProvider.getPluginDescriptor());
         ExtensionTestUtil.maskExtensions(
                 FormattingService.EP_NAME, ImmutableList.of(delegatingFormatter), fixture.getProjectDisposable());