Skip to content
CAI
Software that uses CAICheck a score

Kotlin/kotlin-lsp

53.2

Adequate · 14 November 2026

28.8k

lines of production code

Kotlin

with TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Extract Variable code action for Kotlin

Users can now extract selected expressions into local variables in Kotlin files via the 'Extract to local variable' refactoring. This new code action allows extracting a single occurrence or all occurrences of an expression, automatically determining the appropriate local scope while preventing extraction into class bodies or file scopes (which would create properties). The refactoring is executed without requiring an active editor and returns navigation ranges to the newly introduced variable.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/extract · high confidence

Add Kotlin call hierarchy support in the LSP implementation

This change introduces the LSKotlinCallHierarchyProvider, enabling call hierarchy navigation (incoming and outgoing calls) for Kotlin files via the Language Server Protocol. The provider integrates with Kotlin's K2 code-insight hierarchy structures to render caller and callee trees, and includes logic to resolve PSI elements for classes, objects, files, properties, constructors, and named functions based on their names and parameter signatures.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/callHierarchy · high confidence

Add Kotlin intention converter for explicit type specification

A new Kotlin intention converter has been added to handle the \SpecifyTypeExplicitlyIntention\ by instantiating it with a false argument, ensuring proper behavior when these intentions are exposed via the LSP interface.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/diagnostics/intentions · high confidence

Add Kotlin semantic token provider with label, named-argument, and constructor support

Introduces the LSKotlinSemanticTokensProvider to enable semantic highlighting for Kotlin files in the Language Server. This implementation maps Kotlin symbols to LSP semantic token types, including specific support for label references (e.g., \@loop\), named argument names (marked with a custom \namedArgument\ modifier), and constructor calls (colored as their containing class). It also handles standard types such as classes, functions, properties, and variables, while migrating the underlying analysis to use \api.session.analyze\.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/semanticTokens · high confidence

Add LSP 'relatedTests' request to navigate between code and tests

The \LSCommonRelatedTestsProvider\ implementation enables the Language Server Protocol 'relatedTests' feature, allowing users to navigate between source code and associated tests (or vice versa) via the LSP. This change introduces the common provider logic that leverages existing test-finding helpers to identify related test classes or source elements based on the cursor position, supporting the Go to Test functionality for languages like Go.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/relatedTests · high confidence

Add LSP Type Definition feature support

This change introduces the core implementation for the LSP Type Definition feature, allowing users to navigate to the type definition of a symbol. It adds the \LSTypeDefinition\ handler which processes \TypeDefinitionParams\ and aggregates results from language-specific providers via \LSTypeDefinitionProvider\. The implementation includes request-level and provider-level tracing for diagnostics and supports partial results for large responses.

api.features/src/com/jetbrains/ls/api/features/typeDefinition · high confidence

Add LSP semantic tokens API and encoding support

The language server now supports the \textDocument/semanticTokens/full\ and \textDocument/semanticTokens/range\ requests, enabling richer code highlighting. This change introduces the core API interfaces (\LSSemanticTokensProvider\) and handlers in the \api.features\ module, along with the necessary infrastructure for token type and modifier definitions (including standard types like \class\, \function\, and modifiers like \declaration\, \static\). It also includes the encoder and decoder logic to serialize and deserialize semantic token data according to the LSP specification, ensuring tokens are correctly formatted for client consumption.

api.features/src/com/jetbrains/ls/api/features/semanticTokens · high confidence

Add common LSP formatting provider

Introduces LSCommonFormattingProvider, a new implementation of LSFormattingProvider that handles both full-document and ranged formatting requests via the Language Server Protocol. This component centralizes formatting logic by leveraging the server's analysis context and file settings to collect text edits through PsiFileTextEditsCollector, ensuring consistent code style application across supported languages.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/formatting · high confidence

Add decompile command descriptor provider

A new command descriptor provider has been added to expose a 'Decompile' command via the LSP server. This command accepts a document URI, validates that its scheme is supported by the decompiler, and invokes the decompiler service to return the source code. The implementation notes that this command predates the \workspace/textDocumentContent\ capability and is retained specifically to support VSCode clients that require the \language\ field in the response.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/decompiler · high confidence

Add decompiler support for JAR and JRT URIs in the Language Server

The Language Server now provides decompiled source code for classes located inside JAR archives and JDK modules (JRT URIs) via the workspace/textDocumentContent capability. This change introduces the LSDecompiler component, which resolves these specific URI schemes, retrieves the underlying PSI file, and returns the decompiled text along with the language identifier, enabling clients to view source for library code that is not present as plain files on disk.

api.features/src/com/jetbrains/ls/api/features/decompiler · high confidence

Add support for the intellij/expressionType request

The server now implements the \intellij/expressionType\ request, allowing clients to retrieve type information for expressions at a specific caret position or selection range. This feature leverages existing IntelliJ Platform \ExpressionTypeProvider\ extensions to determine the type of code under the cursor, supporting both standard hints and advanced dataflow hints when requested. It correctly handles injected languages by resolving the expression within the injected file's scope while returning ranges relative to the host document.

api.features/src/com/jetbrains/ls/api/features/expressionType, features-impl/common/src/com/jetbrains/ls/api/features/impl/common/expressionType · high confidence

Added the \LSRelatedTests\ API and associated data classes (\RelatedTestsParams\, \RelatedTestsResult\) and provider interface (\LSRelatedTestsProvider\) to support the \intellij/relatedTests\ LSP request. This enables the 'Go to Test' functionality by allowing language-specific providers to return related test or code locations based on the caret position.

api.features/src/com/jetbrains/ls/api/features/relatedTests · high confidence

Added Document Highlight API support

The API now includes support for the textDocument/documentHighlight LSP method. This change introduces the LSDocumentHighlightProvider interface and the LSDocumentHighlight entry point, allowing the server to identify and return document highlights for specific text ranges in response to client requests.

api.features/src/com/jetbrains/ls/api/features/documentHighlight · high confidence

Added Java type hierarchy support for subtypes and supertypes

This change introduces the core API components for the Java type hierarchy feature, enabling users to query the inheritance structure of types. The new \LSTypeHierarchy\ object and \LSTypeHierarchyProvider\ interface implement the LSP protocol methods for preparing a type hierarchy item, retrieving its supertypes, and retrieving its subtypes, allowing IDE features to display class inheritance trees.

api.features/src/com/jetbrains/ls/api/features/typeHierarchy · high confidence

Added call hierarchy API support

This change introduces the core API components for call hierarchy functionality within the language server protocol integration. It adds the \LSCallHierarchy\ object, which handles the preparation of call hierarchy items, retrieval of incoming calls, and retrieval of outgoing calls by delegating to language-specific providers. Additionally, it defines the \LSCallHierarchyProvider\ interface, establishing the contract for language implementations to provide call hierarchy data.

api.features/src/com/jetbrains/ls/api/features/callHierarchy · high confidence

Added documentation formatting utilities and settings stub

The documentation module now includes a new settings class that configures how documentation is highlighted and rendered (e.g., enabling code block highlighting and inline code formatting) and a utility function to clean up and align Java/Kotlin-style comment text. These changes provide the foundational formatting logic and configuration for documentation features.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/documentation · high confidence

Added organize imports code action for Kotlin files

The Kotlin language server now supports a code action to organize imports. When triggered on a Kotlin file, this action analyzes the current imports and replaces them with an optimized list, removing unused imports and sorting the remaining ones according to the IDE's standard conventions.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/codeActions · high confidence

Added support for Language Server Protocol inlay hints

The IDE now supports inlay hints provided by language servers. This change introduces the \LSInlayHints\ handler and the \LSInlayHintsProvider\ interface, enabling the collection and resolution of inlay hints (such as parameter names or type information) directly from LSP servers. The implementation leverages the \LspHandlerContext\ to access client capabilities and uses concurrent response handling to efficiently gather hints from multiple providers.

api.features/src/com/jetbrains/ls/api/features/inlayHints · high confidence

Added support for the intellij/superDeclarations LSP request

