Enhance generator mismatch detection and clean-up logic

hanniavalera · hanniavalera · commit 6dcc8be387a3 · 2026-04-16T12:24:48.000-05:00
- Added a new method to clean prior configurations if the generator changes..
- Removed deprecated functions related to Visual Studio generator mapping.
- Introduced unit tests to verify generator mismatch detection and kit change logic.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # What's New?
 
+## 1.23.51
+
+Bug Fixes:
+- Fix regression where VS kits with existing Ninja cache would fail due to generator mismatch after update. [#4890](https://github.com/microsoft/vscode-cmake-tools/issues/4890)
+
 ## 1.23
 
 Features:
diff --git a/src/drivers/cmakeDriver.ts b/src/drivers/cmakeDriver.ts
@@ -16,7 +16,7 @@ import { CMakeOutputConsumer } from '@cmt/diagnostics/cmake';
 import { RawDiagnosticParser } from '@cmt/diagnostics/util';
 import { ProgressMessage } from '@cmt/drivers/drivers';
 import * as expand from '@cmt/expand';
-import { CMakeGenerator, effectiveKitEnvironment, Kit, kitChangeNeedsClean, KitDetect, getKitDetect, getVSKitEnvironment, getVsKitPreferredGenerator } from '@cmt/kits/kit';
+import { CMakeGenerator, effectiveKitEnvironment, Kit, kitChangeNeedsClean, KitDetect, getKitDetect, getVSKitEnvironment } from '@cmt/kits/kit';
 import * as logging from '@cmt/logging';
 import paths from '@cmt/paths';
 import { fs } from '@cmt/pr';
@@ -32,7 +32,7 @@ import * as codeModel from '@cmt/drivers/codeModel';
 import { Environment, EnvironmentUtils } from '@cmt/environmentVariables';
 import { CMakeTask, CMakeTaskProvider, CustomBuildTaskTerminal } from '@cmt/cmakeTaskProvider';
 import { getValue } from '@cmt/presets/preset';
-import { CacheEntry } from '@cmt/cache';
+import { CacheEntry, CMakeCache } from '@cmt/cache';
 import { CMakeBuildRunner } from '@cmt/cmakeBuildRunner';
 import { DebuggerInformation } from '@cmt/debug/cmakeDebugger/debuggerConfigureDriver';
 import { onBuildSettingsChange, onTestSettingsChange, onPackageSettingsChange } from '@cmt/ui/util';
@@ -622,6 +622,26 @@ export abstract class CMakeDriver implements vscode.Disposable {
         }
     }
 
+    /**
+     * Check if the generator to be used differs from what is cached in CMakeCache.txt.
+     * If so, auto-clean the prior configuration to prevent CMake errors.
+     */
+    protected async _cleanIfGeneratorChanged(newGeneratorName: string | undefined): Promise<void> {
+        if (!newGeneratorName) {
+            return;
+        }
+        const cachePath = this.cachePath;
+        if (!await fs.exists(cachePath)) {
+            return;
+        }
+        const cache = await CMakeCache.fromPath(cachePath);
+        const cachedGenerator = cache.get('CMAKE_GENERATOR');
+        if (cachedGenerator && cachedGenerator.value !== newGeneratorName) {
+            log.info(localize('generator.changed', 'Generator changed from {0} to {1}; cleaning prior configuration', cachedGenerator.value, newGeneratorName));
+            await this._cleanPriorConfiguration();
+        }
+    }
+
     /**
      * Remove the entire build directory.
      */
@@ -802,6 +822,7 @@ export abstract class CMakeDriver implements vscode.Disposable {
             if (needsCleanIfKitChange && (newBinaryDir === oldBinaryDir)) {
                 await this._cleanPriorConfiguration();
             }
+            await this._cleanIfGeneratorChanged(this._generator?.name);
         });
     }
 
