IntelliJ Platform SDK

https://plugins.jetbrains.com/docs/intellij/
Admin
The IntelliJ Platform SDK allows developers to extend the IntelliJ Platform by creating plugins,...
Tokens:382,734
Snippets:5,617
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Complete API Test Example

Source: https://plugins.jetbrains.com/docs/intellij/integration-tests-api.html

This snippet demonstrates a comprehensive integration test for a plugin. It covers setting up the test context, installing a plugin, running the IDE with a driver, and asserting values from plugin services and storage.

```kotlin
@Test
fun testStubs() {
  Starter.newContext(
    "testExample",
    TestCase(
      IdeInfo.IdeaUltimate,
      GitHubProject.fromGithub(
        branchName = "master",
        repoRelativeUrl = "JetBrains/ij-perf-report-aggregator"
      )
    )
  )
    .apply {
      val pathToPlugin = System.getProperty("path.to.build.plugin")
      PluginConfigurator(this).installPluginFromFolder(File(pathToPlugin))
    }.runIdeWithDriver().useDriverAndCloseIde {
      val storage = utility<PluginStorage>().getPluginStorage()
      val key = storage.getKey()
      val attributes = storage.getAttributes()
      Assertions.assertEquals("static method", key)
      Assertions.assertEquals(listOf("static1", "static2"), attributes)
      val answer = service<PluginService>().getAnswer()
      Assertions.assertEquals(42, answer)
      waitForProjectOpen()
      val project = singleProject()
      val strings = service<PluginProjectService>(project).getStrings()
      Assertions.assertArrayEquals(arrayOf("foo", "bar"), strings)
    }
}

```

--------------------------------

### Bottom-Up PSI Navigation Example

Source: https://plugins.jetbrains.com/docs/intellij/navigating-psi.html

Demonstrates a common bottom-up navigation pattern starting from a PSI file and offset. It finds the element at the offset, then its containing method, and finally its containing class.

```java
PsiFile psiFile = anActionEvent.getData(CommonDataKeys.PSI_FILE);
PsiElement element = psiFile.findElementAt(offset);
PsiMethod containingMethod = PsiTreeUtil.getParentOfType(element, PsiMethod.class);
PsiClass containingClass = containingMethod.getContainingClass();
```

--------------------------------

### Example Postfix Template Key Placeholder

Source: https://plugins.jetbrains.com/docs/intellij/postfix-templates.html

This example shows how the '$key' placeholder is used in template files to represent the actual template key, which is then displayed in the preview UI.

```java
cart.getProducts()$key
```

```java
cart.getProducts().var
```

--------------------------------

### Example JetBrains Runtime Archive

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-jetbrains-runtime.html

A concrete example of a JetBrains Runtime archive file name, demonstrating the structure described by the naming convention.

```text
jbr_jcef-21.0.3-osx-aarch64-b446.1.tar.gz
```

--------------------------------

### Example Test File Content

Source: https://plugins.jetbrains.com/docs/intellij/lexer-and-parser-definition.html

This is an example content for a `.simple` file used for testing the lexer and parser. It includes comments, properties, and values with spaces or special characters.

```properties
# You are reading the ".properties" entry.
! The exclamation mark can also mark text as comments.
website = https://en.wikipedia.org/ 
language = English
# The backslash below tells the application to continue reading
# the value onto the next line.
message = Welcome to \
          Wikipedia!
# Add spaces to the key
key\ with\ spaces = This is the value that could be looked up with the key "key with spaces".
# Unicode
tab : \u0009
```

--------------------------------

### Setup Maven Central and Default IntelliJ Repositories

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-repositories-extension.html

Configure Maven Central alongside the default IntelliJ Platform repositories. This setup is suitable for most plugin development scenarios.

```kotlin
repositories {
  mavenCentral()

  intellijPlatform {
    defaultRepositories()
  }
}
```

```groovy
repositories {
  mavenCentral()

  intellijPlatform {
    defaultRepositories()
  }
}
```

--------------------------------

### Open GitHub Project and Install Plugin in Test

Source: https://plugins.jetbrains.com/docs/intellij/integration-tests-intro.html

