Kotlin/kotlin-lsp

This system is a Language Server Protocol (LSP) implementation for the IntelliJ platform, providing a unified API for language-specific features such as code completion, navigation, diagnostics, and refactoring. It supports workspace import for Gradle, Maven, and JPS projects, enabling the server to understand project structure and dependencies. The system includes a dedicated VS Code extension and is designed to be extensible through a provider-based architecture for various programming languages, primarily Java and Kotlin.

53 changes.

This period focused on establishing a unified, provider-based API for Language Server Protocol features, introducing support for semantic tokens, inlay hints, and signature help. It also implemented comprehensive workspace import and export capabilities for Gradle, Maven, and JPS projects, alongside the initial alpha release of the Kotlin VS Code extension.

84 changes.

This period focused on significantly expanding the Language Server Protocol feature set by implementing core navigation capabilities such as call hierarchy, folding ranges, and code lenses, alongside comprehensive Kotlin support including semantic tokens, inlay hints, and refactoring. Simultaneously, the Gradle workspace import infrastructure was completely rewritten to accurately resolve complex project structures, including multi-module setups, Android variants, and Kotlin compiler settings, supported by extensive new test fixtures.

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

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

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

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

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

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

A new interface, LSTypeDefinitionProvider, has been introduced in the language server API to support type definition lookups. This interface defines the contract for providing type definition locations (Flow\<Location\>) based on TypeDefinitionParams, utilizing the LSServer and LspHandlerContext for context. This change enables the underlying infrastructure for 'go-to-type-definition' functionality, specifically noted for Java support in the associated commit.

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

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

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

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

The LSP integration now exposes two new server commands, 'set-highwatermark-file' and 'wait-for-highwatermark', allowing clients to configure a high watermark file path and wait for a specific timestamp during indexing operations. These commands are registered via a new command descriptor provider that validates arguments and handles errors according to LSP protocol standards.

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

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

This update introduces several new utility components within the LSP common module to support specific language server protocol features. It adds a renderer interface and factory for Call Hierarchy items, enabling language-specific handling of call hierarchy data. It also provides utilities for move refactoring, including functions to find or create destination directories (handling missing intermediate directories) and identify parent paths for multiple file renames. Additionally, a helper for finding the PSI element under the caret is added, and the \showDocument\ request is now guarded to only send it to clients that explicitly declare support, preventing errors from unsupported clients.

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

The workspace-import module now includes a Gradle JVM compatibility checker that validates whether the installed Gradle version is supported by the current Java version. This feature uses a predefined compatibility matrix to ensure that project imports via Gradle only proceed when the Java and Gradle versions are known to work together, preventing import failures due to version mismatches.

workspace-import · high confidence

The Gradle import process now gathers richer project metadata during the preparation phase. A new PrepareKotlinIdeaImportAction executes Gradle tasks to collect Kotlin module definitions, custom source sets, Android project details, and module coordinates (Maven group/artifact/version) for dependency substitution. This metadata is aggregated into a ProjectMetadata object, enabling the import to handle multi-module setups, included builds, and Android projects with greater accuracy.

workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/action · high confidence

The Gradle import plugin now includes concrete implementations for its internal data models, enabling more accurate representation of imported projects. Specifically, ExternalModuleDependencyImpl and ExternalModuleDependencySetImpl allow the import process to track external library coordinates, files, and sources. KotlinModuleImpl and KotlinCompilerSettingsImpl expose Kotlin compiler configuration details such as language version, JVM target, plugin options, and compiler arguments, ensuring Kotlin-specific settings are preserved during import. Additionally, ModuleSourceSetsImpl provides support for custom source sets and module coordinates, allowing the import logic to correctly map non-standard project structures.

workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/model/impl · high confidence

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

The Kotlin language server implementation now includes support for hover documentation and inlay hints. Hover functionality provides formatted Kotlin documentation comments for declarations, while inlay hints display type information, lambda parameters, default parameter values, call chain types, and other value hints, with parameter and call chain hints being optional based on configuration.

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

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

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

