FWD » Core Development » Conversion Tools

IntelliJ plugin for integration with syntax check and running conversion (et al). This must also provide the full support for 4GL editor coloring, syntax expansion, source debugging and so forth). A developer must be able to continue 4GL development using FWD only (no Progress Developer Studio which is a licensed product).

This is meant to be functionally equivalent to the Eclipse plugin (#3883). The results may be limited by the capabilities of each platform. We should use common code as much as possible, but if an IDE-native approach yields a significantly better result we will consider using that.

IntelliJ Platform SDK
IntelliJ LSP Support (Language Server Protocol, also see the IntelliJ LSP Github Project)
Simple IntelliJ Plugin Tutorial

The long term roadmap for IntelliJ is not clear, I can't find it published anywhere. If anyone can point me to something I've missed, I'll be happy to review it.

I'm especially interested in:

• Is there a long term path to more natively use the language server protocol? There is a 3rd party plugin that provides some support but it is not clear if IntelliJ is going to support it directly.
• What is the long term plan for writing IntelliJ plugins? Other platforms are moving to the web, is that in plan? Or should we keep writing a Swing based UI?

See #1757-9 for some analysis of how auto-completion may require a move to ANTLRv4.

I see that the IntelliJ LSP support isn't maintained anymore. Also, according to jetbrains:

The integration with the Language Server Protocol is created as an extension to the commercial IntelliJ-based IDEs. Therefore, plugins using Language Server integration are not available in JetBrains products like IntelliJ IDEA Community Edition and Android Studio from Google.

Among the lternatives for the client I found
1. lsp4intellij, which was forked from the one above.
2. LSP4ij, a client compatible with IntelliJ.It also has debug Adapter Protocol support with Debug Adapter Protocol Run/Debug configuration.

The IntelliJ platform is Swing-based and we can think of the UI components as wrappers over Swing JComponents. For example, this is the code for my code preview:

MyPreviewEditor.javaMyPreviewEditor.java

public class MyPreviewEditor implements FileEditor
{

   private final Editor editor;
   private final VirtualFile file;
   private final Project project;
   private final PsiFile psiFile;
   public MyPreviewEditor(Project project, VirtualFile file)
   {
      this.file = file;
      this.project = project;

      LightVirtualFile previewFile = new LightVirtualFile("preview.p", file.getFileType(), "");
      this. psiFile = PsiManager.getInstance(project).findFile(previewFile);
      // Create a document backed by the file
      Document document = FileDocumentManager.getInstance().getDocument(previewFile);
      if (document == null) {
         throw new IllegalStateException("Could not get document for preview file");
      }
      editor = EditorFactory.getInstance().createEditor(document, project, previewFile.getFileType(), true);
   }

   public void updatePreview(String text) {
      ApplicationManager.getApplication().invokeLater(() ->
              WriteCommandAction.runWriteCommandAction(editor.getProject(), () ->
                      editor.getDocument().setText(text)
              )
      );

   }
...
}

It wraps an intellij Editor which exposes editor.getComponent(). For example, if we wanted to register a key event for this editor, we would have something like this:

registering an actionregistering an action

 private void registerToggleAction()
   {
      AnAction toggleAction = new AnAction("Toggle Preview")
      {
         @Override
         public void actionPerformed(@NotNull AnActionEvent e) {

           // toggle on/off
      };

      // Add shortcut Alt+Shift+P
      ShortcutSet shortcutSet = new CustomShortcutSet(
              new KeyboardShortcut(KeyStroke.getKeyStroke("alt shift P"), null)
      );
      toggleAction.registerCustomShortcutSet(shortcutSet, getComponent());
   }

The KeyboardSHortcut is another wrapper over Swing KeyStroke class, which is bound to the editor’s Swing JComponent when calling registerCustomShortcutSet.

For different scenarios, we may have different FileEditorProvider implementations (that is an intellij interface). Each such interface has to be registered in the plugin.xml.
For example, for Progress files I have MyPreviewProvider, which, as the name suggests, will provide a special kind of editor - one that has two sides (an editor and a preview).

MyPreviewProvider.javaMyPreviewProvider.java

public class MyPreviewEditorProvider implements FileEditorProvider, DumbAware {

   private static final String EDITOR_TYPE_ID = "my-preview-editor";

   @Override
   public boolean accept(@NotNull Project project, @NotNull VirtualFile file) {  
      // here is the condition when to apply this sort of editor
      return file.getFileType() instanceof ProgressFileType;
   }

   @Override
   public @NotNull FileEditor createEditor(@NotNull Project project, @NotNull VirtualFile file) {
      TextEditor sourceEditor = (TextEditor) TextEditorProvider.getInstance().createEditor(project, file);
      MyPreviewEditor preview = null;
      preview = new MyPreviewEditor(project, file);

      // start in editor-only mode
      return new ToggleableTextEditorWithPreview(sourceEditor, preview);
   }

   @Override
   public @NotNull String getEditorTypeId() {
      return EDITOR_TYPE_ID;
   }

   @Override
   public FileEditorPolicy getPolicy() {
      return FileEditorPolicy.HIDE_DEFAULT_EDITOR;
   }
}

The sourceEditor and preview are both imlementations of TextEditor and FileEditor interfaces which have to wrap a an Editor implementation.

The IntelliJ plugin deals with the syntax tree of a language using PsiElement abstractions. These provide information about structure and semantics of a language, so each language needs an own such structure.

We can inspect the PSI structure of the current file by Tools > View PSI structure of current file, for a Java file one would see eleements like PsiJavaFile(the root), PsiMethod, PsiAnnotation, etc.

How A Custom PSI Structure Is Created
Essentially, this structure is constructed by first designing a grammar for the code. Even if we use an LSP responsible for the lexing and parsing, we would still need a client PSI focused only on editor responsiveness and incremental updates.

Instead of using the standard IntelliJ lexer support, I wrote a small grammar in ANTLR4 and integrated it with IntelliJ API:

lexer grammar ProgressLexer;

MESSAGE : 'message' | 'MESSAGE';
DEFINE : 'scoped-define' | 'global-define' ;
TEXT : (~[ {}&"\r\n])+ ;
LCURLY : '{' ;
AMP : '&' ;
RCURLY : '}' ;
DQUOTE : '"' ;
DOT : '.' ;
STRING_LITERAL : DQUOTE (TEXT | ' ')* DQUOTE ;
WS : [ \t\r\n]+;

This required an adapter that wraps the ProgressLexer and uses it to extend the abstract com.intellij.lexer.Lexer class.

AntlrLexerAdapterAntlrLexerAdapter

public class AntlrLexerAdapter extends Lexer {
   private Token currentToken;
   private final ProgressLexer antlrLexer = new ProgressLexer(null);
   private CharSequence buffer;
   private int startOffset;

   @Override
   public void start(@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) {
      this.buffer = buffer;
      this.startOffset = startOffset;
      CharStream input = CharStreams.fromString(buffer.subSequence(startOffset, endOffset).toString());
      antlrLexer.setInputStream(input);
      advance();
   }

   @Override
   public int getState() {
      return 0; // store lexer mode here if needed
   }

   @Override
   public IElementType getTokenType() {
      if (currentToken == null || currentToken.getType() == Token.EOF) return null;
      return ProgressTokenTypes.getTokenType(currentToken.getType());
   }

   @Override
   public int getTokenStart() {
      return startOffset + currentToken.getStartIndex();
   }

   @Override
   public int getTokenEnd() {
      return startOffset + currentToken.getStopIndex() + 1;
   }

   @Override
   public void advance() {
      currentToken = antlrLexer.nextToken();
   }

   @Override
   public @NotNull LexerPosition getCurrentPosition() {
      final int offset = currentToken != null ? currentToken.getStartIndex() : 0;
      final int state = currentToken != null ? currentToken.getType() : 0;

      return new LexerPosition() {
         @Override
         public int getOffset() {
            return offset;
         }

         @Override
         public int getState() {
            return state;
         }
      };
   }

   @Override
   public void restore(@NotNull LexerPosition position) {
      int offset = position.getOffset();
      CharStream input = antlrLexer.getInputStream();
      input.seek(offset);
      currentToken = antlrLexer.nextToken();
   }

   @NotNull
   @Override
   public CharSequence getBufferSequence() {
      return buffer;
   }

   @Override
   public int getBufferEnd() {
      return buffer.length();
   }
}

Next, the flow goes like this:

PsiBuilder
     │
     ▼
PsiParser.parse() → AST tree (ASTNodes with types & offsets)
     │
     ▼
ParserDefinition.createElement() → PSI tree (PsiElements wrapping ASTNodes)
     │
     ▼
Register the grammar definition in the PLUGIN.XML.

PsiParser.parse() - If we had a ProgressParser as well, we'd just adapt the PsiParser too. In absence of a parser, we can iterate manually through the tokens produced by our PsiBuilder. Here we parse the file includes and the 4GL reference calls, and also the global-defines and scoped defines:

ProgressPsiParserProgressPsiParser

public class ProgressPsiParser implements PsiParser {

   @NotNull
   @Override
   public ASTNode parse(@NotNull IElementType root, @NotNull PsiBuilder builder) {
      PsiBuilder.Marker rootMarker = builder.mark();

      while (!builder.eof()) {
         IElementType tokenType = builder.getTokenType();
         if (tokenType == ProgressTokenTypes.LCURLY) {
            boolean isMacro = false;
            PsiBuilder.Marker includeMarker = builder.mark();
            builder.advanceLexer(); // consume '{'
            if (builder.getTokenType() == ProgressTokenTypes.AMP)
            {
               builder.advanceLexer();
               isMacro = true; // is a reference include and not a file include
            }
            if (builder.getTokenType() == ProgressTokenTypes.TEXT) builder.advanceLexer();
            if (builder.getTokenType() == ProgressTokenTypes.RCURLY) builder.advanceLexer();
            if (isMacro)
            {
               includeMarker.done(new IElementType("reference_include", ProgressLanguage.INSTANCE)); // standalone PSI
            }
            else
            {
               includeMarker.done(new IElementType("file_include", ProgressLanguage.INSTANCE)); // standalone PSI
            }
         } else
         if (tokenType == ProgressTokenTypes.AMP)
         {
            PsiBuilder.Marker defineMarker = builder.mark();
            builder.advanceLexer();
            if (builder.getTokenType() == ProgressTokenTypes.DEFINE) builder.advanceLexer();
            while (builder.getTokenType() == ProgressTokenTypes.WS) builder.advanceLexer();
            if (builder.getTokenType() == ProgressTokenTypes.TEXT) builder.advanceLexer(); // macro name
            defineMarker.done(new IElementType("define", ProgressLanguage.INSTANCE));
         } else {
            builder.advanceLexer();
         }
      }

      rootMarker.done(root);
      return builder.getTreeBuilt();
   }
}

ParseDefiniton.createElement() - here we convert the AST elements into PSI elements that can interact with the IntelliJ API: ProgressParserDefinitionProgressParserDefinition

public class ProgressParserDefinition implements ParserDefinition {

   public static final IFileElementType FILE = new IFileElementType(ProgressLanguage.INSTANCE);

   ...

   @NotNull
   @Override
   public PsiElement createElement(ASTNode node) {
      if (node.getElementType().getDebugName().equals("file_include")) {
         return new ProgressPsiInclude(node);
      }
      if (node.getElementType().getDebugName().equals("reference_include")) {
         return new ProgressPsiReference(node);
      }
      if (node.getElementType().getDebugName().equals("define")) {
         return new ProgressPsiDefine(node);
      }
      return new ASTWrapperPsiElement(node);
   }
}

Now, we can inspect a .p file and view the @PsiElements:

Practical example of how to use PsiElementsPractical example of how to use PsiElements

public class ProgressAnnotator implements Annotator {
   private static TextAttributesKey FILE_INCLUDE_COLOR = null;

   private static TextAttributesKey REFERENCE_INCLUDE_COLOR = null;

   private static TextAttributesKey getFileIncludeColor()
   {
      if (FILE_INCLUDE_COLOR == null)
      {
         FILE_INCLUDE_COLOR = TextAttributesKey.createTextAttributesKey(
                 "PROGRESS_FILE_INCLUDE",
                 new TextAttributes(
                         new Color(197, 0, 0), // Navy blue
                         null,                 // background
                         null,                 // effect color
                         null,                 // effect type
                         Font.PLAIN            // font style
                 ));
      }

      return FILE_INCLUDE_COLOR;
   }

   @Override
   public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder)
   {
      if (element instanceof ProgressPsiInclude)
      {
         holder.newSilentAnnotation(HighlightSeverity.INFORMATION)
                 .textAttributes(getFileIncludeColor())
                 .create();
      }
   }
}

<extensions>
...
        <annotator
                language="Progress" 
                implementationClass="fer.plugindemox2.highlighting.ProgressAnnotator"/>
...
</extensions>

ParserDefiniton.createElement() - here we convert the AST elements into PSI elements that can interact with the IntelliJ API

Instead of using a JavaParserDefinition, which is deprecated, the IntelliJ Java Plugin now uses a JavaSyntaxDefinitionJavaSyntaxDefinition

interface LanguageSyntaxDefinition {
  fun parse(builder: SyntaxTreeBuilder)

  /**
   * An instance of [com.intellij.platform.syntax.lexer.Lexer] for the language with default settings.
   * Create your lexer directly if you need to set some custom settings.
   */
  fun createLexer(): Lexer

  /**
   * The set of comment token types of the language
   */
  val comments: SyntaxElementTypeSet

  /**
   * The set of whitespace token types of the language
   */
  val whitespaces: SyntaxElementTypeSet get() = syntaxElementTypeSetOf(SyntaxTokenTypes.WHITE_SPACE)

  /**
   * Controls whitespace balancing behavior of [com.intellij.platform.syntax.parser.SyntaxTreeBuilder].
   * For more details see [com.intellij.platform.syntax.parser.WhitespaceOrCommentBindingPolicy]
   */
  val whitespaceOrCommentBindingPolicy: WhitespaceOrCommentBindingPolicy?
    get() = null

  /**
   * The policy for handling opaque elements in the syntax tree.
   * For more details see [com.intellij.platform.syntax.parser.OpaqueElementPolicy]
   */
  val opaqueElementPolicy: OpaqueElementPolicy?
    get() = null
}

1. Since in the previous approach the ParserDefinition was repsonsible for creating the PsiElements, I tried understanding where this is taking place now. In other words, the mapping between IElementTypes to PsiElemenets. My guess is that the composite elements, such as statements, expressions, etc., each know how to create an own Psi element, which is done implicitly. I will post more about this once I form a clear understanding.

2. With that out of the way, I'm curious about how the PsiElements are annotated (highlighted). It's clear for me that simple tokens are highlighted in the JavaFileHighlighter, using a hash map that stores the colors and the method:

  @Override
  public TextAttributesKey @NotNull [] getTokenHighlights(IElementType tokenType) {
    while (tokenType instanceof ParentProviderElementType parentProviderElementType) {
      if (parentProviderElementType.getParents().size() == 1) {
        tokenType = parentProviderElementType.getParents().iterator().next();
      }
    }
    return pack(ourMap1.get(tokenType), ourMap2.get(tokenType));
  }

I tried understanding where this is taking place now. In other words, the mapping between IElementTypes to PsiElemenets.

From what I've investigated and debugged, there are two scenarios when PsiElements are created:

1. When the file is parsed - this happens when IntelliJ actually parses the source code and builds the AST. Some use cases are retyping, just opening the file, or other operations that change the AST. For this, the Java plugin creates the PsiElements very similarly to our approach for the small Progress Demo - in the ParserDefinition.createElement
2. Called via the stub-factory. Here the PSIs are build from stubs using a factory class. The factory classes are defined in JavaStubRegistryExtensionJavaStubRegistryExtension

   
   public class JavaStubRegistryExtension implements StubRegistryExtension {
     @Override
     public void register(@NotNull StubRegistry registry) {
       JavaStubElementTypePsiElementMappingRegistry.getInstance();
   
       registry.registerStubSerializer(JavaParserDefinition.JAVA_FILE, new JavaFileSerializer());
   
       registry.registerStubSerializer(JavaStubElementTypes.LITERAL_EXPRESSION, new JavaLiteralExpressionStubSerializer(JavaStubElementTypes.LITERAL_EXPRESSION));
       registry.registerLightStubFactory(JavaStubElementTypes.LITERAL_EXPRESSION, new JavaLiteralExpressionStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.MODIFIER_LIST, new JavaModifierListSerializer(JavaStubElementTypes.MODIFIER_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.MODIFIER_LIST, new JavaModifierListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.ANNOTATION, new JavaAnnotationStubSerializer(JavaStubElementTypes.ANNOTATION));
       registry.registerLightStubFactory(JavaStubElementTypes.ANNOTATION, new JavaAnnotationStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.ANNOTATION_PARAMETER_LIST, new JavaAnnotationParameterListStubSerializer(JavaStubElementTypes.ANNOTATION_PARAMETER_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.ANNOTATION_PARAMETER_LIST, new JavaAnnotationParameterListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.NAME_VALUE_PAIR, new JavaNameValuePairStubSerializer(JavaStubElementTypes.NAME_VALUE_PAIR));
       registry.registerLightStubFactory(JavaStubElementTypes.NAME_VALUE_PAIR, new JavaNameValuePairStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.LAMBDA_EXPRESSION, new LambdaExpressionStubSerializer(JavaStubElementTypes.LAMBDA_EXPRESSION));
       registry.registerLightStubFactory(JavaStubElementTypes.LAMBDA_EXPRESSION, new LambdaExpressionStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.METHOD_REF_EXPRESSION, new MethodReferenceStubSerializer(JavaStubElementTypes.METHOD_REF_EXPRESSION));
       registry.registerLightStubFactory(JavaStubElementTypes.METHOD_REF_EXPRESSION, new MethodReferenceStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.PARAMETER_LIST, new JavaParameterListStubSerializer(JavaStubElementTypes.PARAMETER_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.PARAMETER_LIST, new JavaParameterListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.PARAMETER, new JavaParameterStubSerializer(JavaStubElementTypes.PARAMETER));
       registry.registerLightStubFactory(JavaStubElementTypes.PARAMETER, new JavaParameterStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.TYPE_PARAMETER, new JavaTypeParameterStubSerializer(JavaStubElementTypes.TYPE_PARAMETER));
       registry.registerLightStubFactory(JavaStubElementTypes.TYPE_PARAMETER, new JavaTypeParameterStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.TYPE_PARAMETER_LIST, new JavaTypeParameterListStubSerializer(JavaStubElementTypes.TYPE_PARAMETER_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.TYPE_PARAMETER_LIST, new JavaTypeParameterListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.CLASS_INITIALIZER, new JavaClassInitializerStubSerializer(JavaStubElementTypes.CLASS_INITIALIZER));
       registry.registerLightStubFactory(JavaStubElementTypes.CLASS_INITIALIZER, new JavaClassInitializerStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.IMPORT_LIST, new JavaImportListStubSerializer(JavaStubElementTypes.IMPORT_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.IMPORT_LIST, new JavaImportListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.MODULE, new JavaModuleStubSerializer(JavaStubElementTypes.MODULE));
       registry.registerLightStubFactory(JavaStubElementTypes.MODULE, new JavaModuleStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.REQUIRES_STATEMENT, new JavaRequiresStatementStubSerializer(JavaStubElementTypes.REQUIRES_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.REQUIRES_STATEMENT, new JavaRequiresStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.USES_STATEMENT, new JavaUsesStatementStubSerializer(JavaStubElementTypes.USES_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.USES_STATEMENT, new JavaUsesStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.PROVIDES_STATEMENT, new JavaProvidesStatementStubSerializer(JavaStubElementTypes.PROVIDES_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.PROVIDES_STATEMENT, new JavaProvidesStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.RECORD_COMPONENT, new JavaRecordComponentStubSerializer(JavaStubElementTypes.RECORD_COMPONENT));
       registry.registerLightStubFactory(JavaStubElementTypes.RECORD_COMPONENT, new JavaRecordComponentStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.RECORD_HEADER, new JavaRecordHeaderStubSerializer(JavaStubElementTypes.RECORD_HEADER));
       registry.registerLightStubFactory(JavaStubElementTypes.RECORD_HEADER, new JavaRecordHeaderStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.PACKAGE_STATEMENT, new JavaPackageStatementStubSerializer(JavaStubElementTypes.PACKAGE_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.PACKAGE_STATEMENT, new JavaPackageStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.EXPORTS_STATEMENT, new JavaPackageAccessibilityStatementStubSerializer(JavaStubElementTypes.EXPORTS_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.EXPORTS_STATEMENT, new JavaPackageAccessibilityStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.OPENS_STATEMENT, new JavaPackageAccessibilityStatementStubSerializer(JavaStubElementTypes.OPENS_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.OPENS_STATEMENT, new JavaPackageAccessibilityStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.CLASS, new JavaClassStubSerializer(JavaStubElementTypes.CLASS));
       registry.registerLightStubFactory(JavaStubElementTypes.CLASS, new JavaClassStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.IMPLICIT_CLASS, new JavaClassStubSerializer(JavaStubElementTypes.IMPLICIT_CLASS));
       registry.registerLightStubFactory(JavaStubElementTypes.IMPLICIT_CLASS, new JavaClassStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.ANONYMOUS_CLASS, new JavaClassStubSerializer(JavaStubElementTypes.ANONYMOUS_CLASS));
       registry.registerLightStubFactory(JavaStubElementTypes.ANONYMOUS_CLASS, new JavaClassStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.ENUM_CONSTANT_INITIALIZER, new JavaClassStubSerializer(JavaStubElementTypes.ENUM_CONSTANT_INITIALIZER));
       registry.registerLightStubFactory(JavaStubElementTypes.ENUM_CONSTANT_INITIALIZER, new JavaClassStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.METHOD, new JavaMethodStubSerializer(JavaStubElementTypes.METHOD));
       registry.registerLightStubFactory(JavaStubElementTypes.METHOD, new JavaMethodStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.ANNOTATION_METHOD, new JavaMethodStubSerializer(JavaStubElementTypes.ANNOTATION_METHOD));
       registry.registerLightStubFactory(JavaStubElementTypes.ANNOTATION_METHOD, new JavaMethodStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.FIELD, new JavaFieldStubSerializer(JavaStubElementTypes.FIELD));
       registry.registerLightStubFactory(JavaStubElementTypes.FIELD, new JavaFieldStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.ENUM_CONSTANT, new JavaFieldStubSerializer(JavaStubElementTypes.ENUM_CONSTANT));
       registry.registerLightStubFactory(JavaStubElementTypes.ENUM_CONSTANT, new JavaFieldStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.EXTENDS_LIST, new JavaClassReferenceListStubSerializer(JavaStubElementTypes.EXTENDS_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.EXTENDS_LIST, new JavaClassReferenceListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.PERMITS_LIST, new JavaClassReferenceListStubSerializer(JavaStubElementTypes.PERMITS_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.PERMITS_LIST, new JavaClassReferenceListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.IMPLEMENTS_LIST, new JavaClassReferenceListStubSerializer(JavaStubElementTypes.IMPLEMENTS_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.IMPLEMENTS_LIST, new JavaClassReferenceListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.THROWS_LIST, new JavaClassReferenceListStubSerializer(JavaStubElementTypes.THROWS_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.THROWS_LIST, new JavaClassReferenceListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.EXTENDS_BOUND_LIST, new JavaClassReferenceListStubSerializer(JavaStubElementTypes.EXTENDS_BOUND_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.EXTENDS_BOUND_LIST, new JavaClassReferenceListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.PROVIDES_WITH_LIST, new JavaClassReferenceListStubSerializer(JavaStubElementTypes.PROVIDES_WITH_LIST));
       registry.registerLightStubFactory(JavaStubElementTypes.PROVIDES_WITH_LIST, new JavaClassReferenceListStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.IMPORT_STATEMENT, new JavaImportStatementStubSerializer(JavaStubElementTypes.IMPORT_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.IMPORT_STATEMENT, new JavaImportStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.IMPORT_STATIC_STATEMENT, new JavaImportStatementStubSerializer(JavaStubElementTypes.IMPORT_STATIC_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.IMPORT_STATIC_STATEMENT, new JavaImportStatementStubFactory());
   
       registry.registerStubSerializer(JavaStubElementTypes.IMPORT_MODULE_STATEMENT, new JavaImportStatementStubSerializer(JavaStubElementTypes.IMPORT_MODULE_STATEMENT));
       registry.registerLightStubFactory(JavaStubElementTypes.IMPORT_MODULE_STATEMENT, new JavaImportStatementStubFactory());
     }
   }
   
   

   . Of course, this class has to be registered in the plugin.xml. Probably, stubbing is an optimization (https://plugins.jetbrains.com/docs/intellij/stub-indexes.html#serializing-data).

With the last IntelliJ update (2025.2), the LSP API is now available to all IDEA users. In other words, we can now use the ultimate platform-specific dependencies such as the com.intellij.platform.lsp.api.
This means we no longer need a third party framework for the IJ client, we can use the bundled support.

For configuration details please also refer to these:
https://blog.jetbrains.com/platform/2025/09/the-lsp-api-is-now-available-to-all-intellij-idea-users-and-plugin-developers/
https://platform.jetbrains.com/t/lsp-api-available-in-intellij-idea-ultimate-2025-2-without-paid-subscription/2284/11

I have experimented today with this and managed to integrate an IJ client with the same LSP server used for a VSCode client. I will post more details once I manage to structure the code better and get rid of some configuration errors.

Florin Eugen Rotaru wrote:

With the last IntelliJ update (2025.2), the LSP API is now available to all IDEA users. In other words, we can now use the ultimate platform-specific dependencies such as the com.intellij.platform.lsp.api.
This means we no longer need a third party framework for the IJ client, we can use the bundled support.

For configuration details please also refer to these:
https://blog.jetbrains.com/platform/2025/09/the-lsp-api-is-now-available-to-all-intellij-idea-users-and-plugin-developers/
https://platform.jetbrains.com/t/lsp-api-available-in-intellij-idea-ultimate-2025-2-without-paid-subscription/2284/11

I have experimented today with this and managed to integrate an IJ client with the same LSP server used for a VSCode client. I will post more details once I manage to structure the code better and get rid of some configuration errors.

As a follow-up, I have noticed that the IntelliJ integration with the Language Server Protocol does not implement all of the LSP features:
https://plugins.jetbrains.com/docs/intellij/language-server-protocol.html#supported-features

For example, the textDocument/foldingRange request is missing, unlike in VSCode (which seems to be more complete).

With the last IntelliJ update (2025.2), the LSP API is now available to all IDEA users. In other words, we can now use the ultimate platform-specific dependencies such as the com.intellij.platform.lsp.api.
This means we no longer need a third party framework for the IJ client, we can use the bundled support.

The Supported IDEs section states that the community edition is NOT supported. That is a problem for us, we can't assume that a commercial version is in use.

Greg Shah wrote:

With the last IntelliJ update (2025.2), the LSP API is now available to all IDEA users. In other words, we can now use the ultimate platform-specific dependencies such as the com.intellij.platform.lsp.api.
This means we no longer need a third party framework for the IJ client, we can use the bundled support.

The Supported IDEs section states that the community edition is NOT supported. That is a problem for us, we can't assume that a commercial version is in use.

Greg, does this answer your question?

From https://blog.jetbrains.com/platform/2025/09/the-lsp-api-is-now-available-to-all-intellij-idea-users-and-plugin-developers/:

Future changes (2025.3): With the new unified distribution, the traditional Community Edition will be sunset. All users will download a single IntelliJ IDEA installer, with IntelliJ IDEA Ultimate features requiring a subscription to be unlocked, but LSP support will remain available to everyone.

The LSP implementation itself stays closed-source and commercial, but we’ll keep it fully accessible for third-party plugins at no charge. This means plugin developers can now target a much broader user base without requiring their users to purchase the IntelliJ IDEA license.

Greg, does this answer your question?

Yes, it does.

Some remaining questions:

• What are the functional limitations of using LSP for IntelliJ? (What IDE features cannot be accessed using LSP alone?)
• Can one write a plugin that accesses both the native/PSI approach and the LSP model? Or do we need to choose one or the other?

JetBrains have a new IDE which is similar to VSCode. It has a smart mode in which it can support many standard languages like Java, Ruby, C++, etc.

However, as this link suggests (https://fleet-asupport.jetbrains.com/hc/en-us/community/posts/26819633205778-Language-Server-Protocol-support) there are no intentions to make it support custom LSP servers.

As for IntelliJ plans to extend their LSP support to more features, I have posted a question on their forum, hopefully we get an answer:
https://platform.jetbrains.com/t/intellij-lsp-features-road-map/2736

My assessment is that it does not make sense to invest in an IntelliJ plugin. Their direction is closed/proprietary and they are the gatekeepers on whether you can add features or not. The inability to implement a custom LSP in their latest codebase is a prime example. At a time when the entire world is implementing an LSP approach, why would you limit yourself to only those LSPs that are provided as part of the IDE. It is a death sentence to the platform, IMO.

Our plan at this time is to move on with a VSCode extension and that support will replace this task.

Hyenk: You've been watching this space as well. What are your thoughts?

Greg, I share your concerns. IntelliJ is indeed a superior Java IDE - the debugger alone is light years ahead of VSCode. But superior tooling doesn't help if the platform limits what we can build on top of it.

Btw. a similar story plays out with AI assistants. JetBrains controls which AI providers are available in IntelliJ, and while they allow some third parties, the selection is curated and those integrations are not first-class citizens in terms of features or UX. JetBrains AI Assistant gets deeper hooks into the editor, better inline placement, tighter PSI (Program Structure Interface - JetBrains' proprietary API for code analysis and manipulation) integration. Third-party AI plugins hit the same ceiling as third-party LSP - they can exist, but they can't match the built-in experience. JetBrains AI Assistant is a paid add-on with their own margins on top of the underlying LLM providers - so the incentive to keep third-party AI integrations second-class is obviously financial, not just technical. In VSCode, Copilot, Cody, Continue, Cursor-style agents all compete on equal grounds through the same extension API.