This test opens a GitHub project, installs a plugin from a local directory, and waits for IDE indicators to disappear. It verifies that the plugin does not interfere with IDE startup.

```kotlin
@Test
fun simpleTest() {
  Starter.newContext(
    "testExample",
    TestCase(
      IdeInfo.IdeaUltimate,
      GitHubProject.fromGithub(
        branchName = "master",
        repoRelativeUrl = "JetBrains/ij-perf-report-aggregator"
      )
    )
  ).apply {
    val pathToPlugin = System.getProperty("path.to.build.plugin")
    PluginConfigurator(this).installPluginFromDir(Path.of(pathToPlugin))
  }.runIdeWithDriver().useDriverAndCloseIde {
    waitForIndicators(5.minutes)
  }
}
```

--------------------------------

### Install Plugin from Directory

Source: https://plugins.jetbrains.com/docs/intellij/integration-tests-intro.html

Installs the plugin being developed from a specified directory path. The path is typically retrieved from a system property defined in the Gradle configuration.

```kotlin
.apply {
  val pathToPlugin = System.getProperty("path.to.build.plugin")
  PluginConfigurator(this).installPluginFromFolder(File(pathToPlugin))
}

```

--------------------------------

### Registering Services in plugin.xml

Source: https://plugins.jetbrains.com/docs/intellij/plugin-services.html

Example of registering application-level and project-level services in the plugin.xml descriptor file.

```xml
<extensions defaultExtensionNs="com.intellij">
  <!-- Declare the application-level service -->
  <applicationService
          serviceInterface="com.example.MyAppService"
          serviceImplementation="com.example.MyAppServiceImpl"/>

  <!-- Declare the project-level service -->
  <projectService
          serviceInterface="com.example.MyProjectService"
          serviceImplementation="com.example.MyProjectServiceImpl"/>
</extensions>
```

--------------------------------

### Stub Indexer Implementation Example

Source: https://plugins.jetbrains.com/docs/intellij/stub-indexes.html

Shows a basic implementation of a stub indexer for a custom language element, like a method. This is a conceptual example.

```java
public class JavaMethodStubElementType extends StubElementType<PsiMethod, MethodStub> {
    // ... constructor and other methods

    @Override
    public void indexStub(@NotNull MethodStub stub, @NotNull IndexSink sink) {
        sink.occurrence(JavaStubIndexKeys.METHOD_BY_NAME, stub.getName());
    }
}
```

--------------------------------

### Example: SafeDeleteProcessorDelegate implementation for Properties language

Source: https://plugins.jetbrains.com/docs/intellij/safe-delete-refactoring.html

An example of implementing `SafeDeleteProcessorDelegate` to customize Safe Delete behavior for elements in the Properties language.

```java
public class PropertiesSafeDeleteProcessor implements SafeDeleteProcessorDelegate {
    @Override
    public boolean canDeleteElement(@NotNull PsiElement element) {
        // Custom logic to determine if the element can be deleted safely
        return element instanceof Property;
    }
    // Other methods of SafeDeleteProcessorDelegate...
}
```

--------------------------------

### Action Implementation Example

Source: https://plugins.jetbrains.com/docs/intellij/action-system.html

Illustrates a basic action implementation by extending `AnAction`. This example shows how to override `actionPerformed` to define the action's behavior when triggered.

```java
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import org.jetbrains.annotations.NotNull;

public class SimpleAction extends AnAction {

    @Override
    public void actionPerformed(@NotNull AnActionEvent e) {
        // TODO: implement action logic
    }
}
```

--------------------------------

### Gradle Build Script Setup for IntelliJ IDEA Plugin

Source: https://plugins.jetbrains.com/docs/intellij/idea.html

Minimum setup for a build.gradle.kts file to define dependencies for an IntelliJ IDEA plugin project. Ensure you replace '<versionNumber>' with the desired IDE version.

```gradle
repositories {
  mavenCentral()
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea("<versionNumber>")
  }
}
```

--------------------------------

### Plugin XML for Custom Settings (Example 2)

Source: https://plugins.jetbrains.com/docs/intellij/rider.html

This example demonstrates a plugin.xml where the backend plugin ID is derived from both the vendor name and the plugin ID due to the absence of a dot in the plugin ID.