The Gradle plugin now detects and imports Android projects (both application and library types) by resolving their build variants, source sets, and dependencies. It identifies the active variant (selectable via the LSP\_ANDROID\_VARIANT environment variable or Gradle property) and extracts the corresponding Kotlin/Java sources, resources, and compile-time classpaths, including the generated R.jar. This enables the language server to provide code intelligence for Android modules during workspace import.

workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/model/builder/android · high confidence

Added new Kotlin utilities in the \workspace-import/src/com/jetbrains/ls/imports/json\ package to serialize and deserialize the LSP workspace model to and from JSON format. This includes \XmlUtils\ for handling XML structures within the model and \conversion.kt\ for mapping workspace entities (modules, libraries, SDKs, Java/Kotlin settings) into data classes and back, enabling the language server to persist and reload workspace configurations independently of the IDE's internal JPS storage.

workspace-import/src/com/jetbrains/ls/imports/json · high confidence

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.

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

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

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.

imports-maven-plugin · high confidence

The Gradle import plugin now exposes a richer data model for workspace imports, adding interfaces such as ModuleSourceSet, ModuleSourceSets, KotlinModule, and KotlinCompilerSettings. This allows the import process to capture detailed source-set metadata (including output directories, produced archives, and friend source sets), Java compilation options, and Kotlin compiler configuration (language version, JVM target, and plugin classpaths), providing more accurate project structure and dependency information to the IDE.

workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/model · high confidence

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

A new LSCodeActionProvider interface has been added to the api.features module, defining how code actions (quick-fixes) are provided for the Language Server Protocol. This interface requires providers to specify which CodeActionKinds they support via providesOnlyKinds and exposes a getCodeActions function that accepts CodeActionParams along with server and handler context parameters, enabling access to the LSP client during request processing.

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

A new \LSConcurrentResponseHandler\ object has been added to the \api.features\ module to manage how the Language Server collects and returns results. This handler provides two main capabilities: it can collect results from multiple providers concurrently into a single list, or it can stream partial results to the client if the protocol supports it, falling back to direct response otherwise. This change enables more efficient processing of LSP requests by leveraging Kotlin coroutines for concurrent execution and partial result streaming.

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

The JPS workspace importer has been enhanced to correctly handle Kotlin-specific project configurations. A new \JpsBuildTool\ implementation now initializes global JPS options and loads the project model, while a dedicated \kotlinFacetExtension\ module provides serializers for Kotlin compiler arguments (JVM, JS, Metadata) and facet settings. This ensures that when importing a workspace, Kotlin compiler settings and facet configurations are preserved in the resulting \.idea\ model, allowing the analyzer to index Kotlin modules with the correct language and compiler settings.

workspace-import/src/com/jetbrains/ls/imports/jps · high confidence

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

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

The Gradle plugin now includes new model builders that expose detailed project structure to the IDE: ExternalModuleDependencySetModuleBuilder resolves external library dependencies (including source artifacts for Gradle 7.5+) and reports their Maven coordinates with classifiers; ModuleSourceSetsModelBuilder exposes Java and Android source sets, their compile/runtime classpaths, friend module relationships, and Java toolchain settings; KotlinMetadataModelBuilder reads Kotlin compiler settings (language version, JVM target, plugin classpath) from the compileKotlin task; and PrepareKotlinIdeaImportTasksModelBuilder ensures the standard 'prepareKotlinIdeaImport' task runs before import to generate sources. These changes improve import accuracy by providing richer dependency and configuration metadata.

workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/model/builder · high confidence

