Fix exportCompileCommands flag handling (#4899)

* fix: prevent passing -DCMAKE_EXPORT_COMPILE_COMMANDS flag when exportCompileCommandsFile is false

* fix changelog

---------

Co-authored-by: Hannia Valera <hanniavalera@users.noreply.github.com>

Author: hanniavalera

CHANGELOG.md

@@ -13,6 +13,7 @@ Bug Fixes:
 ## 1.23.52
 
 Bug Fixes:
+- Fix `cmake.exportCompileCommandsFile` set to `false` still passing `-DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=FALSE` instead of omitting the flag entirely, which caused CMake warnings for projects with `LANGUAGES NONE`. [#4893](https://github.com/microsoft/vscode-cmake-tools/issues/4893)
 - Fix regression where Visual Studio kits with an existing Ninja-based build cache would fail due to a generator mismatch. Ninja is now preferred again when available, stale VS kits derive the correct generator at runtime as a fallback, and the build directory is auto-cleaned on generator mismatches. [#4890](https://github.com/microsoft/vscode-cmake-tools/issues/4890)
 
 ## 1.23

src/drivers/cmakeDriver.ts

@@ -1574,7 +1574,7 @@ export abstract class CMakeDriver implements vscode.Disposable {
         const presetCacheVariables = configPreset.cacheVariables ?? {};
         const hasExportCompileCommands = Object.prototype.hasOwnProperty.call(presetCacheVariables, 'CMAKE_EXPORT_COMPILE_COMMANDS')
             || expandedArgs.some(arg => arg.startsWith('-DCMAKE_EXPORT_COMPILE_COMMANDS'));
-        if (!hasExportCompileCommands) {
+        if (!hasExportCompileCommands && exportCompileCommandsFile) {
             const exportCompileCommandsValue = util.cmakeify(exportCompileCommandsFile);
             expandedArgs.push(`-DCMAKE_EXPORT_COMPILE_COMMANDS:${exportCompileCommandsValue.type}=${exportCompileCommandsValue.value}`);
         }
@@ -1898,7 +1898,9 @@ export abstract class CMakeDriver implements vscode.Disposable {
         // Export compile_commands.json
         const exportCompileCommandsSetting = config.get<boolean>("exportCompileCommandsFile");
         const exportCompileCommandsFile: boolean = exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false);
-        settingMap.CMAKE_EXPORT_COMPILE_COMMANDS = util.cmakeify(exportCompileCommandsFile);
+        if (exportCompileCommandsFile) {
+            settingMap.CMAKE_EXPORT_COMPILE_COMMANDS = util.cmakeify(exportCompileCommandsFile);
+        }
 
         console.assert(!!this._kit);
         if (!this._kit) {

test/unit-tests/backend/exportCompileCommands.test.ts

@@ -0,0 +1,123 @@
+import { expect } from 'chai';
+
+/**
+ * Tests for the export compile commands logic in cmakeDriver.ts
+ *
+ * This tests the LOGIC PATTERN used for deciding whether to inject
+ * -DCMAKE_EXPORT_COMPILE_COMMANDS into CMake configure arguments.
+ *
+ * The actual implementation lives in cmakeDriver.ts but depends on vscode,
+ * so we mirror the decision logic here to validate correctness.
+ *
+ * Issue #4893: When cmake.exportCompileCommandsFile is set to false,
+ * the flag should NOT be passed at all (not even as FALSE), to avoid
+ * CMake warnings for projects with LANGUAGES NONE.
+ */
+
+suite('[Export Compile Commands Logic]', () => {
+    /**
+     * Mirrors the logic from cmakeDriver.ts generateConfigArgsFromPreset()
+     * and generateCMakeSettingsFlags()
+     *
+     * @param exportCompileCommandsSetting The raw setting value (undefined, true, or false)
+     * @param hasExportCompileCommandsInPresetOrArgs Whether preset or args already specify the flag
+     * @returns Whether to inject the -DCMAKE_EXPORT_COMPILE_COMMANDS flag
+     */
+    function shouldInjectExportCompileCommandsFlag(
+        exportCompileCommandsSetting: boolean | undefined,
+        hasExportCompileCommandsInPresetOrArgs: boolean
+    ): boolean {
+        // Mirror the logic from cmakeDriver.ts:
+        // const exportCompileCommandsFile: boolean = exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false);
+        const exportCompileCommandsFile: boolean = exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false);
+
+        // For presets mode (generateConfigArgsFromPreset):
+        // if (!hasExportCompileCommands && exportCompileCommandsFile)
+        //
+        // For kits mode (generateCMakeSettingsFlags):
+        // if (exportCompileCommandsFile)
+        //
+        // Both modes now check exportCompileCommandsFile is truthy before injecting
+        return !hasExportCompileCommandsInPresetOrArgs && exportCompileCommandsFile;
+    }
+
+    suite('Setting is undefined (default)', () => {
+        test('Should inject flag when preset/args do not specify it', () => {
+            const result = shouldInjectExportCompileCommandsFlag(undefined, false);
+            expect(result).to.equal(true, 'Default behavior should inject TRUE to enable compile_commands.json');
+        });
+
+        test('Should NOT inject flag when preset/args already specify it', () => {
+            const result = shouldInjectExportCompileCommandsFlag(undefined, true);
+            expect(result).to.equal(false, 'Should respect preset/args override');
+        });
+    });
+
+    suite('Setting is explicitly true', () => {
+        test('Should inject flag when preset/args do not specify it', () => {
+            const result = shouldInjectExportCompileCommandsFlag(true, false);
+            expect(result).to.equal(true, 'Explicit true should inject the flag');
+        });
+
+        test('Should NOT inject flag when preset/args already specify it', () => {
+            const result = shouldInjectExportCompileCommandsFlag(true, true);
+            expect(result).to.equal(false, 'Should respect preset/args override');
+        });
+    });
+
+    suite('Setting is explicitly false (Issue #4893 fix)', () => {
+        test('Should NOT inject flag when preset/args do not specify it', () => {
+            const result = shouldInjectExportCompileCommandsFlag(false, false);
+            expect(result).to.equal(false, 'Explicit false should NOT inject the flag at all');
+        });
+
+        test('Should NOT inject flag when preset/args already specify it', () => {
+            const result = shouldInjectExportCompileCommandsFlag(false, true);
+            expect(result).to.equal(false, 'Should respect preset/args override');
+        });
+    });
+
+    suite('exportCompileCommandsFile computation', () => {
+        /**
+         * Mirrors the computation: exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false)
+         */
+        function computeExportCompileCommandsFile(setting: boolean | undefined): boolean {
+            return setting === undefined ? true : (setting || false);
+        }
+
+        test('undefined setting defaults to true', () => {
+            expect(computeExportCompileCommandsFile(undefined)).to.equal(true);
+        });
+
+        test('explicit true remains true', () => {
+            expect(computeExportCompileCommandsFile(true)).to.equal(true);
+        });
+
+        test('explicit false becomes false', () => {
+            expect(computeExportCompileCommandsFile(false)).to.equal(false);
+        });
+    });
+
+    suite('Kits mode logic (generateCMakeSettingsFlags)', () => {
+        /**
+         * In kits mode, the logic is simpler: just check if exportCompileCommandsFile is truthy
+         * (no hasExportCompileCommands check needed as configureSettings handles that)
+         */
+        function shouldAddToSettingMapInKitsMode(exportCompileCommandsSetting: boolean | undefined): boolean {
+            const exportCompileCommandsFile: boolean = exportCompileCommandsSetting === undefined ? true : (exportCompileCommandsSetting || false);
+            return exportCompileCommandsFile;
+        }
+
+        test('undefined setting should add to settingMap', () => {
+            expect(shouldAddToSettingMapInKitsMode(undefined)).to.equal(true);
+        });
+
+        test('explicit true should add to settingMap', () => {
+            expect(shouldAddToSettingMapInKitsMode(true)).to.equal(true);
+        });
+
+        test('explicit false should NOT add to settingMap (Issue #4893 fix)', () => {
+            expect(shouldAddToSettingMapInKitsMode(false)).to.equal(false);
+        });
+    });
+});