```xml
<idea-plugin>
  <id>Enterprise</id>
  <vendor>Jean-Luc Picard</vendor>
  <!-- ... -->
</idea-plugin>
```

--------------------------------

### Application-Level Light Service (Kotlin)

Source: https://plugins.jetbrains.com/docs/intellij/plugin-services.html

Example of an application-level light service implementation in Kotlin. Ensure the class is final.

```kotlin
@Service
class MyAppService {
  fun doSomething(param: String) {
    // ...
  }
}
```

--------------------------------

### GroovyTokenSets Example

Source: https://plugins.jetbrains.com/docs/intellij/implementing-lexer.html

This example shows how to define a TokenSet for grouping related token types, specifically for keywords in a Groovy language plugin. This promotes reusability.

```java
package org.jetbrains.plugins.groovy.lang.parser;

import com.intellij.psi.tree.TokenSet;
import static org.jetbrains.plugins.groovy.GroovyBundle.message;
import static org.jetbrains.plugins.groovy.GroovyElementTypes.*;

public interface GroovyTokenSets {
  TokenSet COMMENT_SET = TokenSet.create(GROOVY_DOC_COMMENT, LINE_COMMENT, BLOCK_COMMENT);
  TokenSet KEYWORD_SET = TokenSet.create(ABSTRACT, AS, ASSERT, BOOLEAN, BREAK, CASE, CATCH, CLASS, CONTINUE, DEF, DEFAULT, DELETE, DO, DOUBLE, ELSE, ENUM, EXTENDS, FINAL, FINALLY, FLOAT, FOR, GOTO, IF, IMPLEMENTS, IMPORT, INSTANCEOF, INT, INTERFACE, LONG, NATIVE, NEW, PACKAGE, PRIVATE, PROTECTED, PUBLIC, RETURN, SHORT, STATIC, SUPER, SWITCH, SYNCHRONIZED, THIS, THROW, THROWS, TRANSIENT, TRY, VOID, VOLATILE, WHILE);
  TokenSet LITERAL_SET = TokenSet.create(STRING_LITERAL, GSTRING_LITERAL, CHARACTER_LITERAL, INTEGER_LITERAL, DECIMAL_FLOATING_POINT_LITERAL, BOOLEAN_LITERAL, NULL_LITERAL);
  TokenSet OPERATOR_SET = TokenSet.create(PLUS, MINUS, MULTIPLY, DIVIDE, MODULO, ASSIGN, EQUAL, NOT_EQUAL, GREATER_THAN, LESS_THAN, GREATER_EQUAL, LESS_EQUAL, AND, OR, NOT, XOR, BINARY_AND, BINARY_OR, BINARY_NOT, SHIFT_LEFT, SHIFT_RIGHT, UNSIGNED_SHIFT_RIGHT, PLUS_ASSIGN, MINUS_ASSIGN, MULTIPLY_ASSIGN, DIVIDE_ASSIGN, MODULO_ASSIGN, AND_ASSIGN, OR_ASSIGN, XOR_ASSIGN, SHIFT_LEFT_ASSIGN, SHIFT_RIGHT_ASSIGN, UNSIGNED_SHIFT_RIGHT_ASSIGN, ELVIS_OPERATOR, SPREAD_OPERATOR, SPREAD_MAP_OPERATOR, RANGE_INC, RANGE_EXC, INSTANCEOF, AS);
  TokenSet BRACKET_SET = TokenSet.create(LPARENTHS, RPARENTHS, LBRACKET, RBRACKET, LBRACE, RBRACE);
  TokenSet DOT_SET = TokenSet.create(DOT, SAFE_DOT);
}

```

--------------------------------

### Application-Level Light Service (Java)

Source: https://plugins.jetbrains.com/docs/intellij/plugin-services.html

Example of an application-level light service implementation in Java. Ensure the class is final.

```java
@Service
public final class MyAppService {

  public void doSomething(String param) {
    // ...
  }

}
```

--------------------------------

### Example: delete() implementation for Property in Properties language

Source: https://plugins.jetbrains.com/docs/intellij/safe-delete-refactoring.html

A concrete example of implementing the `delete()` method for a `Property` PSI element within a Properties language plugin.