This change introduces a new \vscode-jvm-testing\ package that provides the core infrastructure for discovering and running JVM tests (Java and Kotlin) within VS Code. It implements a test controller that discovers tests via the IntelliJ LSP, manages build steps (Maven/Gradle) to ensure test classes are compiled, and handles test execution and failure reporting. The package includes components for test tree grouping (module/package/class/method), failure message parsing (including stacktrace navigation and diff display for assertions), and debug launch integration. This is a foundational behavioral change enabling JVM test support in the VS Code extension.

vscode-jvm-testing · high confidence

A new Java Base extension has been added to the Language Server API, providing core configuration and feature providers for Java files. This includes definition and hover support (with specific handling for JAR/JRT library sources to avoid duplication), completion item kind mapping, Markdown documentation generation, and code lenses for running main methods. The extension is registered as a plugin dependency for the main Java LSP feature.

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

The \LSDiagnosticProvider\ interface is introduced to expose diagnostics (inspections) via the Language Server Protocol. It defines a \getDiagnostics\ method that accepts \DocumentDiagnosticParams\ and returns a flow of \Diagnostic\ objects, utilizing the new \LspHandlerContext\ to access the LSP client. A specialized \LSCompilationDiagnosticProvider\ interface is also added, extending the base provider for compilation-specific errors.

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

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

Added new interfaces for document and workspace symbol providers that explicitly require an LspHandlerContext, enabling access to the LSP client from within symbol requests.

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

A new Maven plugin has been added to the workspace-import module that generates a JSON workspace description (workspace.json) for the Language Server. The plugin provides two goals: 'info' (StructureWithDependenciesMojo), which resolves the full project structure including transitive dependencies and optional sources/javadoc artifacts, and 'process-sources' (ProcessSourcesMojo), which focuses on module structure and Kotlin settings. The implementation includes extensive support for detecting source roots generated by various build plugins (such as build-helper, modello, antlr4, avro, protobuf, and jaxb2) and accurately calculating Java language levels based on compiler configurations.

workspace-import/maven-plugin · high confidence

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

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

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

A new \LSImplementationProvider\ interface has been added to define how the language server provides implementation locations. This interface integrates with the LSP \ImplementationParams\ and \Location\ protocols, allowing the server to return a flow of locations for code navigation. It is designed to be language-specific, enabling features like 'go-to-implementation' to be implemented per language.

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

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

Added two new utility files to the LSP API features utils package. The \ranges.kt\ file introduces a \PsiFile.allNonWhitespaceChildren\ function that retrieves non-whitespace PSI elements, optionally filtered by a specific text range, supporting the implementation of range-based requests like \textDocument/semanticTokens/range\. The \tracing.kt\ file provides \traceProvider\ helper functions that wrap provider result flows or blocks in OpenTelemetry spans, automatically propagating the span context via coroutines, recording exceptions, and ensuring spans are closed upon completion.

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

This change introduces a new set of utility classes in the workspace import module to support Java SDK configuration and build tool integration. It adds a message bundle for localized strings, logic to automatically detect and fix missing project SDKs by creating SDK entities with class and source roots, and a mechanism to stamp build tools (like Maven or Gradle) with their specific Java Home paths. Additionally, it includes utilities for locating JDK external annotations, running build tool processes with error reporting, and converting file paths to internal IntelliJ URIs.

workspace-import/src/com/jetbrains/ls/imports/utils · high confidence

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

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

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

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

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

The API now allows resolve requests to be explicitly bound to their original configuration entries. A new interface, ResolveDataWithConfigurationEntryId, and a helper function, getConfigurationEntryId, have been added to the resolve feature module to extract and validate the configuration entry ID from resolve data, enabling better traceability between resolved results and their source configuration.

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

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

The system now supports non-interactive extraction of variables, methods, fields, and constants. This change introduces the \ExtractActionKind\ enum, which defines the specific action kinds for these refactorings, enabling users to trigger these operations via hotkeys without additional prompts.

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

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

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

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

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