This change introduces the \intellij/superDeclarations\ LSP extension, enabling IDE features like 'Go to Super' and the gutter icons for 'overrides/implements'. It defines the protocol structures (\SuperDeclarationsParams\, \SuperDeclarationTarget\) and provides a concrete implementation for Kotlin, which uses the K2 analysis API to resolve direct super declarations (overridden methods, super classes/interfaces, and expect/actual relationships) and correctly distinguishes between 'implementing' and 'overriding' based on the target's modality.

api.features/src/com/jetbrains/ls/api/features/superDeclarations, features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/superDeclarations · high confidence

Common type definition provider implementation

A new shared implementation of the type definition provider (LSCommonTypeDefinitionProvider) has been added to the common LSP module. This component centralizes the logic for resolving type declarations by reusing IntelliJ's existing navigation utilities, enabling consistent 'go to type declaration' behavior across different language servers, including Kotlin.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/typeDefinition · high confidence

Implement document and workspace symbol providers with OpenTelemetry tracing

This change introduces the core API components for the \textDocument/documentSymbol\ and \workspaceSymbol\ requests. It adds interfaces (\LSDocumentSymbolProvider\, \LSWorkspaceSymbolProvider\) and their corresponding orchestrators (\LSDocumentSymbols\, \LSWorkspaceSymbols\) which handle concurrent result streaming, result ranking, and limit enforcement. Additionally, it implements the \workspaceSymbol/resolve\ logic, where providers can fill in location details for symbols returned in a workspace search. All symbol operations are now instrumented with OpenTelemetry tracing via \traceProvider\ to monitor provider performance.

api.features/src/com/jetbrains/ls/api/features/symbols · high confidence

Initial Bazel build and ownership configuration for Java Base language server module

The \features-impl/java-base\ location now includes its first Bazel build definition (\BUILD.bazel\), establishing the \java-base\ JVM library and its test variant. This configuration sets the Kotlin compiler to target JVM 25 with language and API versions 2.4, enabling specific experimental features like context parameters and when guards. The module is wired to depend on core language server components (analyzer, API implementations) and platform libraries, while also generating the necessary IntelliJ IDEA module descriptor (\.iml\) and declaring code ownership for the IntelliJ Server Java team.

features-impl/java-base · high confidence

Initial implementation of Language Server Protocol signature help

This change introduces the core API components for signature help support within the Language Server Protocol integration. It adds the \LSSignatureHelpProvider\ interface, allowing language-specific implementations to define how signature help is generated, and the \LSSignatureHelp\ object, which orchestrates the request by locating the appropriate provider based on the document configuration and delegating the call. This enables IDE features to display function parameter hints and documentation when users invoke signature help.

api.features/src/com/jetbrains/ls/api/features/signatureHelp · high confidence

Initial release of the Kotlin by JetBrains VS Code extension

The Kotlin by JetBrains extension for Visual Studio Code is now available in Alpha. It provides IntelliJ-powered code completion, diagnostics, quick fixes, navigation, and refactoring for Kotlin JVM projects (Gradle and Maven). The extension uses the Language Server Protocol and requires VS Code 1.96.0 or later. It is licensed under the JetBrains Free Plugin License, and users must uninstall any previous GitHub-installed Kotlin extension before using this one.

kotlin-vscode · high confidence

Introduce base infrastructure for LSP inlay hints

Added LSInlayHintsProviderBase, a new abstract class that provides the core implementation for fetching, formatting, and resolving inlay hints via the Language Server Protocol. This component establishes the foundation for displaying contextual hints (such as parameter names or type information) in the editor by bridging IntelliJ's declarative inlay API with LSP inlay hint requests and resolutions.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/inlayHints · high confidence

Introduce common definition provider for multi-language support

Added LSCommonDefinitionProvider, a shared implementation of the definition provider that supports multiple languages and target kinds. This component centralizes definition lookup logic by delegating to lsDefinitions within an analysis context, enabling consistent definition resolution across different language servers and reducing code duplication between IDE and analyzer LSP plugins.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/definitions · high confidence

Introduce common implementation provider for LSP

A new \LSCommonImplementationProvider\ class has been added to the common LSP features module. This component provides a unified way to handle implementation requests across different languages supported by the IDE's LSP integration, replacing language-specific implementations with a shared logic that leverages the existing \lsImplementations\ utility.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/implementation · high confidence

Introduce common language server configuration and extension

A new common configuration module is now registered via the \LSCommonServerExtension\, providing a centralized \LSConfigurationPiece\ that bundles shared session components (\LatestCompletionSessionComponent\, \LazyActionSessionComponent\) and command providers (decompile, apply fix, file template interpolation, high watermark, location resolution, and move operations) along with core API and native I/O plugins. Also in this area: 8 commits (1 fix) modifying features-impl/common/src/com/jetbrains/ls/api/features/impl; Support for semantic tokens, highlighting, and navigation inside language injections; Add support for the qualifiedName LSP request.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/configuration · medium confidence · unverified

Introduce language-server.api.features module with Kotlin 2.4 and OpenTelemetry support

A new \language-server.api.features\ module has been added to the build system, providing a dedicated component for language-server API features. This module is configured to use Kotlin 2.4 (language and API versions) and targets JVM 25, with specific compiler options including context parameters and opt-ins for \KaExperimentalApi\ and \KaIdeApi\. It integrates OpenTelemetry for tracing capabilities and depends on core platform modules (core, core-impl, analysis-impl, util, telemetry) as well as language-server specific components (analyzer, api.impl.analyzer, api.core.util) and the \fleet.lsp.protocol\ module. The module is owned by the IntelliJ Server Core team.

api.features · high confidence

Introduce non-interactive extract refactorings via ModCommand plumbing

The extract refactoring feature now supports non-interactive execution for variables, methods, fields, and constants. A new base provider (LSExtractModCommandProviderBase) and action kind definitions (ExtractActionKind) route these refactorings through the shared ModCommand infrastructure, allowing the client to apply the edits directly without requiring an interactive choice menu, provided the client supports the necessary intellijExtensions.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/extract · high confidence

Introduce structured diagnostic provider interfaces and handler

The diagnostics module now exposes \LSDiagnosticProvider\ and \LSCompilationDiagnosticProvider\ interfaces, allowing language-specific implementations to supply diagnostics via a coroutine \Flow\. The \LSDiagnostic\ object implements the LSP document diagnostic request by concurrently invoking these providers, respecting the server's indexing state, and wrapping the calls in OpenTelemetry traces for observability.

api.features/src/com/jetbrains/ls/api/features/diagnostics · high confidence

Introduce unified LSP feature API with telemetry and provider-based architecture

The language server now uses a new, unified API architecture in the \api.features\ module to handle core LSP capabilities such as code actions, completion, diagnostics, definitions, folding ranges, semantic tokens, and symbols. This change replaces previous implementations with a provider-based model where each feature is handled by pluggable providers (e.g., \LSCodeActionProvider\, \LSCompletionProvider\) orchestrated by central managers (e.g., \LSCodeActions\, \LSCompletion\). The new system integrates request-level telemetry tracing via \TelemetryManager\ and \traceProvider\ for all major LSP requests, improving observability. It also introduces a \PsiSerializablePointer\ utility to safely serialize and restore PSI elements across LSP boundaries, ensuring stability during operations like call hierarchy and code actions. This refactoring standardizes how the server processes LSP requests, making it easier to extend and maintain language-specific features. Also in this area: 1 commit (0 fixes) modifying repository; Build tool API moved to dedicated module.

features-impl/java-base/src/com/jetbrains/ls/api/features/impl, repository · medium confidence

Introduces common LSP references provider

Adds LSCommonReferencesProvider, a shared implementation for the textDocument/references LSP feature that works across multiple languages. This provider delegates to the underlying lsReferences function, respects configured target kinds, and returns results as a Kotlin Flow of Location objects.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/references · high confidence

Introduction of Code Lens provider interface for LSP