```java
public class Property extends PsiElementBase {
    // ...
    @Override
    public void delete() throws IncorrectOperationException {
        ASTNode node = getNode();
        if (node != null) {
            node.getTreeParent().removeChild(node);
        }
    }
    // ...
}
```

--------------------------------

### Example: KotlinNewProjectWizard

Source: https://plugins.jetbrains.com/docs/intellij/new-project-wizard.html

An example implementation of a language project generator for creating Kotlin projects. This class would typically extend LanguageGeneratorNewProjectWizard and provide specific logic for Kotlin project creation.

```Java
class KotlinNewProjectWizard : LanguageGeneratorNewProjectWizard
```

--------------------------------

### Example Quick-Fix Wording

Source: https://plugins.jetbrains.com/docs/intellij/inspections.html

Demonstrates the wording for a quick-fix, using single quotes for referenced code.

```text
Replace with 'new-method()'
```

--------------------------------

### Java Method Example

Source: https://plugins.jetbrains.com/docs/intellij/psi-references.html

This Java code demonstrates a simple method with several references that can be resolved to their declarations in the JDK.

```java
public void hello(String message) {
  System.out.println(message);
}
```

--------------------------------

### Minimal LSP Server Plugin Setup (Pre-2026.1.4)

Source: https://plugins.jetbrains.com/docs/intellij/language-server-protocol.html

Implement LspServerSupportProvider to manage LSP server startup. Use isSupportedFile to determine file support and createCommandLine for server execution.

```kotlin
import com.intellij.platform.lsp.api.LspServerSupportProvider
import com.intellij.platform.lsp.api.ProjectWideLspServerDescriptor

internal class FooLspServerSupportProvider : LspServerSupportProvider {
  override fun fileOpened(
    project: Project,
    file: VirtualFile,
    serverStarter: LspServerStarter
  ) {
    if (file.extension == "foo") {
      serverStarter.ensureServerStarted(
        FooLspServerDescriptor(project)
      )
    }
  }
}

private class FooLspServerDescriptor(project: Project)
    : ProjectWideLspServerDescriptor(project, "Foo") {

  override fun isSupportedFile(file: VirtualFile): Boolean {
    return file.extension == "foo"
  }

  override fun createCommandLine(): GeneralCommandLine {
    return GeneralCommandLine("foo", "--stdio")
  }
}
```

--------------------------------

### Get PSI Tree for a Specific Language

Source: https://plugins.jetbrains.com/docs/intellij/file-view-providers.html

Obtain the PSI tree for a particular language from a FileViewProvider. For example, to get the XML PSI tree, use `fileViewProvider.getPsi(XMLLanguage.INSTANCE)`.

```java
fileViewProvider.getPsi(language)
```

--------------------------------

### Implement RunConfiguration

Source: https://plugins.jetbrains.com/docs/intellij/run-configurations-tutorial.html

Represents a custom run configuration. It extends `RunConfigurationBase` and defines how to get options, configure the editor, and start the execution process.

```java
public class DemoRunConfiguration extends RunConfigurationBase<DemoRunConfigurationOptions> {

  protected DemoRunConfiguration(Project project,
                                 ConfigurationFactory factory,
                                 String name) {
    super(project, factory, name);
  }

  @NotNull
  @Override
  protected DemoRunConfigurationOptions getOptions() {
    return (DemoRunConfigurationOptions) super.getOptions();
  }

  public String getScriptName() {
    return getOptions().getScriptName();
  }

  public void setScriptName(String scriptName) {
    getOptions().setScriptName(scriptName);
  }

  @NotNull
  @Override
  public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
    return new DemoSettingsEditor();
  }

  @Nullable
  @Override
  public RunProfileState getState(@NotNull Executor executor,
                                  @NotNull ExecutionEnvironment environment) {
    return new CommandLineState(environment) {
      @NotNull
      @Override
      protected ProcessHandler startProcess() throws ExecutionException {
        GeneralCommandLine commandLine = 
            new GeneralCommandLine(getOptions().getScriptName());
        OSProcessHandler processHandler = ProcessHandlerFactory.getInstance()
            .createColoredProcessHandler(commandLine);
        ProcessTerminatedListener.attach(processHandler);
        return processHandler;
      }
    };
  }

}
```