The Gradle plugin component for workspace import is now built as a dedicated content module with explicit Bazel build rules and IntelliJ module descriptors. This establishes the build structure for the plugin, defining its Kotlin 2.4 compilation settings, JVM 1.8 target, and dependencies on core tooling libraries (Groovy, Gradle, Kotlin tooling core, serialization) and annotations, while also setting up the test library configuration with JUnit 6 and Kotlin test support.

workspace-import/gradle-plugin · high confidence

A new build target and module configuration have been added for the Kotlin PSI implementation used by the language server. This change introduces the \language-server.api.features.impl.kotlin.psi\ module, defining its dependencies on core platform, analysis API, and Kotlin compiler libraries, and configuring the Kotlin compiler with specific flags (such as JVM target 25 and API version 2.4) to support the language server's internal processing needs.

features-impl/kotlin/psi · high confidence

The workspace import functionality now includes generated metadata definitions for the \DefaultJdkEntitySource\ class. This change registers the entity's structure, specifically its \virtualFileUrl\ property, within the internal workspace storage system, ensuring that this source type is correctly recognized and persisted during language server workspace imports.

workspace-import/gen · high confidence

Users will now see specific error messages when the workspace import process fails, including a generic parsing error for workspace.json and a specific message indicating that no JDK was found on the machine, which is required for JPS workspace import.

workspace-import/resources/messages · high confidence

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

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 \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

The Gradle import utility now supports resolving additional artifacts produced by source sets and extracting project information from the \idea\ Gradle plugin, improving the accuracy of imported project structures. To ensure compatibility across different Gradle versions, the import logic includes version-specific handling for included builds (distinguishing between Gradle 8.0 and earlier), resource directories, test sources, and test resources within IDEA module models. Additionally, a new utility safely unpacks Gradle model proxies to ensure they function correctly within the import process's classloader context.

workspace-import/gradle-plugin/src/com/jetbrains/ls/imports/gradle/utils · high confidence

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

The Gradle workspace import utility now provides more accurate dependency scope calculation and better support for multi-module and multi-root projects. A new \DependencyDataScopeCalculator\ distinguishes between COMPILE, RUNTIME, and PROVIDED scopes based on whether dependencies are part of the current compilation set. \DependencyFileIndex\ and \ProjectLibraryIndex\ have been refactored to track both output directories and archives, ensuring that downstream modules correctly resolve dependencies whether they are accessed via project outputs or packaged jars. Additionally, a new \GradleOutputStream\ captures Gradle sync output line-by-line for propagation to the LSP, and \GradleSyncResultHandler\ manages the asynchronous sync result, improving the reliability and visibility of the import process.

workspace-import/src/com/jetbrains/ls/imports/gradle/util · high confidence

The Gradle workspace import logic now uses dedicated resolvers to more accurately map source sets and dependencies. \GradleContentRootResolver\ correctly identifies content roots and marks build-directory outputs as generated, while \SourceSetDependencyResolver\ distinguishes between compile, runtime, and test scopes and supports multi-module and Android project dependencies. This results in more precise project structure and dependency information for imported Gradle projects.

workspace-import/src/com/jetbrains/ls/imports/gradle · high confidence

The Maven workspace import process now correctly merges source roots generated by code-generation plugins (such as maven-sources) with the initial dependency model. Previously, generated sources might have been lost or conflicted with existing roots; the new logic ranks source roots by type (e.g., java-source, java-test) and ensures that generated roots are properly integrated without intersecting incorrectly with existing module roots. This results in a more accurate project structure where generated code is correctly recognized and ranked alongside manual sources.

workspace-import/src/com/jetbrains/ls/imports/maven · high confidence

The Kotlin Language Server Protocol implementation now provides more granular and accurate categorization for code completion suggestions. A new provider maps specific Kotlin PSI elements to LSP completion item kinds, distinguishing between methods and functions, identifying operator overloads, and correctly classifying data classes, interfaces, enums, and constants. This results in better visual grouping and filtering of autocomplete options in supported editors.

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

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