A new \LSCodeLensProvider\ interface has been added to the LSP API features module to support the LSP \textDocument/codeLens\ request. This interface allows language-specific implementations to emit actionable annotations (code lenses) for documents, with results merged by \LSCodeLens\. The design ensures that all code lenses are fully populated with commands upfront, as the server does not advertise a resolve provider, eliminating the need for additional round-trips to fetch command details.

api.features/src/com/jetbrains/ls/api/features/codeLens · high confidence

Kotlin LSP diagnostics and symbol support

The Kotlin Language Server Protocol integration now provides diagnostics and symbol information. Diagnostics are generated using the Kotlin Analysis API, with specific inspections (such as unused imports and variables) disabled to avoid conflicts in the headless server environment. Document and workspace symbols are now available, mapping Kotlin constructs like classes, functions, properties, and type aliases to their corresponding LSP symbol kinds, including support for filtering workspace symbols by type. Also in this area: 1 commit (0 fixes) modifying features-impl/kotlin/psi/src/com/jetbrains/ls/api/features/impl, features-impl/kotlin/src/com/jetbrains/ls/api/features/impl.

features-impl/kotlin/psi/src/com/jetbrains/ls/api/features/impl · medium confidence · unverified

Kotlin completion support added to the Language Server

The Language Server now provides code completion for Kotlin files. This change introduces the Kotlin-specific completion provider and item kind provider, enabling autocomplete suggestions for Kotlin constructs such as classes, functions, properties, and operators within the IDE.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/completion · high confidence

Kotlin language server workspace import and export capabilities

The Kotlin language server now supports importing and exporting workspace configurations. This change introduces a new \WorkspaceImportLanguageServerExtension\ that registers drivers for Gradle, Maven, JPS, and JSON to handle workspace imports, and adds an \Export Workspace\ command that allows users to export the current workspace structure to a JSON file.

features-impl/kotlin · high confidence

Kotlin-specific rename refactoring implementation for LSP

The Kotlin language support for the Language Server Protocol now includes dedicated rename providers. A new \LSKotlinRenameProvider\ handles identifier and class renaming for Kotlin files, including logic to strip backticks from identifiers and locate target classes within Kotlin source files. Additionally, a new \LSJvmRenameDirectoryProvider\ enables directory renaming for Kotlin projects, allowing users to rename packages or directories via the LSP \textDocument/rename\ and \workspace/willRenameFiles\ requests, with proper validation to prevent overwriting existing files.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/rename · high confidence

New @jetbrains/vscode-testing package for language-agnostic test integration

This change introduces the \@jetbrains/vscode-testing\ package, providing a shared framework for integrating test runners into the VS Code Testing view. It includes a \TestLanguage\ interface for implementing discovery and launches, an LSP-based discovery mechanism (\lspDiscovery\), a debug adapter runner (\debugAdapterRunner\) for executing test processes, and a parser for TeamCity service messages to interpret test results. The package also handles test tree management, coverage reporting, and file watching to keep the test view synchronized with the workspace. Also in this area: Support for suiteTreeStarted messages and improved navigation for parameterized test invocations.

vscode-testing/src · high confidence

The server now provides two new code lens providers. First, it surfaces Run and Debug lenses above JVM main entry points, passing the module's build tool (Gradle or Maven) to the client so it can select the correct launch configuration type. Second, it exposes navigation lenses for related items defined by user plugins (such as DevKit class-to-XML links), mirroring the IDE's gutter icons by invoking a client-side navigation command that opens the target or shows a popup for multiple targets.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/codeLens · high confidence

New JVM test runner integration for VS Code

This change introduces a new testing module for the \vscode-jvm-testing\ package, enabling JVM-based tests (Java and Kotlin) to be discovered and executed directly within the VS Code Testing view. The implementation adds a \JvmTestLanguage\ provider that communicates with the IntelliJ LSP server to discover tests and resolve launch configurations, handling both run and debug profiles. It includes a \JvmTestBuilds\ component that ensures the relevant module is built on the server before test execution, streaming build output to the test results and gracefully handling build failures or cancellations. The module also defines the necessary protocol interfaces for test discovery and launch requests, and registers the testing controller to appear in the VS Code UI. Also in this area: 2 commits (0 fixes) modifying vscode-jvm-testing; 1 commit (0 fixes) modifying vscode-extension-core, vscode-jvm-testing.

vscode-jvm-testing · medium confidence · unverified

New LSP code action and references provider APIs

The language server now exposes new extension points for code actions and references, allowing language plugins to integrate their quick-fixes and reference finding logic via the \LSCodeActionProvider\ and \LSReferencesProvider\ interfaces. Code actions are now filtered by kind to match client requests, and a base \LSSimpleCodeActionProvider\ class simplifies implementation by handling context, read actions, and command execution. This change enables features like 'Organize Imports' and inspection suppressions to be offered as source actions through the LSP protocol.

api.features/src/com/jetbrains/ls/api/features/codeActions · high confidence

New LSP document and range formatting API

The LSP integration now exposes a new formatting feature area. This change introduces the \LSFormattingProvider\ interface, which defines the contract for language-specific formatting logic, and the \LSDocumentFormatting\ object, which implements the server-side handlers for document and range formatting requests. Users can now rely on these new API components to integrate custom formatting providers into the language server.

api.features/src/com/jetbrains/ls/api/features/formatting · high confidence

New common diagnostics and code-action providers for inspections, syntax errors, and injected languages

This change introduces a shared diagnostics module that provides a unified way to report diagnostics and offer quick-fixes across the LSP server. It adds \LSCommonInspectionDiagnosticProvider\ and \LSCommonInspectionFixesCodeActionProvider\ to handle inspection diagnostics and their associated ModCommand-based quick-fixes, including a blacklist mechanism to filter out problematic fixes. It also adds \LSCommonInspectionSuppressionCodeActionProvider\ to expose suppression actions (e.g., 'Suppress for statement') for inspection warnings. Furthermore, it introduces \LSCommonInjectionInspectionDiagnosticProvider\ and \LSCommonInjectionSyntaxErrorDiagnosticProvider\ to report diagnostics for injected languages (like SQL in HTML) within host files, and \LSCommonSyntaxErrorDiagnosticProvider\ for general syntax errors. The module includes supporting data classes (\DiagnosticData\, \SimpleDiagnosticData\) and a \Blacklist\ utility to manage excluded quick-fix implementations.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics · high confidence

New document command executor for applying workspace edits

A new \LSDocumentCommandExecutor\ interface has been introduced in the language server API features module. This component enables the execution of commands that modify document content by generating text edits and applying them via the LSP \ApplyWorkspaceEdit\ request, allowing users to see immediate changes reflected in their open documents.

api.features/src/com/jetbrains/ls/api/features/commands/document · high confidence

New extensible configuration API for language server features

The \api.features\ module now exposes a new set of Kotlin classes and interfaces that allow plugins to declaratively configure language server capabilities. This includes \LSConfiguration\ and \LSConfigurationEntry\ types to register build tool drivers, launch contributors, workspace/session components, and custom indexing file systems. It also introduces \LanguageServerExtension\ for plugins to provide their configuration pieces and \LSConfigurationData\ to decode initialization options from clients, enabling more structured and extensible language server setups.

api.features/src · high confidence

New headless task support for language server progress

A new LSHeadlessTaskSupport class has been added to handle progress reporting in headless language server environments. This implementation provides simplified versions of background and modal progress tasks that do not account for UI modality, ensuring that long-running language server operations can report progress correctly even when no graphical interface is present.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/progress · high confidence

New typed command API for Language Server features

The \api.features\ module now includes a new command execution framework (\LSCommand\, \LSCommandDescriptor\, \LSCommandExecutor\, and \LSTypedCommand\) that allows language server features to register commands with strongly-typed arguments and results. This change introduces a structured way to define command titles and executors, replacing ad-hoc command handling with a typed, JSON-serializable interface that simplifies the implementation of new LSP commands.

api.features/src/com/jetbrains/ls/api/features/commands · high confidence