--------------------------------

### Minimal LSP Client Plugin Setup (2026.1.4+)

Source: https://plugins.jetbrains.com/docs/intellij/language-server-protocol.html

Implement LspIntegrationProvider to manage LSP client lifecycle. Use isSupportedFile to check file compatibility and createCommandLine to define server startup.

```kotlin
import com.intellij.platform.lsp.api.LspIntegrationProvider
import com.intellij.platform.lsp.api.ProjectWideLspClientDescriptor

internal class FooLspIntegrationProvider : LspIntegrationProvider {
  override fun fileOpened(
    project: Project,
    file: VirtualFile,
    clientStarter: LspClientStarter
  ) {
    if (file.extension == "foo") {
      clientStarter.ensureClientStarted(
        FooLspClientDescriptor(project)
      )
    }
  }
}

private class FooLspClientDescriptor(project: Project)
    : ProjectWideLspClientDescriptor(project, "Foo") {

  override fun isSupportedFile(file: VirtualFile): Boolean {
    return file.extension == "foo"
  }

  override fun createCommandLine(): GeneralCommandLine {
    return GeneralCommandLine("foo", "--stdio")
  }
}
```

--------------------------------

### Example Postfix Template Description Files

Source: https://plugins.jetbrains.com/docs/intellij/postfix-templates.html

These files demonstrate how to describe a postfix template's behavior before and after expansion, using '<spot>' to mark important code parts and caret positions.

```java
<spot>cart.getProducts()</spot>.var
```

```java
List<Product> products = cart.getProducts();<spot></spot>
```

--------------------------------

### Setup Releases and Marketplace Repositories

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin.html

Configure Maven Central, IntelliJ Platform releases, and JetBrains Marketplace repositories. Use this when depending on specific release versions or marketplace plugins.

```kotlin
repositories {
  mavenCentral()

  intellijPlatform {
    releases()
    marketplace()
  }
}
```

```groovy
repositories {
  mavenCentral()

  intellijPlatform {
    releases()
    marketplace()
  }
}
```

--------------------------------

### PsiReference.handleElementRename() Example

Source: https://plugins.jetbrains.com/docs/intellij/rename-refactoring.html

Example of calling `PsiReference.handleElementRename()` for references to a renamed element.

```java
reference.handleElementRename(newName);
```

--------------------------------

### Setup Custom SDK Paths and Save

Source: https://plugins.jetbrains.com/docs/intellij/sdk.html

Implement setupSdkPaths to configure SDK paths and save changes using modificator.commitChanges(). This is crucial for making custom SDK settings persistent.

```java
@Override
public boolean setupSdkPaths(@NotNull Sdk sdk, @NotNull SdkModel sdkModel) {
  SdkModificator modificator = sdk.getSdkModificator();
  modificator.setVersionString(getVersionString(sdk));
  modificator.commitChanges(); // save
  return true;
}
```

--------------------------------

### Example Inspection Description - Quick Fix

Source: https://plugins.jetbrains.com/docs/intellij/inspections.html

An example of an inspection description that includes a quick-fix.

```text
Reports usages of the 'java.util.Date' class. Use 'java.time.Instant' instead.
```

--------------------------------

### PropertyRenameHandler Example

Source: https://plugins.jetbrains.com/docs/intellij/rename-refactoring.html

Example of implementing `PropertyRenameHandler` to customize the UI and workflow for renaming Groovy properties.

```java
public class PropertyRenameHandler implements RenameHandler { ... }
```

--------------------------------

### YAMLAnchorRenameInputValidator Example

Source: https://plugins.jetbrains.com/docs/intellij/rename-refactoring.html

Example of `YAMLAnchorRenameInputValidator` for validating YAML language anchor names during rename operations.

```java
public class YAMLAnchorRenameInputValidator extends RenameInputValidator { ... }
```

--------------------------------

### Setup Project Structure with Module Creation

Source: https://plugins.jetbrains.com/docs/intellij/legacy-project-wizard.html

Implement `setupProjectStructure` to create a module if no other modules exist in the project. This method is called during project import to define the project's structure.

