Fix clang-cl vendor detection returning 'unknown vendor'

Copilot · snehara99 · Copilot · commit f995106ddc56 · 2026-02-03T20:29:47.000Z
Co-authored-by: snehara99 &lt;113148726+snehara99@users.noreply.github.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,7 @@ Bug Fixes:
 - Fix user-level tasks defined in `~/.config/Code/User/tasks.json` causing infinite spinner. [#4659](https://github.com/microsoft/vscode-cmake-tools/pull/4659)
 - Fix "Copy Value" in CMake debugger copying variable name instead of value. [#4551](https://github.com/microsoft/vscode-cmake-tools/issues/4551)
 - cmakeDriver: Fixes getCompilerVersion by using compilerPath instead of compilerName. [#4647](https://github.com/microsoft/vscode-cmake-tools/pull/4647) [@lygstate](https://github.com/lygstate)
+- Fix kit detection returning "unknown vendor" when using clang-cl compiler. [#4685](https://github.com/microsoft/vscode-cmake-tools/issues/4685)
 
 ## 1.22
 
diff --git a/src/kits/kit.ts b/src/kits/kit.ts
@@ -239,9 +239,12 @@ export async function getKitDetect(kit: Kit): Promise<KitDetect> {
         if (!vs) {
             return kit;
         }
+        // Determine if the compiler is clang-cl based on binary name
+        const isClangCl = c_bin ? (path.basename(c_bin, '.exe') === 'clang-cl') : false;
+        const clangVendor: CompilerVendorEnum = isClangCl ? 'ClangCl' : 'Clang';
         let version: CompilerVersion | null = null;
         if (c_bin) {
-            version = await getCompilerVersion('Clang', c_bin);
+            version = await getCompilerVersion(clangVendor, c_bin);
         }
         let targetArch = kit.preferredGenerator?.platform ?? kit.visualStudioArchitecture ?? 'i686';
         if (targetArch === 'win32') {
@@ -251,7 +254,7 @@ export async function getKitDetect(kit: Kit): Promise<KitDetect> {
         let versionCompiler = vs.installationVersion;
         let vendor: CompilerVendorEnum;
         if (version !== null) {
-            vendor = 'Clang';
+            vendor = clangVendor;
             versionCompiler = version.version;
         } else {
             vendor = `MSVC`;
@@ -271,6 +274,18 @@ export async function getKitDetect(kit: Kit): Promise<KitDetect> {
         } else if (kit.name.startsWith('Clang-cl')) {
             vendor = 'ClangCl';
         }
+        // Fallback: detect vendor from compiler binary path if name pattern doesn't match
+        if (vendor === undefined && c_bin) {
+            const binBasename = path.basename(c_bin, '.exe').toLowerCase();
+            if (binBasename === 'clang-cl' || binBasename.startsWith('clang-cl-')) {
+                vendor = 'ClangCl';
+            } else if (binBasename === 'clang' || binBasename.startsWith('clang-')) {
+                vendor = 'Clang';
+            } else if (binBasename === 'gcc' || binBasename.startsWith('gcc-') ||
+                       binBasename.endsWith('-gcc') || binBasename.includes('-gcc-')) {
+                vendor = 'GCC';
+            }
+        }
         if (vendor === undefined) {
             return kit;
         }
@@ -280,7 +295,11 @@ export async function getKitDetect(kit: Kit): Promise<KitDetect> {
             version = await getCompilerVersion(vendor, c_bin);
         }
         if (!version) {
-            return kit;
+            // Return at least the vendor information even when version detection fails
+            return {
+                ...kit,
+                vendor
+            };
         }
         return {
             vendor,
@@ -863,7 +882,8 @@ async function scanDirForClangForMSVCKits(dir: PathWithTrust, vsInstalls: VSInst
             return null;
         }
 
-        const version = dir.isTrusted ? await getCompilerVersion('Clang', binPath) : null;
+        const clangVendor: CompilerVendorEnum = isClangMsvcCli ? 'ClangCl' : 'Clang';
+        const version = dir.isTrusted ? await getCompilerVersion(clangVendor, binPath) : null;
         if (dir.isTrusted && version === null) {
             return null;
         }
@@ -896,7 +916,9 @@ async function scanDirForClangForMSVCKits(dir: PathWithTrust, vsInstalls: VSInst
             const vsArch = (version?.target && version.target.triple.includes('i686-pc')) ? 'x86' : 'x64';
             const archForKitName = vsArch === 'x86' ? 'x86' : 'amd64';
             const clangArchPath = (vsArch === "x64") ? "x64\\" : "";
-            const clangKitName: string = `Clang ${version?.version} ${clang_cli} - ${archForKitName} for MSVC ${vs.installationVersion} (${install_name})`;
+            // Use 'Clang-cl' prefix for clang-cl.exe, 'Clang' for clang.exe to match vendor detection pattern
+            const clangNamePrefix = isClangMsvcCli ? 'Clang-cl' : 'Clang';
+            const clangKitName: string = `${clangNamePrefix} ${version?.version} ${clang_cli} - ${archForKitName} for MSVC ${vs.installationVersion} (${install_name})`;
             const clangExists = async () => {
                 const exists = binPath.startsWith(`${vs.installationPath}\\VC\\Tools\\Llvm\\${clangArchPath}bin`) && await util.checkFileExists(util.lightNormalizePath(binPath));
                 return exists;
diff --git a/test/unit-tests/kit-scan.test.ts b/test/unit-tests/kit-scan.test.ts
@@ -234,4 +234,113 @@ suite('Kits scan test', () => {
             ]);
         }).timeout(10000);
     });
+
+    suite('getKitDetect vendor detection from binary path', () => {
+        test('Detect ClangCl vendor from clang-cl binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: 'C:/path/to/clang-cl.exe',
+                    CXX: 'C:/path/to/clang-cl.exe'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            // When not trusted, getKitDetect returns the original kit with vendor from binary path detection
+            // Since the binary doesn't exist and we can't get version, it should still detect vendor from path
+            expect(detect.vendor).to.eq('ClangCl');
+        });
+
+        test('Detect Clang vendor from clang binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: '/usr/bin/clang',
+                    CXX: '/usr/bin/clang++'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            expect(detect.vendor).to.eq('Clang');
+        });
+
+        test('Detect GCC vendor from gcc binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: '/usr/bin/gcc',
+                    CXX: '/usr/bin/g++'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            expect(detect.vendor).to.eq('GCC');
+        });
+
+        test('Detect GCC vendor from versioned gcc binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: '/usr/bin/gcc-11',
+                    CXX: '/usr/bin/g++-11'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            expect(detect.vendor).to.eq('GCC');
+        });
+
+        test('Detect Clang vendor from versioned clang binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: '/usr/bin/clang-14',
+                    CXX: '/usr/bin/clang++-14'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            expect(detect.vendor).to.eq('Clang');
+        });
+
+        test('Detect ClangCl vendor from versioned clang-cl binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: 'C:/LLVM/bin/clang-cl-14.exe',
+                    CXX: 'C:/LLVM/bin/clang-cl-14.exe'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            expect(detect.vendor).to.eq('ClangCl');
+        });
+
+        test('Detect GCC vendor from cross-compiler gcc binary path', async () => {
+            const testKit: kit.Kit = {
+                name: 'Custom Kit Name',
+                compilers: {
+                    C: '/opt/toolchain/arm-linux-gnueabihf-gcc',
+                    CXX: '/opt/toolchain/arm-linux-gnueabihf-g++'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            expect(detect.vendor).to.eq('GCC');
+        });
+
+        test('Return original kit when vendor cannot be detected', async () => {
+            const testKit: kit.Kit = {
+                name: 'Unknown Kit',
+                compilers: {
+                    C: '/usr/bin/unknown-compiler',
+                    CXX: '/usr/bin/unknown-compiler++'
+                },
+                isTrusted: false
+            };
+            const detect = await kit.getKitDetect(testKit);
+            // Should return original kit when vendor cannot be detected
+            expect(detect.vendor).to.be.undefined;
+        });
+    });
 });