New utility classes for PSI serialization, range filtering, and OpenTelemetry tracing

The \api.features\ module now includes three new utility files to support language server operations. \PsiSerializablePointer\ introduces a serializable representation of PSI elements and files, enabling the persistence and restoration of pointers across sessions. \ranges.kt\ adds a helper to retrieve non-whitespace child elements from a PSI file, optionally filtered by a specific text range. \tracing.kt\ implements OpenTelemetry integration by providing \traceProvider\ functions that wrap provider result flows and blocks in spans, recording exceptions and propagating context via coroutine context elements.

api.features/src/com/jetbrains/ls/api/features/utils · high confidence

New workspace reload and build task infrastructure

The extension now includes a new mechanism to automatically reload the workspace when the \.vscode/settings.json\ file is saved, giving users the choice to reload immediately, be prompted, or never reload via a new setting. Additionally, a dedicated build task provider has been introduced to handle pre-launch compilation for Java launches, ensuring the correct module is built before execution. This build system also features improved Windows command-line handling to correctly resolve build tools and paths, and a new DocumentParser class utilizes web-tree-sitter to parse documents for syntax-aware features.

vscode-extension-core/src · high confidence

Run code lenses for Kotlin main functions

Users can now see and use Run code lenses in Kotlin files. This change introduces a specific provider that detects \main\ entry points—whether defined as top-level functions or within objects/companion objects—and exposes them via the Language Server Protocol, enabling direct execution from the editor.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/debug · high confidence

Server-side location resolution command registration

The IDE now registers a command descriptor for the LSP 'resolveLocation' command, enabling server-side resolution of code locations. This change introduces the LSResolveLocationCommandDescriptorProvider which binds the command to the LSServer execution context, allowing the backend to handle location resolution requests directly.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/location · high confidence

Support for 'Show Inherited' in Structure View via LSP

The LSP now supports the \intellij/inheritedMembers\ request, enabling the IDE's Structure View to display inherited members for Kotlin classes. This change introduces the API contract (\LSInheritedMembersProvider\) and a concrete Kotlin implementation that calculates inherited members by comparing the class's member scope against its declared scope, excluding overrides and classes, and grouping results by their supertype. Users can now see inherited members in the Structure View when clicking on a class name or base class reference.

api.features/src/com/jetbrains/ls/api/features/inheritedMembers, features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/inheritedMembers · high confidence

Support for Kotlin compiler diagnostics and quick fixes in the LSP

The LSP now exposes Kotlin compiler diagnostics and their associated quick fixes to clients. A new diagnostic provider collects compiler errors for Kotlin files and serializes them for transmission. A corresponding code action provider allows clients to list available quick fixes; for clients supporting lazy intentions, it returns lightweight command descriptors that compute the actual edits only when the user selects a fix, while other clients receive eager fix listings. This enables IDE clients to show and apply Kotlin compiler fixes directly through the Language Server Protocol.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/diagnostics/compiler · high confidence

Support for Type Hierarchy navigation in Kotlin via LSP

The Language Server Protocol now supports Type Hierarchy requests for Kotlin files. This change introduces the LSKotlinTypeHierarchyProvider, enabling users to navigate the inheritance structure (supertypes and subtypes) of Kotlin classes and objects, as well as Java classes referenced from Kotlin. The implementation handles mixed Kotlin/Java inheritance scenarios and correctly identifies class hierarchies at the caret position.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/typeHierarchy · high confidence

Support for batch code inspections via LSP

Users can now trigger batch inspections on files through the LSP protocol. This change introduces a new batch inspection provider that runs local inspections (excluding injected-language inspections) in a non-on-the-fly mode, returning diagnostic results without immediate fixes. The implementation supports inspection profiles without scopes and allows controlling profile import via initialization options, enabling more efficient analysis of larger codebases compared to real-time checks.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/inspectCode · high confidence

Support for batch code inspections via intellij/inspectCode

The language server now supports the \intellij/inspectCode\ and \intellij/inspections\ wire types, enabling clients to run batch inspections over files or directories. This change introduces the \LSBatchInspectionProvider\ interface and associated data classes (\InspectCodeParams\, \InspectCodeFileReport\, \InspectionInfo\) to handle batch analysis requests, stream progress reports, and return diagnostic results without registering fixes, allowing clients to retrieve fixes via \textDocument/codeAction\ instead.

api.features/src/com/jetbrains/ls/api/features/inspectCode · high confidence

Support for inline variable and method code actions

The inline feature now exposes specific action kinds for inlining variables and methods, enabling users to trigger these refactorings via hot keys. This change introduces the \InlineActionKind\ object which defines \refactor.inline.variable\ and \refactor.inline.method\ as distinct code action types, allowing the IDE to identify and offer these specific inline operations to the user.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/inline · high confidence

Support for intellij/qualifiedName request in Copy Reference