The Kotlin LSP implementation has been restructured to support multiplexing the server to several clients. This includes introducing a new \KotlinFirCacheImpl\ that utilizes the Kotlin LL FIR session cache storage to manage semi-immutable caches, allowing concurrent requests to maintain their own workspace states while sharing sessions. Additionally, a new \KotlinFileForModificationFactory\ has been added to handle text edits, ensuring that modified files are correctly associated with their context modules and retain their original names.

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

The Kotlin-specific language server configuration has been moved into a new, dedicated module under the Kotlin implementation path. This change introduces a \KotlinLanguageServerExtension\ that exposes the Kotlin configuration piece and a \kotlinPlugins.kt\ file that defines the plugin descriptor. This descriptor explicitly lists the XML modules for core, completion, code actions, refactoring, usages, and import features, along with dependencies on the main Kotlin plugin and the Java base feature, effectively decoupling the Kotlin language server setup from the generic analyzer infrastructure.

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

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

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

The \LSCompletionProvider\ and \LSDefinitionProvider\ interfaces in the language server API have been updated to include \LspHandlerContext\ as a context receiver. This change allows implementations of these providers to access the LSP client directly during request handling, enabling more interactive or client-aware completion and definition resolution behaviors.

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

The Gradle workspace import process now uses a dedicated \IdeaGradleLspPlugin\ to register model builders for Kotlin metadata, custom source sets, Android projects, and external dependencies. This change introduces a new \ProjectMetadataBuilder\ that constructs a unified metadata model by resolving these specific aspects (Kotlin modules, source sets, Android variants, and dependency sets) for all projects, including included builds, during the import phase.

simple-maven · high confidence

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

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

The diagnostics module now includes a new LSInspectionManager that converts inspection quick fixes into lazy-mod-command fixes for the LSP server. This change introduces support for information-level inspections as intention actions, ensures nullability inspection warnings are properly represented, and strips HTML from quick-fix names to improve display. It also implements a limit on flattened inspection fix choices (max 5) to prevent excessive data transfer and handles various quick-fix types (ModCommandQuickFix, IntentionAction, LocalQuickFix) with fallback logic.

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

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

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.

api.features/resources/messages · high confidence

The Kotlin Language Server Protocol implementation now uses dedicated customizer classes to handle document and workspace symbols, moving language-specific logic into a shared module. This change introduces LSKotlinDocumentSymbolCustomizer to map Kotlin PSI elements (such as class initializers, property accessors, and constructor parameters) to LSP document symbols, and LSKotlinWorkspaceSymbolCustomizer to reuse existing IntelliJ navigation contributors for workspace symbol resolution. A new helper file defines the mapping of Kotlin PSI types to LSP SymbolKind values, ensuring consistent symbol representation across the IDE and analyzer.

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

The completion implementation in the common LSP module has been refactored to remove dependencies on Java and Kotlin-specific logic, improving modularity. This change introduces a new \CompletionSortingUtil\ to handle LSP-compliant sorting via the \sortText\ field, adds an \LSAnyCompletionItemKindProvider\ to map generic PSI elements to completion kinds, and defines a new \LSCompletion\ data class to encapsulate completion parameters, lookup elements, and matchers.

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

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

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

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

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

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

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

The LSP integration now uses a single provider to handle ModCommand-based quick fixes, introducing support for lazy execution. Users will experience fixes that are resolved on-demand (previewing what a fix would do without immediate application) and executed within the correct analysis context, ensuring that fixes relying on file-specific analysis data are applied correctly.

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

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

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

A fix in workspace-import/resources/META-INF — 2 commits (2 fixs), 1 file.

workspace-import/resources/META-INF · medium confidence · unverified

