Dynamic Plugins

No Use of Components

No Components must be used; existing ones must be migrated to services, extensions, or listeners.

Action Group Requires ID

All <group>s must declare a unique id.

Use Only Dynamic Extensions

Whether defined in the platform itself (Extension Point and Listener List) or coming from other plugins, all used extension points must be marked explicitly as dynamic (see next paragraph).

Some deprecated extension points (e.g., com.intellij.configurationProducer) are intentionally non-dynamic, and their usage should be migrated to the corresponding replacement.

Mark Extension Points as Dynamic

If a plugin defines its own custom extension points, they must adhere to specific usage rules and then be declared ready for dynamic use explicitly.

Configurables Depending on Extension Points

Any Configurable which depends on dynamic extension points must implement Configurable.WithEpDependencies.

No Use of Service Overrides

Application, project, and module services declared with overrides="true" are not allowed.

CachedValue

Loading/Unloading a plugin clears all cached values created using CachedValuesManager.

Do not Store PSI

Do not store references to PSI elements in objects which can survive plugin loading or unloading; use SmartPsiElementPointer instead.

Do not Use FileType/Language as Map Key

Replace with String from Language.getID()/FileType.getName() (use inspection Plugin DevKit | Code | Map key may leak).

Plugin Load/Unload Events

Register DynamicPluginListener application listener to receive updates on plugin load/unload events.

This can be used to e.g., cancel long-running activities or disallow unload due to ongoing processes.

Logging

All events are tracked under com.intellij.ide.plugins.DynamicPlugins category in IDE log file. If a plugin fails to reload, the log will contain a cause as to why.

Diagnosing Leaks

To find leaks preventing clean unload, perform the following steps:

1. Verify that the IDE is running with the VM parameter -XX:+UnlockDiagnosticVMOptions. When using Gradle, specify runIde.jvmArgs += "-XX:+UnlockDiagnosticVMOptions" otherwise Configure JVM Options.

2. Set Registry key ide.plugins.snapshot.on.unload.fail to true (Go to Navigate | Search Everywhere and type Registry).

3. Trigger the plugin reload.

4. Open the .hprof memory snapshot generated on plugin unload, look for the plugin ID string. IntelliJ Ultimate can open memory snapshots directly.

5. Find the PluginClassLoader referencing the plugin ID string

6. Look at references to the PluginClassLoader instance.

7. Every one of them is a memory leak (or part of a memory leak) that needs to be resolved.

When you've completed step 1 and 2, the log will contain more information about the memory leak, for instance the following shows a chain of field references that is keeping the class loader in memory.