@@ -812,14 +833,8 @@ export abstract class CMakeDriver implements vscode.Disposable {
         this._kitEnvironmentVariables = await effectiveKitEnvironment(kit, this.expansionOptions);
 
         // Place a kit preferred generator at the front of the list
-        // For VS kits that don't have preferredGenerator (e.g., scanned before a VS version was added),
-        // try to derive it from the VS installation.
-        let kitPreferredGenerator = kit.preferredGenerator;
-        if (!kitPreferredGenerator && kit.visualStudio) {
-            kitPreferredGenerator = await getVsKitPreferredGenerator(kit);
-        }
-        if (kitPreferredGenerator) {
-            preferredGenerators.unshift(kitPreferredGenerator);
+        if (kit.preferredGenerator) {
+            preferredGenerators.unshift(kit.preferredGenerator);
         }
 
         // If no preferred generator is defined by the current kit or the user settings,
diff --git a/src/kits/kit.ts b/src/kits/kit.ts
@@ -800,60 +800,6 @@ const VsGenerators: { [key: string]: string } = {
     18: 'Visual Studio 18 2026'
 };
 
-/**
- * Get the CMake generator name for a given Visual Studio version
- * @param version The major version of Visual Studio (e.g., '17' for VS 2022, '18' for VS 2026)
- * @returns The CMake generator name, or undefined if the version is not recognized
- */
-export function vsGeneratorForVersion(version: string): string | undefined {
-    return VsGenerators[version];
-}
-
-/**
- * Get the preferred CMake generator for a Visual Studio kit.
- * This is useful for kits that were scanned before a VS version was added to the VsGenerators mapping.
- * @param kit The Visual Studio kit
- * @returns The preferred generator, or undefined if the kit is not a VS kit or the VS version is not recognized
- */
-export async function getVsKitPreferredGenerator(kit: Kit): Promise<CMakeGenerator | undefined> {
-    if (!kit.visualStudio || !kit.visualStudioArchitecture) {
-        return undefined;
-    }
-
-    // If the kit already has a preferredGenerator, return it
-    if (kit.preferredGenerator) {
-        return kit.preferredGenerator;
-    }
-
-    // Try to derive the preferredGenerator from the VS installation
-    const vsInstall = await getVSInstallForKit(kit);
-    if (!vsInstall) {
-        return undefined;
-    }
-
-    const version = /^(\d+)+./.exec(vsInstall.installationVersion);
-    if (!version) {
-        return undefined;
-    }
-
-    const generatorName = VsGenerators[version[1]];
-    if (!generatorName) {
-        return undefined;
-    }
-
-    const majorVersion = parseInt(vsInstall.installationVersion);
-    const hostArch = kit.visualStudioArchitecture;
-    const host: string = hostArch.toLowerCase().replace(/ /g, "").startsWith("host=") ? hostArch : "host=" + hostArch;
-    // For VS kits, use the hostArch as the target platform (x64 -> x64)
-    const targetArch = hostArch;
-
-    return {
-        name: generatorName,
-        platform: generatorPlatformFromVSArch[targetArch] as string || targetArch,
-        toolset: majorVersion < 15 ? undefined : host
-    };
-}
-
 /**
  * Try to get a VSKit from a VS installation and architecture
  * @param inst A VS installation from vswhere
diff --git a/test/unit-tests/generator-mismatch.test.ts b/test/unit-tests/generator-mismatch.test.ts
@@ -0,0 +1,101 @@
+/* eslint-disable no-unused-expressions */
+import { expect } from 'chai';
+import { CMakeCache, CacheEntry } from '@cmt/cache';
+
+suite('Generator mismatch detection', () => {
+    // Test the core logic that _cleanIfGeneratorChanged relies on:
+    // reading CMAKE_GENERATOR from cache and comparing with new generator
+
+    test('Detects generator mismatch when cache has Ninja but VS generator selected', () => {
+        const cacheContent = [
+            '# This is the CMakeCache file.',
+            'CMAKE_GENERATOR:INTERNAL=Ninja',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR') as CacheEntry;
+        expect(cachedGenerator).to.not.be.undefined;
+        expect(cachedGenerator.value).to.eq('Ninja');
+        // Simulating the comparison in _cleanIfGeneratorChanged
+        const newGenerator = 'Visual Studio 18 2026';
+        expect(cachedGenerator.value).to.not.eq(newGenerator);
+    });
+
+    test('No mismatch when cache generator matches selected generator', () => {
+        const cacheContent = [
+            'CMAKE_GENERATOR:INTERNAL=Ninja',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR') as CacheEntry;
+        expect(cachedGenerator).to.not.be.undefined;
+        expect(cachedGenerator.value).to.eq('Ninja');
+    });
+
+    test('No mismatch detection when cache is empty', () => {
+        const cacheContent = '';
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR');
+        expect(cachedGenerator).to.be.undefined;
+        // _cleanIfGeneratorChanged would return early (no cached generator)
+    });
+
+    test('No mismatch detection when CMAKE_GENERATOR not in cache', () => {
+        const cacheContent = [
+            'CMAKE_BUILD_TYPE:STRING=Debug',
+            'CMAKE_INSTALL_PREFIX:PATH=/usr/local',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR');
+        expect(cachedGenerator).to.be.undefined;
+    });
+
+    test('Detects mismatch with Visual Studio generators of different versions', () => {
+        const cacheContent = [
+            'CMAKE_GENERATOR:INTERNAL=Visual Studio 17 2022',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR') as CacheEntry;
+        expect(cachedGenerator).to.not.be.undefined;
+        const newGenerator = 'Visual Studio 18 2026';
+        expect(cachedGenerator.value).to.not.eq(newGenerator);
+    });
+
+    test('No mismatch when both are Visual Studio 18 2026', () => {
+        const cacheContent = [
+            'CMAKE_GENERATOR:INTERNAL=Visual Studio 18 2026',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR') as CacheEntry;
+        expect(cachedGenerator).to.not.be.undefined;
+        expect(cachedGenerator.value).to.eq('Visual Studio 18 2026');
+    });
+
+    test('Detects mismatch switching from VS generator to Ninja', () => {
+        const cacheContent = [
+            'CMAKE_GENERATOR:INTERNAL=Visual Studio 18 2026',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR') as CacheEntry;
+        expect(cachedGenerator).to.not.be.undefined;
+        const newGenerator = 'Ninja';
+        expect(cachedGenerator.value).to.not.eq(newGenerator);
+    });
+
+    test('Handles Unix Makefiles generator in cache', () => {
+        const cacheContent = [
+            'CMAKE_GENERATOR:INTERNAL=Unix Makefiles',
+            ''
+        ].join('\n');
+        const entries = CMakeCache.parseCache(cacheContent);
+        const cachedGenerator = entries.get('CMAKE_GENERATOR') as CacheEntry;
+        expect(cachedGenerator).to.not.be.undefined;
+        expect(cachedGenerator.value).to.eq('Unix Makefiles');
+        const newGenerator = 'Ninja';
+        expect(cachedGenerator.value).to.not.eq(newGenerator);
+    });
+});
diff --git a/test/unit-tests/kit-scan.test.ts b/test/unit-tests/kit-scan.test.ts
@@ -240,25 +240,130 @@ suite('Kits scan test', () => {
         }).timeout(10000);
     });
 
-    suite('VS Generator mapping', () => {
-        test('returns correct generator for VS 2022', () => {
-            expect(kit.vsGeneratorForVersion('17')).to.eq('Visual Studio 17 2022');
+    suite('Kit change detection for generator regression (#4890)', () => {
+        // These tests verify kitChangeNeedsClean correctly detects generator-related
+        // kit changes, which is the safety net for the regression fixed in #4890.
+
+        test('Returns false for null old kit (first kit selection)', () => {
+            const newKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: {
+                    name: 'Visual Studio 18 2026',
+                    platform: 'x64',
+                    toolset: 'host=x64'
+                }
+            };
+            expect(kit.kitChangeNeedsClean(newKit, null)).to.be.false;
         });
 
-        test('returns correct generator for VS 2026', () => {
-            expect(kit.vsGeneratorForVersion('18')).to.eq('Visual Studio 18 2026');
+        test('Returns true when preferredGenerator changes from undefined to VS generator', () => {
+            const oldKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true
+                // preferredGenerator is undefined — simulates kit scanned before VS 2026 mapping
+            };
+            const newKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: {
+                    name: 'Visual Studio 18 2026',
+                    platform: 'x64',
+                    toolset: 'host=x64'
+                }
+            };
+            expect(kit.kitChangeNeedsClean(newKit, oldKit)).to.be.true;
+        });
+
+        test('Returns false when kits have identical preferredGenerator', () => {
+            const generator = {
+                name: 'Visual Studio 18 2026',
+                platform: 'x64',
+                toolset: 'host=x64'
+            };
+            const oldKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: { ...generator }
+            };
+            const newKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: { ...generator }
+            };
+            expect(kit.kitChangeNeedsClean(newKit, oldKit)).to.be.false;
         });
 
-        test('returns correct generator for VS 2019', () => {
-            expect(kit.vsGeneratorForVersion('16')).to.eq('Visual Studio 16 2019');
+        test('Returns true when switching from VS generator to no generator', () => {
+            const oldKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: {
+                    name: 'Visual Studio 18 2026',
+                    platform: 'x64',
+                    toolset: 'host=x64'
+                }
+            };
+            const newKit: kit.Kit = {
+                name: 'GCC 12.0.0',
+                isTrusted: true
+                // No preferredGenerator — typical GCC kit uses Ninja default
+            };
+            expect(kit.kitChangeNeedsClean(newKit, oldKit)).to.be.true;
         });
 
-        test('returns undefined for unknown version', () => {
-            expect(kit.vsGeneratorForVersion('99')).to.be.undefined;
+        test('Returns true when generator name changes between VS versions', () => {
+            const oldKit: kit.Kit = {
+                name: 'Visual Studio Community 2022 Release - amd64',
+                visualStudio: 'VisualStudio.17.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: {
+                    name: 'Visual Studio 17 2022',
+                    platform: 'x64',
+                    toolset: 'host=x64'
+                }
+            };
+            const newKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true,
+                preferredGenerator: {
+                    name: 'Visual Studio 18 2026',
+                    platform: 'x64',
+                    toolset: 'host=x64'
+                }
+            };
+            expect(kit.kitChangeNeedsClean(newKit, oldKit)).to.be.true;
         });
 
-        test('returns correct generator for legacy VS120COMNTOOLS', () => {
-            expect(kit.vsGeneratorForVersion('VS120COMNTOOLS')).to.eq('Visual Studio 12 2013');
+        test('Returns false when both kits have no preferredGenerator', () => {
+            const oldKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true
+            };
+            const newKit: kit.Kit = {
+                name: 'Visual Studio Community 2026 Release - amd64',
+                visualStudio: 'VisualStudio.18.0',
+                visualStudioArchitecture: 'x64',
+                isTrusted: true
+            };
+            expect(kit.kitChangeNeedsClean(newKit, oldKit)).to.be.false;
         });
     });
 