The IDE now supports the \intellij/qualifiedName\ LSP request, enabling the Copy Reference feature to retrieve the fully qualified name for symbols (such as \pkg.Foo\#bar(int)\ for Java methods) at a specific position in a file. This is implemented via a new \LSQualifiedNameProvider\ interface and a common provider that leverages IntelliJ's \FqnUtil\ to resolve the qualified name from PSI elements, ensuring compatibility with the Copy Reference clipboard action.

api.features/src/com/jetbrains/ls/api/features/qualifiedName, features-impl/common/src/com/jetbrains/ls/api/features/impl/common/qualifiedName · high confidence

Support for interpolating file templates via LSP command

The language server now exposes the 'interpolateFileTemplate' command, allowing clients to process text using IntelliJ's file template engine. This enables the resolution of standard template variables (such as file name, path, and project name) within provided text, mirroring the templating mechanism used in the IntelliJ IDE.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/fileTemplates · high confidence

Support for moving Kotlin packages and directories via LSP

Users can now move Kotlin files and directories through the Language Server Protocol. This change introduces the LSPMoveKotlinFileProcessor, which bridges the LSP interface with the Kotlin K2 refactoring engine to handle package and directory moves, ensuring proper analysis permissions are applied during the operation.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/processors · high confidence

Support for renaming and moving files and directories in the project view

The LSP API now supports file and directory renaming and moving operations within the project view. This change introduces new interfaces (LSRenameProvider, LSRenameDirectoryProvider, LSMoveProvider) and a central dispatcher (LSRename) that routes textDocument/rename and textDocument/renameFiles requests to language-specific implementations. Users can now rename single files or directories, as well as move files and directories (including combinations of both) to new locations, with the system automatically detecting the operation type and delegating to the appropriate provider.

api.features/src/com/jetbrains/ls/api/features/rename · high confidence

Support for resolving package definitions via LSP

Users can now resolve definitions for Kotlin packages using the Language Server Protocol. This change introduces a new definition provider that handles requests for package symbols, allowing IDEs to navigate to the directory containing the package source files. The implementation uses the Kotlin stub index to locate package directories, filtering out library sources to focus on project code.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/definitions · high confidence

Support for textDocument/foldingRange via new provider interface

The API now includes a new LSFoldingRangeProvider interface in the folding range feature module, enabling the implementation of the LSP textDocument/foldingRange capability. This interface allows language servers to define how folding ranges are computed for specific documents, integrating with the existing LSP handler context and server infrastructure.

api.features/src/com/jetbrains/ls/api/features/foldingRange · high confidence

Architecture

Establishes code ownership and build configuration for VS Code extension modules

The VS Code extension core and Kotlin language modules now include explicit code ownership declarations and standardized TypeScript build configurations. An OWNERSHIP file has been added to both locations to define the responsible team, while new tsconfig.json files configure the TypeScript compiler to extend the base configuration, restrict types to Node.js, and exclude output directories. Additionally, .gitignore files have been created to prevent build artifacts in the 'out/' directory from being committed.

vscode-extension-core, vscode-language-kotlin · high confidence

Introduce Bazel build and ownership for the common language-server features implementation

The \features-impl/common\ location now includes a \BUILD.bazel\ file that defines the \language-server.api.features.impl.common\ module, establishing its dependency graph on platform libraries (such as \intellij.platform.core\, \intellij.platform.analysis\, and \kotlinx\ libraries) and language-server components (like \language-server.analyzer\ and \fleet.lsp.protocol\). This build definition also configures Kotlin compiler options, including the \KaExperimentalApi\ and \KaIdeApi\ opt-ins, and sets the JVM target to 25. An \OWNERSHIP\ file is added to assign the module to the 'IntelliJ Server Core' team, and an \.iml\ file is generated to support IDE integration.

features-impl/common · high confidence

Behavioural changes

1 commit (0 fixes) modifying api.features/src/com/jetbrains/ls/api/features/inlineDocumentation, features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/documentation

A change to existing behaviour in api.features/src/com/jetbrains/ls/api/features/inlineDocumentation, features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/documentation — 1 commit, 2 files: “LSP-2198 \[lsp\] add intellij/inlineDocumentation and intellij/resolveDocLink requests”.

api.features/src/com/jetbrains/ls/api/features/inlineDocumentation, features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/documentation · medium confidence · unverified

1 commit (0 fixes) modifying api.features/src/com/jetbrains/ls/api/features/stackTrace, vscode-testing

A change to existing behaviour in api.features/src/com/jetbrains/ls/api/features/stackTrace, vscode-testing — 1 commit, 4 files: “\[lsp\] LSP-2321 Navigate from Java stacktrace to precise location in code”.

api.features/src/com/jetbrains/ls/api/features/stackTrace, features-impl/common/src/com/jetbrains/ls/api/features/impl/common/stackTrace · medium confidence · unverified

12 commits (1 fix) modifying features-impl/kotlin/psi

A change to existing behaviour in features-impl/kotlin/psi — 12 commits (1 fix), 2 files: “\[build\] Update build files (IJI-3451)”; “misc lsp: Move language-specific LSP customization code to modules shared between IDE and analyzer”; “misc lsp: reuse workspace-symbols implementation between LSP and intellix plugin”; and 9 more.

features-impl/kotlin/psi · medium confidence · unverified

2 commits (0 fixes) modifying features-impl/common/src/com/jetbrains/ls/api/features/impl/common/inlineDocumentation

A change to existing behaviour in features-impl/common/src/com/jetbrains/ls/api/features/impl/common/inlineDocumentation — 2 commits, 1 file: “LSP-2198 \[lsp\] add intellij/inlineDocumentation and intellij/resolveDocLink requests”; “LSP-2198 \[lsp\] render inline documentation without editor colors”.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/inlineDocumentation · medium confidence · unverified

2 commits (0 fixes) modifying features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/language

A change to existing behaviour in features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/language — 2 commits, 1 file: “LSP-81 \[lsp\] serve definition and hover inside decompiled library classes”; “cleanup \[lsp\]: remove "common" package prefix from Kotlin implementation”.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/language · medium confidence · unverified

4 commits (0 fixes) modifying buildtool.api

A change to existing behaviour in buildtool.api — 4 commits, 9 files: “\[build\] Update build files (IJI-3451, MRI-5748)”; “IJPL-259329 Bump Kotlin language and API version to 2.5”; “LSP-1982: moved build tool api into new module”; and 1 more.

buildtool.api · medium confidence · unverified

4 commits (0 fixes) modifying features-impl/common/src/com/jetbrains/ls/api/features/impl/common/foldingRange

A change to existing behaviour in features-impl/common/src/com/jetbrains/ls/api/features/impl/common/foldingRange — 4 commits, 1 file: “LSP-655: Support textDocument/foldingRange”; “LSP-81 \[lsp\] serve definition and hover inside decompiled library classes”; “\[java\] IDEA-385880 Split javafolding into backend and frontend”; and 1 more.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/foldingRange · medium confidence · unverified

4 commits (0 fixes) modifying features-impl/common/src/com/jetbrains/ls/api/features/impl/common/highwatermark

A change to existing behaviour in features-impl/common/src/com/jetbrains/ls/api/features/impl/common/highwatermark — 4 commits, 1 file: “LSP-1261 Highwatermark commands in LSP indexing”; “LSP-1261 i18n for added commands”; “LSP-2007 answer the filesystem barrier with a fence instead of reading a watermark file”; and 1 more.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/highwatermark · medium confidence · unverified

7 commits (0 fixes) modifying api.features/src/com/jetbrains/ls/api/features/references

A change to existing behaviour in api.features/src/com/jetbrains/ls/api/features/references — 7 commits, 3 files: “\[lsp\] use using context parameters instead of deprecated context parameters in code”; “cleanup \[lsp\]: use named args when calling streamResultsIfPossibleOrRespondDirectly()”; “\[lsp\] pass \LspHandlerContext\ around requests so it's possible to access lsp client from the request”; and 4 more.

api.features/src/com/jetbrains/ls/api/features/references · medium confidence · unverified

7 commits (0 fixes) modifying features-impl/common/src/com/jetbrains/ls/api/features/impl/common/callHierarchy

A change to existing behaviour in features-impl/common/src/com/jetbrains/ls/api/features/impl/common/callHierarchy — 7 commits, 2 files: “LSP-1026 \[lsp\] key call hierarchy items by declaration pointer”; “\[Java, Kotlin\] LSP-515 LSP-487 Refactoring implementation for kotlin hierarchy support”; “\[Java, Kotlin\] LSP-2075: support call references in test sources”; and 4 more.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/callHierarchy · medium confidence · unverified

8 commits (0 fixes) modifying api.features/src/com/jetbrains/ls/api/features/partialResults

A change to existing behaviour in api.features/src/com/jetbrains/ls/api/features/partialResults — 8 commits, 1 file: “LSP-1964 \[lsp\] send URI-only locations in workspaceSymbol/resolve”; “\[lsp\] use using context parameters instead of deprecated context parameters in code”; “LSP-2170 \[lsp\] Create inspection submenu; move suppressions there”; and 5 more.

api.features/src/com/jetbrains/ls/api/features/partialResults · medium confidence · unverified

8 commits (1 fix) modifying features-impl/common/src/com/jetbrains/ls/api/features/impl

A change to existing behaviour in features-impl/common/src/com/jetbrains/ls/api/features/impl — 8 commits (1 fix), 14 files: “\[Analyzer\] LSP-2192 Inject proper settings when regsitering inspection profile in datagrip lsp”; “IJ-CR-233992 \[lsp\] LSP-2288 Surround With for Java and Kotlin”; “LSP-2367 \[java-inspections\] Edit inspection options in LSP”; and 5 more.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/surroundWith · medium confidence · unverified

8 commits (1 fix) modifying features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/inline

A change to existing behaviour in features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/inline — 8 commits (1 fix), 1 file: “refactoring \[Analyzer\]: use runReadActionInBgt for processing refactoring conflicts inside clients”; “LSP-845 \[kotlin\] add Inline Variable code action”; “LSP-1493 \[lsp\] stamp eager fix commands and version every ModCommand edit”; and 5 more.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/inline · medium confidence · unverified

Add OpenTelemetry tracing to the Go-to-Implementation feature

The Go-to-Implementation feature now instruments its execution with OpenTelemetry tracing. The new LSImplementation component wraps provider calls in telemetry spans, allowing users to monitor performance and trace execution flow for implementation lookups.

api.features/src/com/jetbrains/ls/api/features/implementation · high confidence

Blacklist specific Kotlin quick fixes in LSP

The LSP server now explicitly blocks several Kotlin quick fixes from being offered to users. Specifically, the 'MoveFileToPackageFix' and 'ChangePackageFix' associated with PackageDirectoryMismatchInspection, as well as 'SafeDeleteFix' and 'RenameIdentifierFix', are added to the quick fix blacklist. This prevents the server from attempting to instantiate or apply these fixes, addressing issues where they were causing errors or were unsuitable for the LSP environment.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/diagnostics · high confidence

Decoupling DAP support from Java/Kotlin-specific implementations

The Debug Adapter Protocol (DAP) feature is now decoupled from the Java and Kotlin language server implementations. A new \DapPluginsProvider\ class has been introduced in the API module to manage DAP plugin descriptors independently, and the Java base feature module registers its extension via the standard service loader mechanism. This structural change allows DAP capabilities to be configured and extended without being tightly bound to the Java/Kotlin language server codebase.

api.features/src/com/jetbrains/ls/api/features/dap, features-impl/java-base/resources/META-INF · medium confidence

The language server's textDocument/definition handler has been updated to return LocationLink objects instead of plain Location objects for clients that support definition links. This change includes the origin selection range in the response, allowing clients to highlight the specific part of the source text that triggered the definition request. The implementation uses context parameters to access the server, configuration, and handler context, and integrates with OpenTelemetry tracing for the definition provider.

api.features/src/com/jetbrains/ls/api/features/definition · high confidence

Deprecation of kotlin-lsp scripts and introduction of intellij-server launchers

The \kotlin-lsp.sh\ and \kotlin-lsp.cmd\ scripts are now deprecated and warn users to switch to the new \bin/intellij-server\ (or \bin/intellij-server.exe\) launchers. The shell and batch scripts now simply delegate to these new binaries, which are the recommended entry points for the LSP. Additionally, this change introduces updated setup documentation and configuration examples for Helix, Neovim, Emacs (both lsp-mode and the built-in eglot), and Zed to align with the new launcher structure.

scripts · high confidence

Hover feature now receives LspHandlerContext for client access

The hover API implementation has been updated to pass the LspHandlerContext through the call chain. Both the LSHover entry point and the LSHoverProvider interface now explicitly accept this context, enabling hover providers to access the LSP client directly during request processing.

api.features/src/com/jetbrains/ls/api/features/hover · high confidence

Improved error handling and API integration for Kotlin move refactoring

The Kotlin move refactoring handler has been updated to use the new K2 move model and processor, ensuring better alignment with the underlying refactoring infrastructure. Additionally, the implementation now provides more specific error messages when the move operation fails, improving the user experience by clarifying why a move might not be possible.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/move · high confidence

Kotlin language server configuration and implementation migrated to new API

The Kotlin language server setup has been restructured to use the new analyzer API. This includes a new \KotlinFirCacheImpl\ for managing LL FIR session caches, a \KotlinFileForModificationFactory\ for creating modifiable PSI files, and a consolidated \LSKotlinLanguageConfiguration\ that registers all Kotlin-specific providers (completion, diagnostics, refactoring, hierarchy, etc.) and workspace components. The configuration also defines the necessary plugin modules and dependencies for the Kotlin feature.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/configuration · high confidence

Kotlin signature help now supports context parameters

The Kotlin Language Server now provides signature help that includes context parameters (such as receiver types or lambda arguments) in addition to standard function arguments. This change is implemented in the new LSKotlinSignatureHelpProvider, which integrates Kotlin's high-level parameter info handlers to ensure that signature information accurately reflects the full call context, improving the clarity of parameter hints for users.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/signatureHelp · high confidence

Kotlin symbol providers now use language-specific customizers

The Kotlin Language Server Protocol implementation for document and workspace symbols has been refactored to use dedicated customizers. New provider classes (LSKotlinDocumentSymbolProvider and LSKotlinWorkspaceSymbolProvider) now delegate to language-specific customizers (LSKotlinDocumentSymbolCustomizer and LSKotlinWorkspaceSymbolCustomizer) instead of generic base implementations. Additionally, a new kinds.kt file defines how Kotlin PSI elements map to LSP SymbolKind values, ensuring correct symbol type reporting for classes, interfaces, enums, functions, properties, and other Kotlin constructs.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/symbols · high confidence

New Kotlin hover implementation with improved documentation rendering

The \textDocument/hover\ request for Kotlin now uses a new implementation (\LSKotlinHoverProvider\) that leverages the Kotlin Analysis API. This change improves hover content by properly rendering bounded type parameters with comma-separated bounds, resolving KDoc links to proper URIs for navigation, and handling error types in code more gracefully. It also ensures hover analysis runs in its own session to avoid exceptions related to expect/actual resolution.

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/hover · high confidence

New LSP completion API with context-aware providers and tracing

The completion feature now uses a new API layer that passes \LspHandlerContext\ to completion providers, enabling access to the LSP client state during request handling. This change introduces \LSCompletionProvider\ interfaces that support both providing and resolving completion items, with built-in telemetry tracing via \traceProvider\ for monitoring provider performance. The system also adds \LSCompletionItemKindProvider\ for language-specific completion item kind resolution and \ResolveDataWithConfigurationEntryId\ to properly bind resolve requests with their original completion items.

api.features/src/com/jetbrains/ls/api/features/completion · high confidence

New LSP move refactoring implementation with improved error handling

The move refactoring feature now uses a new \LSCommonMoveProvider\ that supports moving both files and directories, including the automatic creation of destination directories if they do not exist. The implementation provides clearer, user-visible error messages for common issues such as destination directories not being found, files already existing at the target location, or duplicate file names. A generic fallback handler ensures that mixed file types (e.g., Java and text files) can be moved together.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/move · high confidence

New common hover provider implementation for LSP

The hover feature now uses a new shared base implementation (LSHoverProviderBase) that handles the core logic for the textDocument/hover request, including finding documentation targets at a cursor position and formatting results as Markdown. This change introduces a common utility for generating multi-line code blocks in Markdown and establishes a language extension point (ls.markdownDocProvider) for language-specific documentation providers, replacing previous copy-pasted code with a unified module shared between the IDE LSP plugin and the analyzer LSP.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/hover · high confidence

New key-handling logic for Kotlin strings and delimiters

The Kotlin language extension now includes a dedicated key handler that improves how the editor processes quotes, brackets, and Enter keys. It correctly handles triple-quoted strings by overtyping closing delimiters and inserting quotes within content, fixes Enter key behavior inside string interpolations and empty when blocks, and ensures proper auto-completion for parentheses, brackets, and braces.

vscode-language-kotlin/src · high confidence

New localized message bundle for LSP server commands and errors

The LSP server now uses a dedicated message bundle (LspServerBundle.properties) to provide localized strings for user-facing content. This includes error messages for build and launch failures (Gradle, Maven, Bazel, JPS), refactoring issues (move, inline method/variable), and data source management, as well as titles and labels for various LSP commands such as code lenses, quick fixes, and MCP server controls. Also in this area: 4 commits (0 fixes) modifying api.features; 2 commits (1 fix) modifying api.features; Semantic tokens now include injected language regions; Spring Tools commands and workspace import lifecycle events; Unified build tool registration and new build commands.

api.features/resources/messages · medium confidence · unverified

Refactor language configuration API with new data classes

The language server API has been refactored to improve type safety and default handling. The previous \LSLanguageConfiguration\ class has been replaced by \LSConfigurationPiece\, which now provides default empty lists for its \entries\, \plugins\, and \languages\ fields, simplifying instantiation. Additionally, a new \LSLanguage\ class has been introduced to represent language definitions, including a set of file extensions and utility methods to match document URIs against these extensions.

api.features/src/com/jetbrains/ls/api/features/language · high confidence

Refactor text edit collection to use coroutine-based EDT execution

The \PsiFileTextEditsCollector\ has been rewritten to use a coroutine-based approach, replacing the previous implementation. It now explicitly manages execution on the Event Dispatch Thread (EDT) using \withContext(Dispatchers.EDT)\ and \edtWriteAction\, ensuring thread safety for PSI modifications. The collector also adopts \runCatching { ... }.getOrHandleException { ... }\ for error handling within the command execution block, improving robustness when applying text modifications.

api.features/src/com/jetbrains/ls/api/features/textEdits · high confidence

Refactored document and workspace symbol providers to use Flow and context receivers

The symbol provider implementations in the common LSP module have been refactored to use Kotlin Flow for asynchronous result emission and context receivers for cleaner access to the LSServer and handler context. LSDocumentSymbolProviderBase and LSWorkspaceSymbolProviderBase now serve as shared abstract bases, with the latter specifically handling multiple contributors by launching them concurrently and ensuring that a failure in one contributor does not prevent results from other contributors from being returned.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/symbols · high confidence

Refactored rename logic into a shared base provider with prepareRename support

The rename implementation has been consolidated into a new shared base class (LSRenameProviderBase) and utility module, replacing previous language-specific or scattered implementations. This change introduces support for the textDocument/prepareRename LSP method, allowing clients to validate rename availability and receive the exact identifier range before execution. It also standardizes file renaming (workspace/willRenameFiles) by extracting name-change logic into dedicated utilities, ensuring consistent handling of file and directory renames across Java and Kotlin.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/rename · high confidence

Refactoring execution and error handling logic moved to shared Kotlin utilities

The implementation for executing refactoring processors and handling their results has been consolidated into a new shared Kotlin file (\refactoringUtils.kt\). This change introduces a \doRefactoring\ function that manages the refactoring lifecycle, including executing the processor on the EDT, computing text edits, and filtering out file changes that are already handled by the client (such as those in \workspace/willRenameFiles\). It also centralizes error handling, ensuring that refactoring failures are properly reported to the LSP client via error notifications and exceptions.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/processors · high confidence

Refactoring utilities and safe document display for LSP clients

This change introduces a new base class for LSP refactorings that supports both native IDE menus (for clients with intellijExtensions) and standard code actions, while ensuring that post-refactoring navigation via window/showDocument only occurs if the client explicitly declares support for it. It also adds utility functions to safely create destination directories during move operations and to find the element under the caret, improving the reliability of refactorings like move and inline method when interacting with diverse LSP clients.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/utils · high confidence

Register common language server extension and declare module dependencies

The common resources module now explicitly registers the \LSCommonServerExtension\ via the Java SPI mechanism, making common language server features available to the platform. Additionally, a new plugin descriptor declares a comprehensive set of runtime dependencies, including core IDE platforms, analysis tools, telemetry libraries, and workspace storage modules, ensuring the common language server features have access to the necessary underlying infrastructure.

features-impl/common/resources · high confidence

Registration of the common Language Server API plugin

The common Language Server API is now explicitly registered as a plugin with the ID 'ls.common.api'. This registration maps the 'language-server.api.features.impl.common' module to its corresponding XML configuration file, ensuring the plugin is correctly loaded and initialized within the runtime environment.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/api · high confidence

Support for document highlighting in injected language fragments

The document highlight feature now correctly identifies and highlights references to symbols located within injected language fragments (such as SQL or JavaScript embedded in other files). The new \LSCommonDocumentHighlightProvider\ resolves symbols across the host file and its injections, ensuring that read/write access detection and reference highlighting work accurately even when the target code is part of a nested or injected context.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/documentHighlight · high confidence

Unified ModCommand-based quick fixes and code actions for LSP

The LSP server now uses a single, unified provider to handle quick fixes and code actions via the \applyModCommand\ and \resolveModCommand\ commands. This change replaces previous ad-hoc implementations with a common \ModCommandData\ serialization layer, allowing the server to support both eager execution (for clients without \lazyIntentions\) and lazy resolution (for clients that declare \lazyIntentions\). It also introduces support for \ModChooseAction\ trees by flattening choice branches into individual fixes for clients that do not support \intellijExtensions\, ensuring consistent behavior across different LSP clients like VS Code and IntelliJ.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/modcommands · high confidence

Unified completion command handling and sorting in the LSP common module

The completion logic in the common LSP module has been refactored to standardize how completion items are sorted and how complex commands (such as choice selections and templates) are converted into LSP responses. A new \CompletionSortingUtil\ ensures items are sorted by index using zero-padded strings to match LSP \sortText\ expectations. The \ModCompletionCommandConverter\ now handles the unwrapping of \ModChooseAction\ commands, expanding choices into separate completion items for generic clients while deferring them for clients that support IntelliJ extensions. Additionally, \LSCompletionProviderHelper\ and \LSAnyCompletionItemKindProvider\ centralize the creation of completion lists and kind detection, ensuring consistent behavior across different language servers.

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/completion · high confidence

VS Code extension activation flow restructured with geo-restriction and conflict handling

The VS Code extension's activation logic has been reorganized to enforce specific preconditions before starting the language server. The extension now checks for geo-restrictions and conflicts with the legacy Kotlin extension first, returning early if either condition is met. Activation is further gated by policy consent (EULA acceptance) and ensures the server download completes before proceeding. The entry point now delegates core logic to shared modules (\@jetbrains/vscode-extension-core\ and \@jetbrains/intellij-vscode-extension-policy\), enabling features like DAP server support, decompiler integration, and status bar contributions within a unified activation sequence.

kotlin-vscode/src · high confidence

Vendored tree-sitter-kotlin WASM grammar artifact

The repository now includes a pre-built tree-sitter-kotlin.wasm file and documentation for its origin (a fork of fwcd/tree-sitter-kotlin). This change supports the internal LSP-1410 effort to use a WASM-based grammar build, decoupling the grammar artifact from the explicit npm dependency previously managed.

vscode-language-kotlin/grammars · medium confidence

Test coverage

Added Bazel build configuration for language-server test module; Added test infrastructure for mocking the VS Code API; Added tests for archive extraction logic; Added unit tests for semantic tokens encoding and text edits computation; Migrate Kotlin tokenization tests to textmate-grammar-test.

Dependencies

New Kotlin VS Code extension and workspace-import test fixtures

The Kotlin by JetBrains VS Code extension is introduced with a new package.json defining its metadata, dependencies (including workspace packages like @jetbrains/vscode-extension-core), and VS Code contributions such as language support, grammars, breakpoints, and debuggers. Additionally, a Maven plugin for workspace imports is added, and a comprehensive set of Gradle test fixtures is included to cover various project configurations including Android, Kotlin Multiplatform, custom source sets, and different Java/Kotlin language levels. Also in this area: 1 commit updating dependencies (1 manifest); Updated VS Code extension entry points; Add 'Go to Test' command registration; Clarified JVM run configuration descriptions and launch snippet.

(dependencies) · medium confidence · unverified

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 55 → 53 (-1.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 77 → 78 (+0.6)
  • Architecture 62 → 56 (-5.8)
  • Maturity 59 → 60 (+0.7)
  • Readiness 45 → 44 (-1.0)
  • Security 100 → 100 (+0.0)
  • Performance 61 → 60 (-0.9)

Resolved (44)

  • Change coupling: GradleTool.kt ↔ GradleToolingApiHelper.kt (workspace-import/src/com/jetbrains/ls/imports/gradle/GradleTool.kt)
  • Change coupling: LSCommonInspectionDiagnosticProvider.kt ↔ LSCommonReferencesProvider.kt (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/LSCommonInspectionDiagnosticProvider.kt)
  • Change coupling: ModuleSourceSetImpl.kt ↔ IdeaProjectMapper.kt (workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/model/impl/ModuleSourceSetImpl.kt)
  • Change coupling: ModuleSourceSetsModelBuilder.kt ↔ IdeaProjectMapper.kt (workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/model/builder/ModuleSourceSetsModelBuilder.kt)
  • Change-coupling hub: LSCommonSyntaxErrorDiagnosticProvider.kt → LSCommonDefinitionProvider.kt, LSCommonInspectionDiagnosticProvider.kt, LSCommonReferencesProvider.kt, LSKotlinPackageDefinitionProvider.kt, LSKotlinCompilerDiagnosticsFixesCodeActionProvider.kt, LSKotlinCompilerDiagnosticsProvider.kt, LSKotlinIntentionCodeActionProvider.kt (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/LSCommonSyntaxErrorDiagnosticProvider.kt)
  • Change-coupling hub: LSKotlinPackageDefinitionProvider.kt → LSCommonDefinitionProvider.kt, LSCommonInspectionDiagnosticProvider.kt, LSHoverProviderBase.kt, LSCommonReferencesProvider.kt, LSKotlinSemanticTokensProvider.kt (features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/definitions/LSKotlinPackageDefinitionProvider.kt)
  • ConversionKt.importWorkspaceData (cognitive 28) (workspace-import/src/com/jetbrains/ls/imports/json/conversion.kt)
  • ConversionKt.importWorkspaceData (cyclomatic 25) (workspace-import/src/com/jetbrains/ls/imports/json/conversion.kt)
  • ConverterKt.mapModuleNames (cognitive 29) (workspace-import/maven-plugin/src/com/jetbrains/ls/imports/maven/converter.kt)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • DependencyFlatteningKt.flattenExportedDependencies (cognitive 39) (workspace-import/src/com/jetbrains/ls/imports/json/dependencyFlattening.kt)
  • DependencyFlatteningKt.flattenExportedDependencies (cyclomatic 18) (workspace-import/src/com/jetbrains/ls/imports/json/dependencyFlattening.kt)
  • Duplicated block (12–16 lines × 2) (buildtool.api/src/com/jetbrains/ls/buildtool/api/run/RunSteps.kt)
  • Duplicated block (5 lines × 2) (workspace-import/maven-plugin/src/com/jetbrains/ls/imports/maven/util.kt)
  • Duplicated block (8–14 lines × 2) (workspace-import/src/com/jetbrains/ls/imports/json/conversion.kt)
  • FileTooLong: jps/JpsBuildTool.kt (workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt)
  • FileTooLong: json/conversion.kt (workspace-import/src/com/jetbrains/ls/imports/json/conversion.kt)
  • FileTooLong: maven/converter.kt (workspace-import/maven-plugin/src/com/jetbrains/ls/imports/maven/converter.kt)
  • GradleContentRootResolver.getContentRoots (cognitive 17) (workspace-import/src/com/jetbrains/ls/imports/gradle/GradleContentRootResolver.kt)
  • Hotspot: vscode-extension-core/src/initializationSettings.ts (vscode-extension-core/src/initializationSettings.ts)
  • …and 24 more

New (29)

  • Change-coupling hub: LSCommonSyntaxErrorDiagnosticProvider.kt → LSCommonInspectionDiagnosticProvider.kt, LSKotlinCompilerDiagnosticsFixesCodeActionProvider.kt, LSKotlinCompilerDiagnosticsProvider.kt, LSKotlinIntentionCodeActionProvider.kt (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/LSCommonSyntaxErrorDiagnosticProvider.kt)
  • Change-coupling hub: LSKotlinPackageDefinitionProvider.kt → LSCommonDefinitionProvider.kt, LSCommonInspectionDiagnosticProvider.kt, LSCommonSyntaxErrorDiagnosticProvider.kt, LSHoverProviderBase.kt, LSCommonReferencesProvider.kt, LSKotlinSemanticTokensProvider.kt (features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/definitions/LSKotlinPackageDefinitionProvider.kt)
  • Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no committed lockfile, so no resolved version to grade)
  • Duplicated block (12–16 lines × 2) (buildtool.api/src/com/jetbrains/ls/buildtool/api/run/RunSteps.kt)
  • Duplicated block (4–5 lines × 5) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/LSCommonInjectionSyntaxErrorDiagnosticProvider.kt)
  • Duplicated block (5 lines × 2) (features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/superDeclarations/LSKotlinSuperDeclarationsProvider.kt)
  • Edited copy of a member (12 corresponding lines) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/callHierarchy/LSCallHierarchyProviderBase.kt)
  • Edited copy of a member (14 corresponding lines) (features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/typeHierarchy/LSKotlinTypeHierarchyProvider.kt)
  • Edited copy of a member (15 corresponding lines) (api.features/src/com/jetbrains/ls/api/features/implementation/LSImplementation.kt)
  • Edited copy of a member (15 corresponding lines) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/rename/renameUtils.kt)
  • Edited copy of a member (16 corresponding lines) (features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/typeHierarchy/LSKotlinTypeHierarchyProvider.kt)
  • Edited copy of a member (17 corresponding lines) (api.features/src/com/jetbrains/ls/api/features/diagnostics/LSDiagnostic.kt)
  • Edited copy of a member (21 corresponding lines) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/callHierarchy/LSCallHierarchyProviderBase.kt)
  • Edited copy of a member (21 corresponding lines) (features-impl/java-base/src/com/jetbrains/ls/api/features/impl/javaBase/LSJavaPackageDefinitionProvider.kt)
  • Edited copy of a member (41 corresponding lines) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/completion/ModCompletionCommandConverter.kt)
  • Edited copy of a member (5 corresponding lines) (api.features/src/com/jetbrains/ls/api/features/callHierarchy/LSCallHierarchy.kt)
  • Edited copy of a member (5 corresponding lines) (api.features/src/com/jetbrains/ls/api/features/callHierarchy/LSCallHierarchy.kt)
  • Edited copy of a member (5 corresponding lines) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/diagnostics/LSCommonSyntaxErrorDiagnosticProvider.kt)
  • Edited copy of a member (8 corresponding lines) (api.features/src/com/jetbrains/ls/api/features/semanticTokens/LSSemanticTokens.kt)
  • Edited copy of a member (9 corresponding lines) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/callHierarchy/LSCallHierarchyProviderBase.kt)
  • …and 9 more

