Add cmake.languageServerOnlyMode setting for language services without project integration (#4873)

* add languageserveronly mode

* remove unnecessary localization and updated test

* code cleanup

* added test

Author: Omotola

CHANGELOG.md

@@ -5,6 +5,7 @@
 Features:
 - Add support for CMake Presets version 11 (added in CMake 4.3). In test presets, the `execution.jobs` field can now be an empty string, equivalent to passing `--parallel` with no value.
 - Automatically add new source files to `CMakeLists.txt` and remove deleted source files from `CMakeLists.txt`. Two new commands (`cmake.addFileToCMakeLists` and `cmake.removeFileFromCMakeLists`) and nine new `cmake.modifyLists.*` settings provide full control over target selection, variable handling, and confirmation behavior. [#2132](https://github.com/microsoft/vscode-cmake-tools/issues/2132) [#4454](https://github.com/microsoft/vscode-cmake-tools/pull/4454) [@malsyned](https://github.com/malsyned)
+- Add `cmake.languageServerOnlyMode` to keep CMake language services active while disabling CMake project integration when no local CMake executable is available. [#4516](https://github.com/microsoft/vscode-cmake-tools/issues/4516)
 - Allow specifying a custom debug adapter type in `cmake.debugConfig` via the `type` property. When set, automatic debugger detection is skipped and any debug adapter (e.g., `codelldb`, `lldb`) can be used with arbitrary configuration properties. [#4818](https://github.com/microsoft/vscode-cmake-tools/pull/4818)
 - Add `${cmake.testEnvironment}` placeholder for launch.json that resolves to the CTest `ENVIRONMENT` test property, and automatically include CTest environment variables when debugging tests without a launch configuration. [#4572](https://github.com/microsoft/vscode-cmake-tools/issues/4572) [#4821](https://github.com/microsoft/vscode-cmake-tools/pull/4821)
 - Add "Delete Build Directory and Reconfigure" command that removes the entire build directory before reconfiguring, ensuring a completely clean state. [#4826](https://github.com/microsoft/vscode-cmake-tools/pull/4826)

docs/cmake-settings.md

@@ -53,6 +53,7 @@ Options that support substitution, in the table below, allow variable references
 | `cmake.enabledOutputParsers` | List of enabled output parsers. | `["cmake", "gcc", "gnuld", "msvc", "ghs", "diab", "iwyu"]` | no |
 | `cmake.additionalBuildProblemMatchers` | Array of user-defined problem matchers for build output. Each entry has `name`, `regexp`, and optional capture group indices (`file`, `line`, `column`, `severity`, `message`, `code`). See [Additional Build Problem Matchers](#additional-build-problem-matchers) below. | `[]` | no |
 | `cmake.enableLanguageServices` | If `true`, enable CMake language services. | `true` | no |
+| `cmake.languageServerOnlyMode` | If `true`, keep CMake language services enabled while disabling CMake project, build, test, and kit integration. | `false` | no |
 | `cmake.enableTraceLogging` | If `true`, enable trace logging. | `false` | no |
 | `cmake.environment` | An object containing `key:value` pairs of environment variables, which will be available when configuring, building, or testing with CTest. | `{}` (no environment variables) | yes |
 | `cmake.exclude` | CMake Tools will ignore the folders defined in this setting. | `[]` | no |

package.json

@@ -4140,6 +4140,12 @@
           "description": "%cmake-tools.configuration.cmake.enableLanguageServices.description%",
           "scope": "machine"
         },
+        "cmake.languageServerOnlyMode": {
+          "type": "boolean",
+          "default": false,
+          "description": "%cmake-tools.configuration.cmake.languageServerOnlyMode.description%",
+          "scope": "machine"
+        },
         "cmake.preRunCoverageTarget": {
           "type": "string",
           "default": null,

package.nls.json

@@ -383,6 +383,7 @@
     "cmake-tools.configuration.cmake.enableAutomaticKitScan.description": "Enable automatic scanning for kits when a kit isn't selected. This will only take affect when CMake Presets aren't being used.",
     "cmake-tools.configuration.cmake.removeStaleKitsOnScan.description": "Remove compiler-based kits from the user kits file during a full kit scan when they are no longer rediscovered. Set \"keep\": true in a kit entry to preserve it.",
     "cmake-tools.configuration.cmake.enableLanguageServices.description": "Enable language services for CMake files. This will enable syntax highlighting, code completion, and other features.",
+    "cmake-tools.configuration.cmake.languageServerOnlyMode.description": "Enable language-server-only mode for CMake files. This keeps CMake language services active while disabling CMake project, build, test, and kit integration.",
     "cmake-tools.configuration.cmake.preRunCoverageTarget.description": "Target to build before running tests with coverage using the test explorer",
     "cmake-tools.configuration.cmake.postRunCoverageTarget.description": "Target to build after running tests with coverage using the test explorer",
     "cmake-tools.configuration.cmake.coverageInfoFiles.description": "LCOV coverage info files to be processed after running tests with coverage using the test explorer.",

src/cmakeProject.ts

@@ -843,13 +843,26 @@ export class CMakeProject {
         // Force re-reading of cmake exe, this will ensure that the debugger capabilities are updated.
         const cmakeInfo = await this.getCMakeExecutable();
         if (!cmakeInfo.isPresent) {
-            // Do not show a popup here to avoid duplicate "Bad CMake executable" messages.
-            // The canonical user-facing error is shown when a command actually needs a driver
-            // and getCMakeDriverInstance() validates the executable.
-            telemetry.logEvent('CMakeExecutableNotFound');
+            if (!this.workspaceContext.config.languageServerOnlyMode) {
+                telemetry.logEvent('CMakeExecutableNotFound');
+            } else {
+                log.debug(localize('bad.executable.suppressed.language.server.only', 'Skipping bad CMake executable notification because language-server-only mode is enabled.'));
+            }
         }
 
-        await this.reloadCMakeDriver();
+        if (!this.workspaceContext.config.languageServerOnlyMode) {
+            await this.reloadCMakeDriver();
+        }
+    });
+
+    private readonly languageServerOnlyModeSub = this.workspaceContext.config.onChange('languageServerOnlyMode', async enabled => {
+        if (enabled) {
+            log.info(localize('language.server.only.shutdown.driver', 'Shutting down the CMake driver because language-server-only mode was enabled.'));
+            await this.shutDownCMakeDriver();
+        } else {
+            log.info(localize('language.server.only.reload.driver', 'Reloading the CMake driver because language-server-only mode was disabled.'));
+            await this.reloadCMakeDriver();
+        }
     });
 
     private readonly shellSub = this.workspaceContext.config.onChange('shell', async () => {
@@ -901,6 +914,7 @@ export class CMakeProject {
             this.preferredGeneratorsSub,
             this.communicationModeSub,
             this.cmakePathSub,
+            this.languageServerOnlyModeSub,
             this.shellSub
         ]) {
             sub.dispose();
@@ -1491,6 +1505,10 @@ export class CMakeProject {
      */
     async getCMakeDriverInstance(): Promise<CMakeDriver | null> {
         return this.driverStrand.execute(async () => {
+            if (this.workspaceContext.config.languageServerOnlyMode) {
+                log.debug(localize('not.starting.language.server.only', 'Not starting CMake driver because language-server-only mode is enabled.'));
+                return null;
+            }
             if (!this.useCMakePresets && !this.activeKit) {
                 log.debug(localize('not.starting.no.kits', 'Not starting CMake driver: no kit selected'));
                 return null;
@@ -2154,6 +2172,9 @@ export class CMakeProject {
 
     // Reconfigure if the saved file is a cmake file.
     async doCMakeFileChangeReconfigure(uri: vscode.Uri) {
+        if (this.workspaceContext.config.languageServerOnlyMode) {
+            return;
+        }
         const filePath = util.platformNormalizePath(uri.fsPath);
         const driver: CMakeDriver | null = await this.getCMakeDriverInstance();
 

src/config.ts

@@ -251,6 +251,7 @@ export interface ExtensionConfigurationSettings {
     enableAutomaticKitScan: boolean;
     removeStaleKitsOnScan: boolean;
     enableLanguageServices: boolean;
+    languageServerOnlyMode: boolean;
     preRunCoverageTarget: string | null;
     postRunCoverageTarget: string | null;
     coverageInfoFiles: string[];
@@ -656,6 +657,10 @@ export class ConfigurationReader implements vscode.Disposable {
         return this.configData.enableLanguageServices;
     }
 
+    get languageServerOnlyMode(): boolean {
+        return this.configData.languageServerOnlyMode;
+    }
+
     get preRunCoverageTarget(): string | null {
         return this.configData.preRunCoverageTarget;
     }
@@ -764,6 +769,7 @@ export class ConfigurationReader implements vscode.Disposable {
         additionalBuildProblemMatchers: new vscode.EventEmitter<BuildProblemMatcherConfig[]>(),
         shell: new vscode.EventEmitter<string | null>(),
         setBuildTargetSameAsLaunchTarget: new vscode.EventEmitter<boolean>(),
+        languageServerOnlyMode: new vscode.EventEmitter<boolean>(),
         modifyLists: new vscode.EventEmitter<ModifyListsSettings>(),
         outlineViewType: new vscode.EventEmitter<string>()
     };

src/extension.ts

@@ -141,6 +141,9 @@ export class ExtensionManager implements vscode.Disposable {
                 }
             });
         }
+        this.workspaceConfig.onChange('languageServerOnlyMode', async () => {
+            await updateFullFeatureSet();
+        });
 
         this.updateTouchBarVisibility(this.workspaceConfig.touchbar);
         this.workspaceConfig.onChange('touchbar', config => this.updateTouchBarVisibility(config));
@@ -220,7 +223,7 @@ export class ExtensionManager implements vscode.Disposable {
                 await setContextAndStore(multiProjectModeKey, this.projectController.hasMultipleProjects);
                 // Update the full/partial view of the workspace by verifying if after the folder removal
                 // it still has at least one CMake project.
-                await enableFullFeatureSet(this.workspaceHasAtLeastOneProject());
+                await updateFullFeatureSet();
             }
 
             this.projectOutline.removeFolder(folder);
@@ -294,7 +297,7 @@ export class ExtensionManager implements vscode.Disposable {
             }
             await this.initActiveProject();
         }
-        const isFullyActivated: boolean = this.workspaceHasAtLeastOneProject();
+        const isFullyActivated: boolean = this.workspaceHasAtLeastOneProject() && !this.workspaceConfig.languageServerOnlyMode;
         await enableFullFeatureSet(isFullyActivated);
 
         const telemetryProperties: telemetry.Properties = {
@@ -711,6 +714,10 @@ export class ExtensionManager implements vscode.Disposable {
         if (!project) {
             return;
         }
+        if (project.workspaceContext.config.languageServerOnlyMode) {
+            log.debug('Skipping CMake project integration during workspace open because language-server-only mode is enabled.');
+            return;
+        }
         const rootFolder: vscode.WorkspaceFolder = project.workspaceFolder;
         // Scan for kits even under presets mode, so we can create presets from compilers.
         // Silent re-scan when detecting a breaking change in the kits definition.
@@ -2865,8 +2872,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<api.CM
 // and show or hide the buttons in the status bar, according to the boolean.
 // The scope of this is the whole workspace.
 export async function enableFullFeatureSet(fullFeatureSet: boolean) {
-    await setContextAndStore("cmake:enableFullFeatureSet", fullFeatureSet);
-    extensionManager?.showStatusBar(fullFeatureSet);
+    const enableFeatureSet = fullFeatureSet && !extensionManager?.getWorkspaceConfig().languageServerOnlyMode;
+    await setContextAndStore("cmake:enableFullFeatureSet", enableFeatureSet);
+    extensionManager?.showStatusBar(enableFeatureSet);
 }
 
 export function getActiveProject(): CMakeProject | undefined {

src/projectController.ts

@@ -635,6 +635,9 @@ export class ProjectController implements vscode.Disposable {
     private async doCMakeFileChangeReconfigure(uri: vscode.Uri): Promise<void> {
         const activeProject: CMakeProject | undefined = this.getActiveCMakeProject();
         if (activeProject) {
+            if (activeProject.workspaceContext.config.languageServerOnlyMode) {
+                return;
+            }
             const isFileInsideActiveProject: boolean = util.isFileInsideFolder(uri, activeProject.isMultiProjectFolder ? activeProject.folderPath : activeProject.workspaceFolder.uri.fsPath);
             // A save of settings.json triggers the doSave event (doSaveTextDocument or onDidRenameFile)
             // before the settings update event (onDidChangeConfiguration).

test/smoke/goodProject/goodProject.test.ts

@@ -1,5 +1,6 @@
 import { CMakeProject } from '@cmt/cmakeProject';
 import { expect } from 'chai';
+import * as vscode from 'vscode';
 
 import { smokeSuite, smokeTestDefaultKit } from '@test/smoke/smoke';
 
@@ -22,4 +23,57 @@ suite('Smoke test: good project', () => {
             });
         });
     });
+
+    test('languageServerOnlyMode: getCMakeDriverInstance returns null', async () => {
+        smokeSuite('Smoke test: languageServerOnlyMode driver', suite => {
+            let cmakeProject: CMakeProject;
+            suite.setup('create cmake-tools', async test => {
+                cmakeProject = await test.createCMakeProject({
+                    kit: await smokeTestDefaultKit()
+                });
+            });
+            suite.teardown('dispose cmake-tools', async () => {
+                if (cmakeProject) {
+                    await cmakeProject.asyncDispose();
+                }
+            });
+            suite.smokeTest('getCMakeDriverInstance returns null when languageServerOnlyMode is enabled', async () => {
+                // Enable languageServerOnlyMode
+                cmakeProject.workspaceContext.config.updatePartial({ languageServerOnlyMode: true });
+
+                // Verify getCMakeDriverInstance returns null
+                const driver = await cmakeProject.getCMakeDriverInstance();
+                expect(driver).to.be.null;
+            });
+        });
+    });
+
+    test('languageServerOnlyMode: doCMakeFileChangeReconfigure skips reconfiguration', async () => {
+        smokeSuite('Smoke test: languageServerOnlyMode reconfigure', suite => {
+            let cmakeProject: CMakeProject;
+            suite.setup('create cmake-tools', async test => {
+                cmakeProject = await test.createCMakeProject({
+                    kit: await smokeTestDefaultKit()
+                });
+            });
+            suite.teardown('dispose cmake-tools', async () => {
+                if (cmakeProject) {
+                    await cmakeProject.asyncDispose();
+                }
+            });
+            suite.smokeTest('doCMakeFileChangeReconfigure returns early when languageServerOnlyMode is enabled', async () => {
+                // Enable languageServerOnlyMode
+                cmakeProject.workspaceContext.config.updatePartial({ languageServerOnlyMode: true });
+
+                // Call doCMakeFileChangeReconfigure - should return early without error
+                // Use a dummy URI for testing
+                const dummyUri = vscode.Uri.file(cmakeProject.sourceDir + '/CMakeLists.txt');
+                await cmakeProject.doCMakeFileChangeReconfigure(dummyUri);
+
+                // If we get here without error and no driver was created, the test passes
+                const driver = await cmakeProject.getCMakeDriverInstance();
+                expect(driver).to.be.null;
+            });
+        });
+    });
 });

test/unit-tests/config.test.ts

@@ -84,6 +84,7 @@ function createConfig(conf: Partial<ExtensionConfigurationSettings>): Configurat
         enableAutomaticKitScan: true,
         removeStaleKitsOnScan: false,
         enableLanguageServices: true,
+        languageServerOnlyMode: false,
         preRunCoverageTarget: null,
         postRunCoverageTarget: null,
         coverageInfoFiles: [],