Added Bazel build configuration for language-server test module; Added Gradle 6 and 7 test fixtures for workspace import; Added placeholder test data for Gradle workspace import scenarios; Added test data for Gradle Kotlin language version import scenarios; Added test data for Gradle PetClinic workspace import; Added test data for Gradle dependency import scenarios; Added test data for Gradle included build project import; Added test data for Gradle library source download verification; Added test data for Gradle multi-project import scenarios; Added test data for Gradle toolchain and Java version scenarios; Added test data for Gradle workspace import with single-root sources; Added test data for JPS Kotlin facet import; Added test data for JPS Kotlin project settings import; Added test data for JPS TestModuleProperties mapping; Added test data for JPS exported module library flattening; Added test data for JPS source-root package prefix support; Added test data for Java 8, 11, 17, and 21 language levels; Added test data for Java preview language features; Added test data for Kotlin Gradle project import; Added test data for Kotlin Multiplatform Gradle project sync; Added test data for Maven Java language preview feature support; Added test data for Maven annotation processing and custom POM import scenarios; Added test data for Maven workspace import with Kotlin support; Added test data for custom Gradle source sets; Added test data for multi-module Android Gradle projects; Added test fixture for Gradle 6 system properties; Added test fixture for Gradle BuildException handling; Added test fixture for Gradle project with custom environment; Added test fixture for JPS Java module import; Added test fixture for Kotlin Gradle project with multi-module and version catalog support; Added test fixtures for Android Gradle project structures; Added test fixtures for Android-Gradle import and Java language level validation; Added test fixtures for Gradle Java language feature preview; Added test fixtures for Gradle included build scenarios; Added test infrastructure for workspace import validation; Added tests for Gradle import JDK selection, wrapper discovery, and model type safety; Added tests for Gradle plugin reflection utilities; Added tests for archive extraction and TeamCity service message parsing; Added unit tests for semantic tokens encoding and text edits computation; Expanded test coverage for LSP workspace import; Migrate Kotlin tokenization tests to textmate-grammar-test.

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.

(dependencies) · high confidence

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