Changes since last survey

  • 107 commits — 101 feature/other, 6 fixes

By area

  • features-impl/common — 36 commits
  • vscode-extension-core/src — 14 commits
  • features-impl/kotlin — 12 commits
  • api.features/resources — 11 commits
  • workspace-import/test — 9 commits
  • api.features/src — 5 commits
  • workspace-import/gradle-plugin — 4 commits
  • (root) — 3 commits
  • api.features/test — 2 commits
  • features-impl/java-base — 2 commits
  • kotlin-vscode/build.sh — 2 commits
  • vscode-jvm-testing/src — 2 commits
  • (repo) — 1 commit
  • kotlin-vscode/package.json — 1 commit
  • vscode-testing/src — 1 commit
  • workspace-import/BUILD.bazel — 1 commit
  • workspace-import/src — 1 commit

Notable commits

  • fix: KTIJ-40643 [kotlin] fix compilation and tests
  • fix: LSP-1234 [lsp] Revive quick fixes that update inspection options
  • fix: LSP-1493 [lsp] stamp diagnostic fixes when diagnostics are computed
  • fix: LSP-1493 [lsp] stamp eager fix commands and version every ModCommand edit
  • fix: LSP-2084: fix LspAnalyzerRawPathConversion inspections
  • fix: [lsp] LSP-2345 If there is only one surround option fix is applied automatically
  • change: CLI-211 include idecli into intellij-server VSIX
  • change: CLI-211 the intellij-server VSIX is built without the embedded IDE CLI until TeamCity delivers it
  • change: DBE-27360: show "Paste from clipboard" option only when clipboard contains data sources
  • change: DBE-27514: introduce "Import datasources from a folder" feature
  • change: DBE-27514: introduce copy/paste datasources from clipboard
  • change: DBE-27516 [lsp/vscode]: import data sources from datagrip to datagrip vs code
  • change: DBE-27628: skip introspection on tree expand when the model is already loaded
  • change: DBE-27657 [lsp] page grid results and add database commands for Database UI
  • change: GO-21352 lsp: warn when vscode-go is enabled alongside Go LSP
  • change: IDEA-395489 Resolve relative Javadoc links in both printers
  • change: IJ-CR-233992 [lsp] LSP-2288 Surround With for Java and Kotlin
  • change: IJPL-259329 Bump Kotlin language and API version to 2.5
  • change: IJPL-259329 a workaround for KT-90890, to be reverted
  • change: IJPL-259329 keeping Kotlin 2.4 for the language server Gradle plugin
  • …and 87 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 2 removed · edges 0 added · 0 removed

Added bounded contexts (1)

  • repository

Removed bounded contexts (2)

  • imports-maven-plugin
  • simple-maven

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

Kotlin/kotlin-lsp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 477f5c22944254f6225a0bec07fd866642fdb07a — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.