From 9d5ece4be15ceb6d802f777f93f02a294cd2ab4e Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Fri, 20 Nov 2026 23:36:14 +0300 Subject: [PATCH 1/5] Optimize imports with open-java-format in IntelliJ IDEA The formatting service now has OPTIMIZE_IMPORTS, so every way the IDE optimizes imports asks its optimizer instead of the IDE's own JavaImportOptimizer: Optimize Imports, Reformat with "Optimize imports", Actions on Save, the check before a commit, the quick fix for an unused import and "Optimize imports on the fly". The optimizer calls FormatterService.fixImports, which since #221 fixes the imports alone: the unused ones removed, the others sorted, as the command line does. Reformat with "Optimize imports" starts the formatter in the background and the optimizer right after it, on the same document. The platform applies the formatter's text only if the document has not changed since the request started, and IntelliJ IDEA registers no DocumentMerger, so whichever wrote second lost: the formatting or the imports. While a format of the plugin is running on a document, the optimizer now hands the imports over to it, and the format fixes them after the layout, as the command line does. Once the format has its text, the optimizer leaves the document alone until the text is in. The optimizer holds a read action while the formatter runs, which "Optimize imports on the fly" makes typing wait for (#253). --- .../javaformat/intellij/Notifications.java | 4 + .../PalantirJavaFormatFormattingService.java | 158 +++++++++- .../PalantirJavaFormatImportOptimizer.java | 121 ++++++++ .../src/main/resources/META-INF/plugin.xml | 2 +- ...PalantirJavaFormatImportOptimizerTest.java | 287 ++++++++++++++++++ 5 files changed, 556 insertions(+), 16 deletions(-) create mode 100644 open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java create mode 100644 open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java index 3f9e12a1f..53e50e4ad 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java @@ -27,6 +27,10 @@ static String parsingErrorMessage(String filename) { return "open-java-format failed. Does " + filename + " have syntax errors?"; } + static String untrustedProjectMessage() { + return "open-java-format requires a trusted project to load the external formatter classpath."; + } + static String formatterFailedMessage(String filename) { return "open-java-format could not run the formatter on " + filename + ". The details are in idea.log."; } diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java index ccb1c5a8d..3022bf672 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java @@ -24,13 +24,20 @@ import com.intellij.formatting.service.AsyncFormattingRequest; import com.intellij.ide.highlighter.JavaFileType; import com.intellij.ide.impl.TrustedProjects; +import com.intellij.lang.ImportOptimizer; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.editor.Document; +import com.intellij.openapi.editor.event.DocumentEvent; +import com.intellij.openapi.editor.event.DocumentListener; 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.Disposer; +import com.intellij.openapi.util.Key; import com.intellij.openapi.util.NlsSafe; import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiFile; import com.palantir.javaformat.java.FormatterException; import com.palantir.javaformat.java.FormatterService; @@ -40,12 +47,14 @@ import java.util.List; import java.util.Optional; import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; import org.jspecify.annotations.Nullable; class PalantirJavaFormatFormattingService extends AsyncDocumentFormattingService implements PluginAware { private static final Logger logger = Logger.getInstance(PalantirJavaFormatFormattingService.class); private final FormatterProvider formatterProvider = new FormatterProvider(() -> EmbeddedNativeImage.getInstance().installedPath()); + private final ImportOptimizer importOptimizer = new PalantirJavaFormatImportOptimizer(this); // 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). @@ -66,19 +75,27 @@ Optional getPluginDescriptor() { @Nullable protected FormattingTask createFormattingTask(AsyncFormattingRequest request) { Project project = request.getContext().getProject(); - // The marketplace verifier reports this class as experimental, and newer IDEs also deprecate it. It stays: - // its replacement, com.intellij.ide.trustedProjects.TrustedProjects, is @ApiStatus.Internal — a worse thing - // for a plugin to call. - if (!TrustedProjects.isTrusted(project)) { + if (!isTrusted(project)) { logger.warn("open-java-format: skipping formatting for untrusted project: " + project.getName()); - request.onError( - Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, - "open-java-format requires a trusted project to load the external formatter classpath."); + request.onError(Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, Notifications.untrustedProjectMessage()); return null; } - PalantirJavaFormatSettings settings = PalantirJavaFormatSettings.getInstance(project); - Optional formatter = formatterProvider.get(project, settings); - return new PalantirJavaFormatFormattingTask(request, formatter); + PendingFormat pendingFormat = PendingFormat.start( + project, + PsiDocumentManager.getInstance(project) + .getDocument(request.getContext().getContainingFile())); + return new PalantirJavaFormatFormattingTask(request, getFormatter(project), pendingFormat); + } + + static boolean isTrusted(Project project) { + // The marketplace verifier reports this class as experimental, and newer IDEs also deprecate it. It stays: + // its replacement, com.intellij.ide.trustedProjects.TrustedProjects, is @ApiStatus.Internal — a worse thing + // for a plugin to call. + return TrustedProjects.isTrusted(project); + } + + Optional getFormatter(Project project) { + return formatterProvider.get(project, PalantirJavaFormatSettings.getInstance(project)); } @Override @@ -91,9 +108,17 @@ protected String getNotificationGroupId() { return "open-java-format"; } + // OPTIMIZE_IMPORTS: every way the IDE optimizes imports asks the first formatting service that has this feature and + // can format the file for its optimizers (FormattingServiceUtil.findImportsOptimizingService), and so takes ours + // instead of its own JavaImportOptimizer. @Override public Set getFeatures() { - return Set.of(Feature.FORMAT_FRAGMENTS); + return Set.of(Feature.FORMAT_FRAGMENTS, Feature.OPTIMIZE_IMPORTS); + } + + @Override + public Set getImportOptimizers(PsiFile file) { + return Set.of(importOptimizer); } @Override @@ -102,22 +127,120 @@ public boolean canFormat(PsiFile file) { && PalantirJavaFormatSettings.getInstance(file.getProject()).isEnabled(); } + /** + * A formatting request of this service whose text is not in its document yet, kept on the document. + * + *

The formatter runs in the background, and the platform applies its text later, only if the document has not + * changed since the request started: IntelliJ IDEA registers no {@code DocumentMerger} to do anything else. + * Reformat with "Optimize imports" starts the formatter and the import optimizer on the same document without + * waiting for the first, so whichever wrote second would lose: the formatted text, or the imports. While a request + * is formatting, the optimizer hands its work over to it, and the request fixes the imports of the text it + * formatted, as the command line does. Once the request has its text, the optimizer leaves the document alone + * until the text is applied. + */ + static final class PendingFormat { + private static final Key KEY = Key.create("open-java-format.pendingFormat"); + + private enum State { + FORMATTING, + FORMATTING_AND_FIXING_IMPORTS, + // Until the document next changes: with the text, or with an edit that makes the platform drop it. + UNAPPLIED, + DONE + } + + private final AtomicReference state = new AtomicReference<>(State.FORMATTING); + private final Project project; + + @Nullable + private final Document document; + + private PendingFormat(Project project, @Nullable Document document) { + this.project = project; + this.document = document; + } + + static PendingFormat start(Project project, @Nullable Document document) { + var pendingFormat = new PendingFormat(project, document); + if (document != null) { + document.putUserData(KEY, pendingFormat); + } + return pendingFormat; + } + + @Nullable + static PendingFormat of(Document document) { + return document.getUserData(KEY); + } + + /** Asks the request to fix the imports too: false if it has finished formatting already. */ + boolean handOverImports() { + return state.compareAndSet(State.FORMATTING, State.FORMATTING_AND_FIXING_IMPORTS); + } + + boolean isUnapplied() { + return state.get() == State.UNAPPLIED; + } + + /** Ends the formatting, and says whether the imports were handed over meanwhile. */ + private boolean finishFormatting() { + return state.getAndSet(State.UNAPPLIED) == State.FORMATTING_AND_FIXING_IMPORTS; + } + + private void finish(boolean changesDocument) { + if (!changesDocument || document == null) { + state.set(State.DONE); + return; + } + var untilChanged = Disposer.newDisposable("open-java-format: until the formatted text is applied"); + if (!Disposer.tryRegister(project, untilChanged)) { + state.set(State.DONE); + return; + } + // Registered before the platform applies the text, which it does only once the task has returned. + document.addDocumentListener( + new DocumentListener() { + @Override + public void documentChanged(DocumentEvent event) { + state.set(State.DONE); + Disposer.dispose(untilChanged); + } + }, + untilChanged); + } + } + private static final class PalantirJavaFormatFormattingTask implements FormattingTask { private final AsyncFormattingRequest request; private final Optional formatterService; + private final PendingFormat pendingFormat; - PalantirJavaFormatFormattingTask(AsyncFormattingRequest request, Optional formatterService) { + PalantirJavaFormatFormattingTask( + AsyncFormattingRequest request, + Optional formatterService, + PendingFormat pendingFormat) { this.request = request; this.formatterService = formatterService; + this.pendingFormat = pendingFormat; } @Override public void run() { + var changesDocument = false; + try { + changesDocument = format(); + } finally { + pendingFormat.finish(changesDocument); + } + } + + /** Formats, and says whether the text it gave back changes the document. */ + private boolean format() { if (formatterService.isEmpty()) { request.onError( Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, "Failed to format file because formatterService is not configured"); - return; + return false; } String preFormatText = request.getDocumentText(); @@ -138,14 +261,18 @@ public void run() { // returns a change. Thus we must perform a content aware diff / branching. String formattedText = applyReplacements( preFormatText, formatterService.get().getFormatReplacements(preFormatText, toRanges(request))); + if (pendingFormat.finishFormatting()) { + formattedText = formatterService.get().fixImports(formattedText); + } // The Javadoc of this API says that you should set it to null when the document is unchanged // We should not be trying to format a document that is already formatted if (preFormatText.equals(formattedText)) { request.onTextReady(null); - } else { - request.onTextReady(formattedText); + return false; } + request.onTextReady(formattedText); + return true; } catch (FormatterException e) { // A syntax error in the file, not a fault of the plugin: an error would go to its error reports. logger.warn( @@ -169,6 +296,7 @@ public void run() { Notifications.formatterFailedMessage( request.getContext().getContainingFile().getName())); } + return false; } static String applyReplacements(String input, Collection replacementsCollection) { diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java new file mode 100644 index 000000000..22bb2963c --- /dev/null +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java @@ -0,0 +1,121 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.javaformat.intellij; + +import com.intellij.formatting.service.FormattingNotificationService; +import com.intellij.lang.ImportOptimizer; +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.editor.Document; +import com.intellij.openapi.progress.ProcessCanceledException; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.EmptyRunnable; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.PsiDocumentManager; +import com.intellij.psi.PsiFile; +import com.palantir.javaformat.intellij.PalantirJavaFormatFormattingService.PendingFormat; +import com.palantir.javaformat.java.FormatterException; + +/** + * Optimizes imports as the command line fixes them, with {@code FormatterService.fixImports}: the unused ones removed, + * the others sorted. The IDE takes it instead of its own {@code JavaImportOptimizer} for every way of optimizing + * imports, since {@link PalantirJavaFormatFormattingService} has {@code OPTIMIZE_IMPORTS}. + */ +final class PalantirJavaFormatImportOptimizer implements ImportOptimizer { + private static final Logger logger = Logger.getInstance(PalantirJavaFormatImportOptimizer.class); + + private final PalantirJavaFormatFormattingService formattingService; + + PalantirJavaFormatImportOptimizer(PalantirJavaFormatFormattingService formattingService) { + this.formattingService = formattingService; + } + + @Override + public boolean supports(PsiFile file) { + return formattingService.canFormat(file); + } + + // Called under a read action, in the background on most paths; the Runnable runs on the EDT under a write action. + // So the formatter runs here, and the Runnable only writes its text. EmptyRunnable tells the IDE that nothing + // changed. The formatter does not check for cancellation, so a write action waits for it: with "Optimize imports + // on the fly", typing waits (#253). + @Override + public Runnable processFile(PsiFile file) { + Project project = file.getProject(); + Document document = PsiDocumentManager.getInstance(project).getDocument(file); + if (document == null || leftToPendingFormat(document)) { + return EmptyRunnable.getInstance(); + } + if (!PalantirJavaFormatFormattingService.isTrusted(project)) { + logger.warn("open-java-format: skipping optimizing imports for untrusted project: " + project.getName()); + reportError( + project, Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, Notifications.untrustedProjectMessage()); + return EmptyRunnable.getInstance(); + } + var formatter = formattingService.getFormatter(project); + if (formatter.isEmpty()) { + reportError( + project, + Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, + "Failed to optimize imports because formatterService is not configured"); + return EmptyRunnable.getInstance(); + } + + String text = document.getText(); + String fixedText; + try { + fixedText = formatter.get().fixImports(text); + } catch (FormatterException e) { + // A syntax error in the file, not a fault of the plugin: an error would go to its error reports. + logger.warn(String.format("Failed to optimize imports of file %s", file.getName()), e); + reportError(project, Notifications.PARSING_ERROR_TITLE, Notifications.parsingErrorMessage(file.getName())); + return EmptyRunnable.getInstance(); + } catch (ProcessCanceledException e) { + throw e; + } catch (RuntimeException e) { + // As in the formatting task: an error, so that it goes to the plugin's error reports. + logger.error("open-java-format could not run the formatter", e); + reportError( + project, + Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, + Notifications.formatterFailedMessage(file.getName())); + return EmptyRunnable.getInstance(); + } + if (fixedText.equals(text)) { + return EmptyRunnable.getInstance(); + } + + return () -> { + // The document can have changed since: typed into, or given the text of a formatting request. Or a request + // can have started formatting it meanwhile, which takes the imports over. + if (StringUtil.equals(document.getImmutableCharSequence(), text) && !leftToPendingFormat(document)) { + document.setText(fixedText); + } + }; + } + + /** + * Whether a formatting request is pending on the document: one that is still formatting fixes the imports itself, + * and one whose text is not applied yet would lose it if the document changed now. + */ + private static boolean leftToPendingFormat(Document document) { + PendingFormat pendingFormat = PendingFormat.of(document); + return pendingFormat != null && (pendingFormat.handOverImports() || pendingFormat.isUnapplied()); + } + + private static void reportError(Project project, String title, String message) { + FormattingNotificationService.getInstance(project) + .reportError(Notifications.PARSING_ERROR_NOTIFICATION_GROUP, title, message); + } +} diff --git a/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml b/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml index a4a5bf339..6be4efe93 100644 --- a/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml +++ b/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml @@ -9,7 +9,7 @@ Gradle build no longer sets one. Only tags the marketplace renders: p, a, b, code, ul, ol, li. --> Formats Java code with open-java-format, a maintained fork of palantir-java-format: 120 columns, 4-space indents and lambda-friendly line breaking.

-

With the plugin enabled, Reformat Code runs open-java-format instead of the IDE's built-in Java formatter, so the IDE and your build produce identical files. The IDE's own Java code style settings no longer apply.

+

With the plugin enabled, Reformat Code runs open-java-format instead of the IDE's built-in Java formatter, and Optimize Imports removes unused imports and sorts the others as open-java-format does, so the IDE and your build produce identical files. The IDE's own Java code style settings no longer apply.

The formatter runs in a process of its own, on the IDE's runtime, so the project SDK can be any version. A project that applies the dev.openjavaformat.java-format Gradle plugin takes the formatter version from the build; every other project uses the version bundled with this plugin.

For many files at once, tick Use native binary on the plugin's settings page: the plugin downloads the formatter compiled to a native binary for your platform, which starts without a JVM, in a Maven, Gradle or any other project. A binary of your own works too.

Requires IntelliJ IDEA 2024.2 or later, or another IDE with Java support such as Android Studio.

diff --git a/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java b/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java new file mode 100644 index 000000000..75002b065 --- /dev/null +++ b/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java @@ -0,0 +1,287 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.javaformat.intellij; + +import static java.util.Objects.requireNonNull; +import static org.assertj.core.api.Assertions.assertThat; + +import com.intellij.application.options.CodeStyle; +import com.intellij.codeInsight.actions.OptimizeImportsProcessor; +import com.intellij.codeInsight.actions.ReformatCodeProcessor; +import com.intellij.formatting.FormattingContext; +import com.intellij.formatting.service.AsyncFormattingRequest; +import com.intellij.formatting.service.CoreFormattingService; +import com.intellij.formatting.service.FormattingService; +import com.intellij.lang.ImportOptimizer; +import com.intellij.openapi.command.WriteCommandAction; +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiDocumentManager; +import com.intellij.psi.PsiFile; +import com.intellij.testFramework.ExtensionTestUtil; +import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor; +import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory; +import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture; +import com.intellij.testFramework.fixtures.JavaTestFixtureFactory; +import com.intellij.testFramework.fixtures.TestFixtureBuilder; +import com.palantir.javaformat.intellij.PalantirJavaFormatSettings.StoredSettings; +import java.io.File; +import java.util.List; +import java.util.Set; +import org.jspecify.annotations.Nullable; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +final class PalantirJavaFormatImportOptimizerTest { + private static final String UNOPTIMIZED = """ + package com.foo; + + import java.util.Map; + import static java.util.Objects.requireNonNull; + import java.util.List; + import java.util.ArrayList; + + class ImportTest { + Map map; + List list = requireNonNull(null); + } + """; + + private JavaCodeInsightTestFixture fixture; + private PalantirJavaFormatSettings settings; + private DelegatingFormatter delegatingFormatter; + + @BeforeEach + void setUp() throws Exception { + TestFixtureBuilder projectBuilder = IdeaTestFixtureFactory.getFixtureFactory() + .createLightFixtureBuilder( + new DefaultLightProjectDescriptor(), getClass().getName()); + fixture = JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(projectBuilder.getFixture()); + fixture.setUp(); + + // The IDE's own service stays, after ours, for the IDE's own optimizer when the plugin is disabled. + delegatingFormatter = new DelegatingFormatter(); + ExtensionTestUtil.maskExtensions( + FormattingService.EP_NAME, + List.of(delegatingFormatter, new CoreFormattingService()), + fixture.getProjectDisposable()); + + settings = PalantirJavaFormatSettings.getInstance(fixture.getProject()); + var resetState = new StoredSettings(); + resetState.setEnabled("true"); + settings.loadState(resetState); + } + + @AfterEach + void tearDown() throws Exception { + fixture.tearDown(); + } + + @Test + void optimize_imports_removes_the_unused_ones_and_sorts_the_others_as_the_command_line_does() { + PsiFile file = createPsiFile(UNOPTIMIZED); + + run(new OptimizeImportsProcessor(file.getProject(), file)); + + assertThat(file.getText()).isEqualTo(""" + package com.foo; + + import static java.util.Objects.requireNonNull; + + import java.util.List; + import java.util.Map; + + class ImportTest { + Map map; + List list = requireNonNull(null); + } + """); + assertThat(delegatingFormatter.optimizerInvoked).isTrue(); + } + + @Test + void reformat_with_optimize_imports_gives_what_the_command_line_gives() throws Exception { + PsiFile file = createPsiFile(UNOPTIMIZED); + + run(new OptimizeImportsProcessor(new ReformatCodeProcessor(file, false))); + + assertThat(file.getText()).isEqualTo(commandLineOutput(UNOPTIMIZED)); + } + + @Test + void optimize_imports_hands_the_imports_over_to_a_format_still_running_on_the_document() throws Exception { + PsiFile file = createPsiFile(UNOPTIMIZED); + var request = new RecordingRequest(file); + Runnable task = startFormatting(request); + + // The platform starts the optimizer while the formatter runs in the background: if it wrote the imports now, + // the platform would drop the formatted text, the document having changed since the request started. + run(new OptimizeImportsProcessor(file.getProject(), file)); + assertThat(file.getText()).isEqualTo(UNOPTIMIZED); + + task.run(); + assertThat(request.text).isEqualTo(commandLineOutput(UNOPTIMIZED)); + } + + @Test + void optimize_imports_writes_nothing_while_a_format_has_text_not_yet_applied() throws Exception { + PsiFile file = createPsiFile(UNOPTIMIZED); + var request = new RecordingRequest(file); + Runnable task = startFormatting(request); + task.run(); + + run(new OptimizeImportsProcessor(file.getProject(), file)); + assertThat(file.getText()).isEqualTo(UNOPTIMIZED); + + // Once the platform applies the formatted text, optimizing imports works on that. + WriteCommandAction.runWriteCommandAction(fixture.getProject(), () -> { + var documentManager = PsiDocumentManager.getInstance(fixture.getProject()); + requireNonNull(documentManager.getDocument(file)).setText(requireNonNull(request.text)); + documentManager.commitAllDocuments(); + }); + run(new OptimizeImportsProcessor(file.getProject(), file)); + assertThat(file.getText()).isEqualTo(commandLineOutput(UNOPTIMIZED)); + } + + @Test + void optimize_imports_is_the_ides_own_when_the_plugin_is_disabled() { + settings.setEnabled(false); + PsiFile file = createPsiFile(UNOPTIMIZED); + + run(new OptimizeImportsProcessor(file.getProject(), file)); + + assertThat(delegatingFormatter.optimizerInvoked).isFalse(); + } + + private String commandLineOutput(String input) throws Exception { + return delegatingFormatter + .getFormatter(fixture.getProject()) + .orElseThrow() + .formatSourceReflowStringsAndFixImports(input); + } + + /** Starts a formatting request on the document as the platform does, without running it yet. */ + private Runnable startFormatting(AsyncFormattingRequest request) { + return WriteCommandAction.writeCommandAction(fixture.getProject()) + .compute(() -> (Runnable) delegatingFormatter.createFormattingTask(request)); + } + + private void run(OptimizeImportsProcessor processor) { + WriteCommandAction.runWriteCommandAction(fixture.getProject(), () -> { + processor.run(); + PsiDocumentManager.getInstance(fixture.getProject()).commitAllDocuments(); + }); + } + + private PsiFile createPsiFile(String contents) { + PsiFile psiFile = fixture.configureByText("ImportTest.java", contents); + assertThat(psiFile).isNotNull(); + return psiFile; + } + + /** A request as the platform makes it for a Reformat of the whole file, which records the text it is given. */ + private static final class RecordingRequest implements AsyncFormattingRequest { + private final PsiFile file; + private final String documentText; + + @Nullable + private String text; + + RecordingRequest(PsiFile file) { + this.file = file; + this.documentText = file.getText(); + } + + @Override + public String getDocumentText() { + return documentText; + } + + @Override + @Nullable + public File getIOFile() { + return null; + } + + @Override + public List getFormattingRanges() { + return List.of(file.getTextRange()); + } + + @Override + public boolean canChangeWhitespaceOnly() { + return false; + } + + @Override + public boolean isQuickFormat() { + return false; + } + + @Override + public FormattingContext getContext() { + return FormattingContext.create(file, CodeStyle.getSettings(file)); + } + + @Override + public void onTextReady(@Nullable String updatedText) { + text = updatedText; + } + + @Override + public void onError(String title, String message) { + throw new AssertionError(title + ": " + message); + } + + @Override + public void onError(String title, String message, int offset) { + onError(title, message); + } + } + + private static final class DelegatingFormatter extends PalantirJavaFormatFormattingService { + private boolean optimizerInvoked = false; + + DelegatingFormatter() { + this.setPluginDescriptor( + requireNonNull(FormattingService.EP_NAME.findExtension(PalantirJavaFormatFormattingService.class)) + .getPluginDescriptor() + .orElseThrow()); + } + + @Override + public Set getImportOptimizers(PsiFile file) { + var delegate = super.getImportOptimizers(file).iterator().next(); + return Set.of(new ImportOptimizer() { + @Override + public boolean supports(PsiFile file) { + return delegate.supports(file); + } + + @Override + public Runnable processFile(PsiFile file) { + optimizerInvoked = true; + return delegate.processFile(file); + } + }); + } + + @Override + protected FormattingTask createFormattingTask(AsyncFormattingRequest request) { + return requireNonNull(super.createFormattingTask(request)); + } + } +} From 3f9f609bdf1908f9fea4c3a86e22eefd1948f164 Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Fri, 20 Nov 2026 23:36:22 +0300 Subject: [PATCH 2/5] Give the imports IntelliJ IDEA inserts open-java-format's layout Auto-import, Alt+Enter and completion insert imports through the IDE's ImportHelper, by the Java code style settings, and no import optimizer sees them: by default five classes from one package become an import on demand, which open-java-format keeps. A CodeStyleSettingsModifier now gives Java files open-java-format's import settings while the plugin is enabled: single-class imports up to 999 from a package, no packages always imported on demand, and the static imports, a blank line, then the others. The Code Style page then says that open-java-format may override its settings, and its Disable link switches the plugin off for the project, as unticking it on the plugin's page does. Switching the plugin on or off there refreshes the code style of open files, which the IDE caches for each file. The platform applies only the first modifier that changes a file's settings, and EditorConfig's is registered first: in a project whose .editorconfig sets code style properties for Java files, these settings do not apply. --- ...irJavaFormatCodeStyleSettingsModifier.java | 88 +++++++++ .../PalantirJavaFormatConfigurable.java | 17 +- .../intellij/PalantirJavaFormatSettings.java | 9 + .../src/main/resources/META-INF/plugin.xml | 2 + ...vaFormatCodeStyleSettingsModifierTest.java | 174 ++++++++++++++++++ .../PalantirJavaFormatConfigurableTest.java | 19 ++ 6 files changed, 301 insertions(+), 8 deletions(-) create mode 100644 open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatCodeStyleSettingsModifier.java create mode 100644 open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatCodeStyleSettingsModifierTest.java diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatCodeStyleSettingsModifier.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatCodeStyleSettingsModifier.java new file mode 100644 index 000000000..f27e7c9b7 --- /dev/null +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatCodeStyleSettingsModifier.java @@ -0,0 +1,88 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.javaformat.intellij; + +import com.intellij.ide.highlighter.JavaFileType; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiFile; +import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; +import com.intellij.psi.codeStyle.PackageEntry; +import com.intellij.psi.codeStyle.PackageEntryTable; +import com.intellij.psi.codeStyle.modifier.CodeStyleSettingsModifier; +import com.intellij.psi.codeStyle.modifier.CodeStyleStatusBarUIContributor; +import com.intellij.psi.codeStyle.modifier.TransientCodeStyleSettings; +import java.util.function.Consumer; +import org.jspecify.annotations.Nullable; + +/** + * Gives the Java files the plugin formats the import settings that open-java-format writes by. The IDE inserts imports + * through auto-import, Alt+Enter and completion by these settings, and no import optimizer sees them: with the IDE's + * defaults, five classes from one package become {@code import java.util.*;}, which open-java-format keeps. + * + *

The platform applies only the first modifier that changes a file's settings, and EditorConfig's is registered + * first: in a project whose {@code .editorconfig} sets code style properties for Java files, these settings do not + * apply, and its {@code ij_java_*} properties can set them there instead. + */ +final class PalantirJavaFormatCodeStyleSettingsModifier implements CodeStyleSettingsModifier { + // More names than a file imports from one package, so that an import on demand is never written. + private static final int NEVER_IMPORT_ON_DEMAND = 999; + + @Override + public boolean modifySettings(TransientCodeStyleSettings settings, PsiFile file) { + if (!JavaFileType.INSTANCE.equals(file.getFileType()) + || !PalantirJavaFormatSettings.getInstance(file.getProject()).isEnabled()) { + return false; + } + var javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); + javaSettings.USE_SINGLE_CLASS_IMPORTS = true; + javaSettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = NEVER_IMPORT_ON_DEMAND; + javaSettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = NEVER_IMPORT_ON_DEMAND; + javaSettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND.copyFrom(new PackageEntryTable()); + // Static imports, a blank line, then the others, each group in the order of its names: ImportOrderer's. + javaSettings.LAYOUT_STATIC_IMPORTS_SEPARATELY = true; + var importLayout = new PackageEntryTable(); + importLayout.addEntry(PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY); + importLayout.addEntry(PackageEntry.BLANK_LINE_ENTRY); + importLayout.addEntry(PackageEntry.ALL_OTHER_IMPORTS_ENTRY); + javaSettings.IMPORT_LAYOUT_TABLE.copyFrom(importLayout); + return true; + } + + // The Code Style page then says that its settings may be overridden by open-java-format. + @Override + public boolean mayOverrideSettingsOf(Project project) { + return PalantirJavaFormatSettings.getInstance(project).isEnabled(); + } + + @Override + public String getName() { + return "open-java-format"; + } + + @Override + @Nullable + public CodeStyleStatusBarUIContributor getStatusBarUiContributor(TransientCodeStyleSettings transientSettings) { + return null; + } + + // What the Disable link next to that message runs: these settings come with the plugin, so it switches the plugin + // off for the project, as unticking it on the plugin's settings page does. + @Override + public Consumer getDisablingFunction(Project project) { + return settings -> PalantirJavaFormatSettings.getInstance(project) + .setEnabled(PalantirJavaFormatSettings.disabledState(project)); + } +} diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurable.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurable.java index 0b5dc9d97..431cc0591 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurable.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurable.java @@ -25,6 +25,7 @@ import com.intellij.openapi.ui.TextBrowseFolderListener; import com.intellij.openapi.ui.TextFieldWithBrowseButton; import com.intellij.openapi.util.Disposer; +import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.ui.DocumentAdapter; import com.intellij.ui.components.ActionLink; import com.intellij.ui.components.JBTextArea; @@ -174,16 +175,16 @@ public void apply() throws ConfigurationException { throw new ConfigurationException("Download the embedded version or choose a binary"); } } - settings.setEnabled(enable.isSelected() ? EnabledState.ENABLED : getDisabledState()); + var wasEnabled = settings.isEnabled(); + settings.setEnabled( + enable.isSelected() ? EnabledState.ENABLED : PalantirJavaFormatSettings.disabledState(project)); settings.setUseNativeImage(useNativeImage.isSelected()); settings.setNativeImagePath(path); - } - - private EnabledState getDisabledState() { - // The default settings (inherited by new projects) are either 'enabled' or - // 'show notification'. There's no way to default new projects to disabled. If someone wants - // that, we can add another checkbox, I suppose. - return project.isDefault() ? EnabledState.UNKNOWN : EnabledState.DISABLED; + if (settings.isEnabled() != wasEnabled) { + // The Java import settings of each file are cached, and PalantirJavaFormatCodeStyleSettingsModifier sets + // them while the plugin is enabled. + CodeStyleSettingsManager.getInstance(project).notifyCodeStyleSettingsChanged(); + } } @Override diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatSettings.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatSettings.java index 1306237d6..d0d187571 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatSettings.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatSettings.java @@ -67,6 +67,15 @@ void setEnabled(EnabledState enabled) { state.enabled = enabled; } + /** + * The state that switches the plugin off. The default settings (inherited by new projects) are either 'enabled' or + * 'show notification'. There's no way to default new projects to disabled. If someone wants that, we can add + * another checkbox, I suppose. + */ + static EnabledState disabledState(Project project) { + return project.isDefault() ? EnabledState.UNKNOWN : EnabledState.DISABLED; + } + boolean isUninitialized() { return state.enabled.equals(EnabledState.UNKNOWN); } diff --git a/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml b/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml index 6be4efe93..06b45b020 100644 --- a/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml +++ b/open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml @@ -22,6 +22,8 @@ + projectBuilder = IdeaTestFixtureFactory.getFixtureFactory() + .createLightFixtureBuilder( + new DefaultLightProjectDescriptor(), getClass().getName()); + // Files in the light project's source root, so that the imports between them resolve. + fixture = JavaTestFixtureFactory.getFixtureFactory() + .createCodeInsightFixture(projectBuilder.getFixture(), new LightTempDirTestFixtureImpl(true)); + fixture.setUp(); + settings = PalantirJavaFormatSettings.getInstance(fixture.getProject()); + var resetState = new StoredSettings(); + resetState.setEnabled("true"); + settings.loadState(resetState); + } + + @AfterEach + void tearDown() throws Exception { + fixture.tearDown(); + } + + @Test + void java_files_get_the_import_settings_that_open_java_format_writes_by() { + var transientSettings = transientSettings(fixture.configureByText("A.java", "class A {}")); + + assertThat(modifier.modifySettings(transientSettings, fixture.getFile())) + .isTrue(); + + var javaSettings = transientSettings.getCustomSettings(JavaCodeStyleSettings.class); + assertThat(javaSettings.USE_SINGLE_CLASS_IMPORTS).isTrue(); + assertThat(javaSettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND).isEqualTo(999); + assertThat(javaSettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND).isEqualTo(999); + assertThat(javaSettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND.getEntries()).isEmpty(); + assertThat(javaSettings.LAYOUT_STATIC_IMPORTS_SEPARATELY).isTrue(); + assertThat(javaSettings.IMPORT_LAYOUT_TABLE.getEntries()) + .containsExactly( + PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY, + PackageEntry.BLANK_LINE_ENTRY, + PackageEntry.ALL_OTHER_IMPORTS_ENTRY); + // The project's own settings stay as they were. + assertThat(JavaCodeStyleSettings.getInstance(fixture.getProject()).CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND) + .isEqualTo(5); + } + + @Test + void the_settings_stay_as_they_are_with_the_plugin_disabled() { + settings.setEnabled(false); + var transientSettings = transientSettings(fixture.configureByText("A.java", "class A {}")); + + assertThat(modifier.modifySettings(transientSettings, fixture.getFile())) + .isFalse(); + assertThat(modifier.mayOverrideSettingsOf(fixture.getProject())).isFalse(); + } + + @Test + void files_of_other_languages_keep_their_settings() { + var transientSettings = transientSettings(fixture.configureByText("a.txt", "text")); + + assertThat(modifier.modifySettings(transientSettings, fixture.getFile())) + .isFalse(); + assertThat(modifier.mayOverrideSettingsOf(fixture.getProject())).isTrue(); + } + + @Test + void the_disable_link_of_the_code_style_page_switches_the_plugin_off() { + requireNonNull(modifier.getDisablingFunction(fixture.getProject())) + .accept(CodeStyle.getSettings(fixture.getProject())); + + assertThat(settings.isEnabled()).isFalse(); + } + + @Test + void an_import_the_ide_adds_is_a_single_class_import_however_many_come_from_its_package() { + assertThat(CodeStyleSettingsModifier.EP_NAME.getExtensionList()) + .hasAtLeastOneElementOfType(PalantirJavaFormatCodeStyleSettingsModifier.class); + + assertThat(addFifthImportFromOnePackage()).isEqualTo(""" + import p.A; + import p.B; + import p.C; + import p.D; + import p.E; + + class Main {} + """); + } + + @Test + void with_the_plugin_disabled_the_ide_imports_a_fifth_class_from_a_package_on_demand() { + settings.setEnabled(false); + + assertThat(addFifthImportFromOnePackage()).isEqualTo(""" + import p.*; + + class Main {} + """); + } + + /** Adds an import as auto-import, Alt+Enter and completion do, through the IDE's ImportHelper. */ + private String addFifthImportFromOnePackage() { + // The test fixture gives every file the same temporary settings, which no modifier sees. + CodeStyle.dropTemporarySettings(fixture.getProject()); + for (var name : List.of("A", "B", "C", "D")) { + fixture.addClass("package p; public class " + name + " {}"); + } + var fifth = fixture.addClass("package p; public class E {}"); + var file = (PsiJavaFile) fixture.configureByText("Main.java", """ + import p.A; + import p.B; + import p.C; + import p.D; + + class Main {} + """); + + WriteCommandAction.runWriteCommandAction(fixture.getProject(), () -> { + JavaCodeStyleManager.getInstance(fixture.getProject()).addImport(file, fifth); + }); + return file.getText(); + } + + private TransientCodeStyleSettings transientSettings(PsiFile file) { + CodeStyleSettings projectSettings = CodeStyle.getSettings(fixture.getProject()); + return new TransientCodeStyleSettings(file.getVirtualFile(), fixture.getProject(), projectSettings); + } +} diff --git a/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurableTest.java b/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurableTest.java index c74d18bf6..c20c7c5f2 100644 --- a/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurableTest.java +++ b/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurableTest.java @@ -19,6 +19,7 @@ import static com.google.common.collect.MoreCollectors.onlyElement; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import com.intellij.application.options.CodeStyle; import com.intellij.openapi.options.Configurable; import com.intellij.openapi.options.ConfigurationException; import com.intellij.openapi.ui.ComboBox; @@ -123,6 +124,24 @@ void readsAndWritesTheEnabledSetting() throws Throwable { assertThat(settings.isEnabled()).isTrue(); } + @Test + void refreshesTheCodeStyleOfOpenFilesWhenOpenJavaFormatIsSwitchedOnOrOff() throws Throwable { + // The import settings of each file are cached, and the plugin sets them while it is on. + var tracker = CodeStyle.getSettings(fixture.getProject()).getModificationTracker(); + var countBefore = tracker.getModificationCount(); + + EdtTestUtil.runInEdtAndWait(() -> { + configurable.reset(); + configurable.apply(); + assertThat(tracker.getModificationCount()).isEqualTo(countBefore); + + findCheckBox("Enable open-java-format").setSelected(false); + configurable.apply(); + }); + + assertThat(tracker.getModificationCount()).isGreaterThan(countBefore); + } + @Test void sitsUnderTools() { var page = Configurable.PROJECT_CONFIGURABLE.getExtensions(fixture.getProject()).stream() From 4dde8f4a93f6bbe8067992add9e9d9627b2e0416 Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Sat, 21 Nov 2026 14:10:03 +0300 Subject: [PATCH 3/5] Say why the IDE plugin still calls TrustedProjects.isTrusted The comment said that its replacement, com.intellij.ide.trustedProjects.TrustedProjects, is @ApiStatus.Internal. It is in 2024.2, but from 2025.1 that class is public, and its isProjectTrusted replaces isTrusted, deprecated since. The plugin still supports 2024.2, so the call stays until sinceBuild reaches 251. --- .../intellij/PalantirJavaFormatFormattingService.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java index 3022bf672..e503e6f22 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatFormattingService.java @@ -88,9 +88,9 @@ protected FormattingTask createFormattingTask(AsyncFormattingRequest request) { } static boolean isTrusted(Project project) { - // The marketplace verifier reports this class as experimental, and newer IDEs also deprecate it. It stays: - // its replacement, com.intellij.ide.trustedProjects.TrustedProjects, is @ApiStatus.Internal — a worse thing - // for a plugin to call. + // TrustedProjects.isTrusted is @ApiStatus.Experimental, and deprecated since 2025.1. Its replacement, + // com.intellij.ide.trustedProjects.TrustedProjects.isProjectTrusted, is public only from 2025.1, and this + // plugin still supports 2024.2: switch to it when sinceBuild reaches 251. return TrustedProjects.isTrusted(project); } From d00e3d500b06d187d8518a9952cd1d1f86b1e502 Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Sat, 21 Nov 2026 14:10:09 +0300 Subject: [PATCH 4/5] Optimize no imports in an untrusted project without a balloon Safe mode is a normal state, not a fault, yet the import optimizer logged a warning and showed a balloon each time it ran in an untrusted project, and "Optimize imports on the fly" runs it on every highlighting pass while the file has unused imports. It now returns a CollectingInfoRunnable that changes nothing: on the fly nothing shows, and an explicit Optimize Imports shows the reason in its hint instead of "No unused imports found". --- .../PalantirJavaFormatImportOptimizer.java | 19 ++++++++++++++---- ...PalantirJavaFormatImportOptimizerTest.java | 20 +++++++++++++++++++ 2 files changed, 35 insertions(+), 4 deletions(-) diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java index 22bb2963c..a2d468a79 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizer.java @@ -16,6 +16,7 @@ import com.intellij.formatting.service.FormattingNotificationService; import com.intellij.lang.ImportOptimizer; +import com.intellij.lang.ImportOptimizer.CollectingInfoRunnable; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Document; import com.intellij.openapi.progress.ProcessCanceledException; @@ -35,6 +36,18 @@ final class PalantirJavaFormatImportOptimizer implements ImportOptimizer { private static final Logger logger = Logger.getInstance(PalantirJavaFormatImportOptimizer.class); + // Changes nothing. An explicit Optimize Imports shows the message in its hint, instead of "No unused imports + // found"; on the fly nothing shows it. + private static final CollectingInfoRunnable UNTRUSTED_PROJECT = new CollectingInfoRunnable() { + @Override + public void run() {} + + @Override + public String getUserNotificationInfo() { + return Notifications.untrustedProjectMessage(); + } + }; + private final PalantirJavaFormatFormattingService formattingService; PalantirJavaFormatImportOptimizer(PalantirJavaFormatFormattingService formattingService) { @@ -58,10 +71,8 @@ public Runnable processFile(PsiFile file) { return EmptyRunnable.getInstance(); } if (!PalantirJavaFormatFormattingService.isTrusted(project)) { - logger.warn("open-java-format: skipping optimizing imports for untrusted project: " + project.getName()); - reportError( - project, Notifications.GENERIC_ERROR_NOTIFICATION_GROUP, Notifications.untrustedProjectMessage()); - return EmptyRunnable.getInstance(); + // Safe mode is a normal state, and on the fly this runs on every highlighting pass: no warning, no balloon. + return UNTRUSTED_PROJECT; } var formatter = formattingService.getFormatter(project); if (formatter.isEmpty()) { diff --git a/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java b/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java index 75002b065..e69d569fd 100644 --- a/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java +++ b/open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatImportOptimizerTest.java @@ -24,6 +24,7 @@ import com.intellij.formatting.service.AsyncFormattingRequest; import com.intellij.formatting.service.CoreFormattingService; import com.intellij.formatting.service.FormattingService; +import com.intellij.ide.impl.TrustedProjects; import com.intellij.lang.ImportOptimizer; import com.intellij.openapi.command.WriteCommandAction; import com.intellij.openapi.util.TextRange; @@ -166,6 +167,25 @@ void optimize_imports_is_the_ides_own_when_the_plugin_is_disabled() { assertThat(delegatingFormatter.optimizerInvoked).isFalse(); } + @Test + void optimize_imports_in_an_untrusted_project_changes_nothing_and_says_why_in_the_hint() { + PsiFile file = createPsiFile(UNOPTIMIZED); + TrustedProjects.setTrusted(fixture.getProject(), false); + try { + var processor = new OptimizeImportsProcessor(file.getProject(), file); + processor.setCollectInfo(true); + + run(processor); + + assertThat(file.getText()).isEqualTo(UNOPTIMIZED); + assertThat(requireNonNull(processor.getInfoCollector()).getOptimizeImportsNotification()) + .isEqualTo(Notifications.untrustedProjectMessage()); + } finally { + // The light project outlives the test. + TrustedProjects.setTrusted(fixture.getProject(), true); + } + } + private String commandLineOutput(String input) throws Exception { return delegatingFormatter .getFormatter(fixture.getProject()) From f57eebadc3ed18d52bd1008c693c9dc1d6686a03 Mon Sep 17 00:00:00 2001 From: Alex Abashev Date: Sat, 21 Nov 2026 14:10:10 +0300 Subject: [PATCH 5/5] Leave the classpath out of the untrusted-project message The message said that a trusted project is required to load the external formatter classpath, which only the Java-based formatter does. Users of the native binary got it too, since the trust check comes before the formatter is chosen. It now says that open-java-format requires a trusted project to run its formatter. --- .../java/com/palantir/javaformat/intellij/Notifications.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java index 53e50e4ad..8a0a11271 100644 --- a/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java +++ b/open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/Notifications.java @@ -28,7 +28,7 @@ static String parsingErrorMessage(String filename) { } static String untrustedProjectMessage() { - return "open-java-format requires a trusted project to load the external formatter classpath."; + return "open-java-format requires a trusted project to run its formatter."; } static String formatterFailedMessage(String filename) {