```java
@Override
public void setupProjectStructure(
    @NotNull Collection<DetectedProjectRoot> roots,
    @NotNull ProjectDescriptor projectDescriptor,
    @NotNull ProjectFromSourcesBuilder builder) {

  List<ModuleDescriptor> modules = projectDescriptor.getModules();
  if (modules.isEmpty()) {
    modules = new ArrayList<>();
    for (DetectedProjectRoot root : roots) {
      modules.add(new ModuleDescriptor(root.getDirectory(),
          MyModuleType.getInstance(), ContainerUtil.emptyList()));
    }
    projectDescriptor.setModules(modules);
  }
}
```

--------------------------------

### setName() Implementation Example

Source: https://plugins.jetbrains.com/docs/intellij/rename-refactoring.html

Example of implementing the `setName()` method for a Properties language plugin during rename refactoring.

```java
psiElement.setName(newName);
```

--------------------------------

### Example Inspection Description - Specific Problems

Source: https://plugins.jetbrains.com/docs/intellij/inspections.html

An example of an inspection description that is specific about the code problems it detects.

```text
Reports if a method is annotated with '@Deprecated' but not documented with Javadoc.
```

--------------------------------

### Example Inspection Name

Source: https://plugins.jetbrains.com/docs/intellij/inspections.html

An example of a concise and descriptive inspection name that reflects the code problem it detects.

```text
Do not use 'check' or 'inspection' in names
```

--------------------------------

### Sample plugin.xml with Required and Optional Dependencies

Source: https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html

This example shows a plugin.xml file declaring a required dependency on the Java plugin and an optional dependency on the Kotlin plugin, along with extension definitions.

```xml
<idea-plugin>
   ... 
   <depends>com.intellij.java</depends>

   <depends
       optional="true"
       config-file="myPluginId-withKotlin.xml">org.jetbrains.kotlin</depends>

   <extensions defaultExtensionNs="com.intellij">
      <annotator
          language="JAVA"
          implementationClass="com.example.MyJavaAnnotator"/>
   </extensions>
</idea-plugin>
```

--------------------------------

### Get Package Name of Java Class

Source: https://plugins.jetbrains.com/docs/intellij/psi-cookbook.html

Use PsiUtil.getPackageName() to get the package name for a Java class.

```java
PsiUtil.getPackageName()
```

--------------------------------

### RenamePsiElementProcessor Example

Source: https://plugins.jetbrains.com/docs/intellij/rename-refactoring.html

Example of `RenamePsiElementProcessor` for renaming properties in the Properties plugin language, allowing for extended renaming logic.

```java
public class PropertiesRenamePsiElementProcessor extends RenamePsiElementProcessor { ... }
```

--------------------------------

### Implement DocumentationTargetProvider for Offset Documentation

Source: https://plugins.jetbrains.com/docs/intellij/documentation.html

Implement this extension point to build documentation for a specific offset within a PsiFile. Register it as 'com.intellij.platform.backend.documentation.targetProvider'.

```java
com.intellij.platform.backend.documentation.targetProvider
```

--------------------------------

### Project-Level Light Service (Java)

Source: https://plugins.jetbrains.com/docs/intellij/plugin-services.html

Example of a project-level light service implementation in Java. It demonstrates constructor injection of the Project and requires the class to be final.

```java
@Service(Service.Level.PROJECT)
public final class MyProjectService {

  private final Project myProject;

  MyProjectService(Project project) {
    myProject = project;
  }

  public void doSomething(String param) {
    String projectName = myProject.getName();
    // ...
  }

}
```

--------------------------------

### Stub Element Type Registration Example

Source: https://plugins.jetbrains.com/docs/intellij/stub-indexes.html

Illustrates how to register stub element types for a language. This is a conceptual example based on common patterns.

```java
public interface JavaStubElementTypes {
    IStubElementType<?, ?> FIELD = new JavaFieldStubElementType();
    IStubElementType<?, ?> METHOD = new JavaMethodStubElementType();
    // ... other stub element types
}
```

--------------------------------

### Declare IntelliJ IDEA Installer Dependency (Kotlin)

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-dependencies-extension.html

Declares a dependency on an IntelliJ IDEA installer artifact. This is the default behavior when setting up a project.