• CAI 54 → 54 (-0.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 75 → 82 (+6.9)
• Architecture 66 → 63 (-3.1)
• Maturity 59 → 59 (-0.0)
• Readiness 41 → 43 (+2.2)
• Security 100 → 100 (+0.0)
• Performance 60 (new)

• Change-coupling hub: IdeaProjectMapper.kt → ProjectMetadataBuilder.java, ModuleSourceSetsModelBuilder.kt, ModuleSourceSetImpl.kt (workspace-import/src/com/jetbrains/ls/imports/gradle/IdeaProjectMapper.kt)
• Duplicated block (14 lines × 2) (workspace-import/src/com/jetbrains/ls/imports/maven/MavenWorkspaceImporter.kt)
• FileTooLong: jps/JpsWorkspaceImporter.kt (workspace-import/src/com/jetbrains/ls/imports/jps/JpsWorkspaceImporter.kt)
• Hotspot: features-impl/common/src/com/jetbrains/ls/api/features/impl/common/completion/ModCompletionCommandConverter.kt (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/completion/ModCompletionCommandConverter.kt)
• Hotspot: vscode-extension-core/src/keyHandlerUtils.ts (vscode-extension-core/src/keyHandlerUtils.ts)
• Hotspot: workspace-import/maven-plugin/src/com/jetbrains/ls/imports/maven/util.kt (workspace-import/maven-plugin/src/com/jetbrains/ls/imports/maven/util.kt)
• Hotspot: workspace-import/src/com/jetbrains/ls/imports/jps/JpsWorkspaceImporter.kt (workspace-import/src/com/jetbrains/ls/imports/jps/JpsWorkspaceImporter.kt)
• Hotspot: workspace-import/src/com/jetbrains/ls/imports/maven/MavenWorkspaceImporter.kt (workspace-import/src/com/jetbrains/ls/imports/maven/MavenWorkspaceImporter.kt)
• JpsWorkspaceImporter.importJpsModel (cognitive 17) (workspace-import/src/com/jetbrains/ls/imports/jps/JpsWorkspaceImporter.kt)
• JpsWorkspaceImporter.importJpsModel (cyclomatic 17) (workspace-import/src/com/jetbrains/ls/imports/jps/JpsWorkspaceImporter.kt)
• LSRenameProcessor.classifyUsages (cognitive 17) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/processors/LSRenameProcessor.kt)
• LSRenameProcessor.processUsages (cognitive 26) (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/processors/LSRenameProcessor.kt)
• MavenWorkspaceImporter.importWorkspace (cyclomatic 16) (workspace-import/src/com/jetbrains/ls/imports/maven/MavenWorkspaceImporter.kt)
• MethodTooLong: JpsWorkspaceImporter.importJpsModel (workspace-import/src/com/jetbrains/ls/imports/jps/JpsWorkspaceImporter.kt)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• TodoComment (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)
• Documentation: no architecture or design documentation (README.md)
• Duplicated block (14 lines × 2) (workspace-import/src/com/jetbrains/ls/imports/maven/MavenTool.kt)
• FileTooLong: jps/JpsBuildTool.kt (workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt)
• FileTooLong: modcommands/ModCommandData.kt (features-impl/common/src/com/jetbrains/ls/api/features/impl/common/modcommands/ModCommandData.kt)
• Hotspot: features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/semanticTokens/LSKotlinSemanticTokensProvider.kt (features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/kotlin/semanticTokens/LSKotlinSemanticTokensProvider.kt)
• Hotspot: workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt (workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt)
• JpsBuildTool.importJpsModel (cognitive 18) (workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt)
• JpsBuildTool.importJpsModel (cyclomatic 19) (workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt)
• MethodTooLong: JpsBuildTool.importJpsModel (workspace-import/src/com/jetbrains/ls/imports/jps/JpsBuildTool.kt)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #3
• Off-boarding risk: anonymized user #2
• Scanner failed to run — not a clean result
• lspClient.doStartLspClient (cyclomatic 16) (vscode-extension-core/src/lspClient.ts)
• lspClient.startServer (cognitive 17) (vscode-extension-core/src/lspClient.ts)
• lspClient.startServer (cyclomatic 16) (vscode-extension-core/src/lspClient.ts)

• 71 commits — 69 feature/other, 2 fixes

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

• fix: LSP-1908 [kotlin] fix missing read-action in Extract
• fix: LSP-1932 [lsp] Code action fixes ship whole file texts per edit; send changed fragments instead
• change: IDEA-391927 [junit] use ALL-MODULE-PATH for JPMS
• change: IJPL-150365 Remove moduleId from ModuleSettingsFacetBridgeEntity
• change: IJPL-245353 Remove registry flag
• change: IJPL-254287 Workspace Model: introduce VirtualFileUrlManager.get, storeAndGet, VirtualFile extension functions
• change: LSP-1481 [dap] implement Java stepping filters
• change: LSP-1741 clarify license activation and server status text
• change: LSP-1745 pass --enable-preview to a launch of a preview-level module
• change: LSP-1757 [lsp] Follow-up: do not fallback to virtualFile.modificationStamp, use 0 explicitly
• change: LSP-1773 [junit] support JPMS
• change: LSP-1777 Proxy LSP to already running server
• change: LSP-1798: do not report import exceptions caused by user environment
• change: LSP-1850 [lsp] native.io plugin for DAP, DB and import containers
• change: LSP-1859 [lsp] serve library text via workspace/textDocumentContent
• change: LSP-1866 [lsp] pack jdkAnnotations.jar into server java plugin
• change: LSP-1867 [bazel] add Bazel build-tool launch contributor
• change: LSP-1867 [vscode] intellij_bazel launch configuration type
• change: LSP-1880 git-worktree support
• change: LSP-1881 [lsp] Java textDocument/hover fails with NPE on a synthetic enum method (valueOf / values)
• …and 51 more

• Unchanged — 0 containers · 2 contexts · 0 edges

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

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.