Performance issue using IntelliJ Community Edition with spotless-maven-plugin and IDEA formatter

[ozlmulg]

Hi Spotless team 👋

Description:

First of all, thanks for adding support for the IntelliJ IDEA formatter in the Spotless Maven plugin — it's a great feature!

I'm currently testing this integration using spotless-maven-plugin version 2.45.0-SNAPSHOT and IntelliJ IDEA Community Edition (latest available version). I'm using 2.45.0-SNAPSHOT, built locally, since there hasn't been a stable release yet that includes IntelliJ (idea) support for Maven.

The formatter works as expected, but performance has become a concern. Specifically, during a spotless:check or spotless:apply, the plugin appears to launch a separate IDEA instance for each file, like:

Launching IDEA formatter for orig file ... with params: [idea, format, -s, ..., /tmp/spotlessXYZ123.java] and env: {IDEA_PROPERTIES=/.../idea.properties}

This results in very slow formatting, especially for projects with hundreds of .java files.

Here's my relevant Maven configuration:

        <plugin>
          <groupId>com.diffplug.spotless</groupId>
          <artifactId>spotless-maven-plugin</artifactId>
          <version>2.45.0-SNAPSHOT</version>
          <executions>
            <execution>
              <goals>
                <goal>check</goal>
                <goal>apply</goal>
              </goals>
            </execution>
          </executions>
          <configuration>
            <java>
              <includes>
                <include>src/**/*.java</include>
              </includes>
              <idea>
                <codeStyleSettingsPath>
                  /Users/ozlemulag/Documents/codestyle_settings.xml
                </codeStyleSettingsPath>
                <withDefaults>false</withDefaults>
                <binaryPath>/Applications/IntelliJ IDEA CE.app/Contents/MacOS/idea</binaryPath>
              </idea>
            </java>
          </configuration>
        </plugin>

Additional Notes:
When I run the formatter directly using the IntelliJ format.sh script and pass multiple files at once, performance is much faster. For example:

find . -name "*.java" -print0 | xargs -0 /Applications/IntelliJ\ IDEA\ CE.app/Contents/bin/format.sh -s /Users/ozlemulag/Documents/codestyle_settings.xml

This approach completes quickly even on large projects.

Request:
Is there any possibility to improve performance in the plugin?
I’m not sure whether this is technically feasible due to how the formatter integration works, but just wanted to ask if this is something that could be optimized.

Thanks again for your great work and looking forward to hearing your thoughts!

[simschla]

Thanks for your feedback on the new IntelliJ IDEA integration. 🥳

Spotless works on a file-per-file-basis, which results in exactly the performance behavior you see. And it's precisely what we meant with the limitation noted in README.md:

Launching IntelliJ IDEA from the command line is pretty expensive and as of now, we do this for each file. If you want to change this, consider opening a PR.

To speed this up, we would need support in spotless core for this. From the top of my head:

1. Allow Batching of File-Sets (resulting in fewer calls to idea) by changing or extendingFormatterFunc so we could at least invoke idea for batches not each file separately:

   spotless/lib/src/main/java/com/diffplug/spotless/FormatterFunc.java

   Line 28 in 86d65b0

   public interface FormatterFunc {

2. Allow formatters to operate on the <includes> directly. This could work in a "mixed" mode:

   • Run spotless as normal on all files up to a formatter requiring file access.
   • Provide the formatter requiring file access with (potentially preformatted and temporary stored) files so it may invoke formatting on all of them.
   • Continue spotless pipeline until the end of the formatting pipeline is reached.

I'm pretty sure this topic has come up before, so would be interesting to hear @nedtwigg's thoughts on this.

[nedtwigg]

Out of the box right now, there are two ways to improve the performance:

• up-to-date checking
• git ratchet

The value that Spotless brings is that you can compose formatters. The cost is that the formatters that work with Spotless must be composable - ideally they can accept input in-memory, and if they require it to be on-disk then we have to write a tempfile for every usage.

An important corner case that happens a lot:

• you have 10 files
• on 5 of them, the formatter runs once and gets the same result -> it's already formatted
• on 4 of them, the formatter runs once and gets a new result, then runs again and gets the same result -> formatter was idempotent
• 1 of them has an idempotency issue, so Spotless will run the formatter loop multiple times on that one file until it is fixed

It is not the case that Spotless just calls all the functions once on each file - it calls the functions a variable number of times per file, because that is required to ensure idempotency. If formatters were good at idempotency out of the box, Spotless wouldn't be as valuable. Maybe they have improved today, but at the start of Spotless this was a pretty big problem.

So if we added a way for a FormatterStep to say "I perform better on multiple files at once", it would require some pretty fancy scheduling & batching to figure out which files to pass each round. Very doable, but imo formatting is not important enough to justify that effort. If I wanted to use IntelliJ on a large project, I would

• use Spotless and its ratchet feature so that IntelliJ is only running on the changed files
• find some other plugin or shell-script which calls IntelliJ in parallel, accepting that I will lose the composability and bubblewrap that Spotless provides
• harang IntelliJ to make its formatter more API friendly

[philippe-granet]

harang IntelliJ to make its formatter more API friendly

Ticket open for 7 years: https://youtrack.jetbrains.com/issue/IJPL-29924/Provide-standalone-formatter-or-API

[philippe-granet]

I found this maven plugin https://github.com/mschieder/idea-code-formatter that uses and bundles a standalone version (157 MB) of the IntelliJ IDEA command line formatter (No installed IntelliJ IDEA is required)

Could this help improve performance, while maintaining Spotless's file-by-file operation?

[nedtwigg]

@philippe-granet that might be a great step forward. We used to do something similar for Eclipse, which was eventually abandoned because the maintenance burden was too high and we were able to use the original unaltered artifacts.

An independent project which takes the freely-licensed parts of the idea formatter and keeps them up-to-date release after release would be very valuable to Spotless and other projects. If it's just a one-time snapshot, that is also useful but less so.

I'd be happy to merge a PR which leverages an independent project such as this. But its quite a lot of work - if it's worth it at all, it's probably worth it to document the process enough that it can be repeated a few times a year to update to upstream's latest.