```kotlin
repositories {
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea("2026.2")
  }
}
```

--------------------------------

### Stub File Element Type Example

Source: https://plugins.jetbrains.com/docs/intellij/stub-indexes.html

Demonstrates extending IStubFileElementType to define a custom file element type for stub support. This is a conceptual example.

```java
public class MyLanguageFileElementType extends IStubFileElementType<MyLanguageFileStub> {
    public static final External લાઇसेन्स.Key<MyLanguageFileStub> EXTERNAL_ID = new External લાઇसेन्स.Key<>("my.language.stub.file");

    public MyLanguageFileElementType() {
        super(MyLanguage.INSTANCE);
    }

    @Override
    public External લાઇसेन्स.Key<MyLanguageFileStub> getExternalId() {
        return EXTERNAL_ID;
    }
}
```

--------------------------------

### Project-Level Light Service (Kotlin)

Source: https://plugins.jetbrains.com/docs/intellij/plugin-services.html

Example of a project-level light service implementation in Kotlin. It demonstrates constructor injection of the Project and requires the class to be final.

```kotlin
@Service(Service.Level.PROJECT)
class MyProjectService(private val project: Project) {
  fun doSomething(param: String) {
    val projectName = project.name
    // ...
  }
}
```

--------------------------------

### Declare IntelliJ IDEA Installer Dependency (Groovy)

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-dependencies-extension.html

Declares a dependency on an IntelliJ IDEA installer artifact using Groovy syntax. This is the default behavior.

```groovy
repositories {
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea '2026.2'
  }
}
```

--------------------------------

### Embeddable Install Plugin Button

Source: https://plugins.jetbrains.com/docs/intellij/marketing.html

Provides a button to allow users to install your plugin directly from your website into their IDE. Requires the user to have an IDE open.

```html
<!-- Example for Embeddable Install Plugin Button -->
<script src="https://plugins.jetbrains.com/embeddable/install-button.js" data-plugin-id="YOUR_PLUGIN_ID"></script>
```

--------------------------------

### Implement PsiDocumentationTargetProvider for PSI Element Documentation

Source: https://plugins.jetbrains.com/docs/intellij/documentation.html

Implement this extension point to build documentation for PSI elements. Register it as 'com.intellij.platform.backend.documentation.psiTargetProvider'.

```java
com.intellij.platform.backend.documentation.psiTargetProvider
```

--------------------------------

### Apply File Bundling to All PrepareSandboxTasks (Kotlin)

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-recipes.html

Apply file bundling configuration to all `PrepareSandboxTask` instances using `withType`. This ensures consistent file inclusion across all sandbox preparations.

```kotlin
tasks {
  withType<PrepareSandboxTask> {
    from(...) {
      into(...)
    }
  }
}
```

--------------------------------

### Apply File Bundling to All PrepareSandboxTasks (Groovy)

Source: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-recipes.html

Apply file bundling configuration to all `PrepareSandboxTask` instances using `withType` in Groovy. This ensures consistent file inclusion across all sandbox preparations.

```groovy
tasks {
  withType(PrepareSandboxTask) {
    from(...)
    into(...)
  }
}
```

--------------------------------

### Basic GotItTooltip with Header (Java)

Source: https://plugins.jetbrains.com/docs/intellij/got-it-tooltip.html

Instantiate a GotItTooltip with essential parameters and add a header to provide context. This is useful for highlighting new or changed features.

```java
new GotItTooltip(TOOLTIP_ID, GET_IT_TEXT, parentDisposable)
    .withHeader("The reader mode is on");
```

--------------------------------

### Initialize GotItTooltip (Java)

Source: https://plugins.jetbrains.com/docs/intellij/got-it-tooltip.html

Basic initialization of GotItTooltip in Java. Use this for showing tooltips tied to specific UI elements.

```java
new GotItTooltip(TOOLTIP_ID, GOT_IT_TEXT, parentDisposable)
    .show(gutterComponent, GotItTooltip.TOP_MIDDLE);
```

--------------------------------

### JFlex Definition File Example

Source: https://plugins.jetbrains.com/docs/intellij/implementing-lexer.html

This is an example of a JFlex definition file used for creating a lexer for the Properties language plugin. It demonstrates how to define tokens and their associated actions.

```jflex
%public
%class PropertiesLexer
%implements Lexer
%unicode
%function advance
%type int

%{ 
  // These imports are for the IntelliJ Platform adapter
  import com.intellij.lexer.LexerBase;
  import com.intellij.psi.tree.IElementType;
  import static com.example.PropertiesTypes.*; // Assuming PropertiesTypes contains your token types

  // Helper method to create an IElementType token
  private IElementType token(int type) {
    return PropertiesTypes.get(type); // Assuming a method to map integer types to IElementType
  }
%}

// JFlex options for IntelliJ Platform compatibility
%yylineno
%ignorecase

// Whitespace and comments
%x COMMENT

%% 

// States and transitions
<YYINITIAL> "#"          { yybegin(COMMENT); return token(HASH); }
<YYINITIAL> [ \t\r\n]+     { return token(WHITE_SPACE); }
<YYINITIAL> "="            { return token(EQUALS); }
<YYINITIAL> [^\r\n=]+      { return token(KEY_VALUE); }

<COMMENT> "\n"           { yybegin(YYINITIAL); return token(WHITE_SPACE); } // Newline ends comment
<COMMENT> [^\n]+         { return token(COMMENT_CONTENT); } // Content of the comment
<COMMENT> <<EOF>>          { yybegin(YYINITIAL); return token(WHITE_SPACE); } // End of file ends comment

// Fallback for any other character (should not happen with a complete grammar)
[^]                     { return token(BAD_CHARACTER); }

```

--------------------------------

### Basic GotItTooltip with Header

Source: https://plugins.jetbrains.com/docs/intellij/got-it-tooltip.html

Instantiate a GotItTooltip with essential parameters and add a header to provide context. This is useful for highlighting new or changed features.

```kotlin
GotItTooltip(TOOLTIP_ID, GET_IT_TEXT, parentDisposable)
    .withHeader("The reader mode is on")
```

--------------------------------

### Plugin XML for Custom Settings (Example 1)

Source: https://plugins.jetbrains.com/docs/intellij/rider.html

This example shows a plugin.xml configuration where the IntelliJ plugin ID directly determines the backend plugin ID for custom settings.

```xml
<idea-plugin>
  <id>com.example.awesomeplugin</id>
  <!-- ... -->
</idea-plugin>
```

--------------------------------

### Initialize GotItTooltip (Kotlin)

Source: https://plugins.jetbrains.com/docs/intellij/got-it-tooltip.html

Basic initialization of GotItTooltip in Kotlin. Use this for showing tooltips tied to specific UI elements.

```kotlin
GotItTooltip(TOOLTIP_ID, GOT_IT_TEXT, parentDisposable)
    .show(gutterComponent, GotItTooltip.TOP_MIDDLE)
```

--------------------------------

### Java Message Bundle Class Example

Source: https://plugins.jetbrains.com/docs/intellij/internationalization.html

This Java example demonstrates creating a message bundle class by extending DynamicBundle. It provides methods for retrieving messages and lazy messages.

```java
final class ExampleBundle {
  @NonNls
  private static final String BUNDLE = "messages.ExampleBundle";
  private static final DynamicBundle INSTANCE =
      new DynamicBundle(ExampleBundle.class, BUNDLE);

  private ExampleBundle() {}

  public static @NotNull @Nls String message(
      @NotNull @PropertyKey(resourceBundle = BUNDLE) String key,
      Object @NotNull ... params
  ) {
    return INSTANCE.getMessage(key, params);
  }

  public static Supplier<@Nls String> lazyMessage(
      @NotNull @PropertyKey(resourceBundle = BUNDLE) String key,
      Object @NotNull ... params
  ) {
    return INSTANCE.getLazyMessage(key, params);
  }
}
```

--------------------------------

### Example: PythonNewProjectWizard

Source: https://plugins.jetbrains.com/docs/intellij/new-project-wizard.html

An example implementation of a language project generator for creating Python projects. This class would typically extend LanguageGeneratorNewProjectWizard and provide specific logic for Python project creation.

```Java
class PythonNewProjectWizard : LanguageGeneratorNewProjectWizard
```
Tokens:
Raw