Pass mandatory compiler arguments from CMake 4.3 to cpptools

The `CMAKE_<LANG>_COMPILER` variable or the `CC` or similar environment
variable can contain command line arguments that must be passed to every
invocation of the compiler. Previously, these were lost on the way from
CMake to cpptools because the CMake file API did not expose them, causing
non-working code navigation after cpptools called the compiler without them
to determine system include paths and built-in preprocessor macro
definitions.

CMake 4.3 adds a new `commandFragment` member to the `toolchains.
toolchains[].compiler` object to rectify that. Pass that along in
configuration provider responses.

Author: cwalther

CHANGELOG.md

@@ -1,5 +1,11 @@
 # What's New?
 
+## 1.22
+
+Features:
+
+- Pass mandatory compiler arguments from `CMAKE_<LANG>_COMPILER` to cpptools so it can properly determine system include paths and built-in preprocessor macro definitions. Requires CMake 4.3 or newer. [#4627](https://github.com/microsoft/vscode-cmake-tools/pull/4627) [@cwalther](https://github.com/cwalther)
+
 ## 1.21
 
 Features:

package.json

@@ -4011,7 +4011,7 @@
     "tsconfig-paths": "^3.11.0",
     "tslint": "^6.1.3",
     "typescript": "^4.1.5",
-    "vscode-cmake-tools": "^1.5.0",
+    "vscode-cmake-tools": "^1.6.0",
     "vscode-nls-dev": "^3.3.2",
     "webpack": "^5.94.0",
     "webpack-cli": "^4.5.0"

src/cpptools.ts

@@ -449,22 +449,34 @@ export class CppConfigurationProvider implements cpptools.CustomConfigurationPro
         const targetArchFromToolchains = targetFromToolchains ? parseTargetArch(targetFromToolchains) : undefined;
 
         const normalizedCompilerPath = util.platformNormalizePath(compilerPath);
-        let compileCommandFragments = useFragments ? (fileGroup.compileCommandFragments || target.compileCommandFragments) : [];
+        const compileCommandFragments = useFragments ? (fileGroup.compileCommandFragments || target.compileCommandFragments).slice(0) : [];
         const getAsFlags = (fragments?: string[]) => {
             if (!fragments) {
                 return [];
             }
             return [...util.flatMap(fragments, fragment => shlex.split(fragment))];
         };
-        let flags: string[] = [];
+        const flags: string[] = [];
         let extraDefinitions: string[] = [];
         let standard: StandardVersion;
         let targetArch: Architecture;
         let intelliSenseMode: IntelliSenseMode;
         let defines = (fileGroup.defines || target.defines || []);
-        if (!useFragments) {
+        if (useFragments) {
+            if (compilerToolchains?.commandFragment) {
+                compileCommandFragments.unshift(compilerToolchains.commandFragment);
+            }
+        } else {
+            if (compilerToolchains?.commandFragment) {
+                // This is incorrect: shlex.split() does not do what one would
+                // expect, it treats quotes and backslashes differently than a
+                // shell would. But maybe it's good enough for a legacy codepath,
+                // what are the chances that anyone has old CppTools but new
+                // CMake Tools and new CMake?
+                flags.push(...shlex.split(compilerToolchains.commandFragment));
+            }
             // Send the intelliSenseMode and standard only for CppTools API v5 and below.
-            flags = getAsFlags(fileGroup.compileCommandFragments || target.compileCommandFragments);
+            flags.push(...getAsFlags(fileGroup.compileCommandFragments || target.compileCommandFragments));
             ({ extraDefinitions, standard, targetArch } = parseCompileFlags(this.cpptoolsVersion, flags, lang));
             defines = defines.concat(extraDefinitions);
             intelliSenseMode = getIntelliSenseMode(this.cpptoolsVersion, compilerPath, targetArchFromToolchains ?? targetArch);
@@ -491,7 +503,6 @@ export class CppConfigurationProvider implements cpptools.CustomConfigurationPro
         }
         if (targetFromToolchains) {
             if (useFragments) {
-                compileCommandFragments = compileCommandFragments.slice(0);
                 compileCommandFragments.push(`--target=${targetFromToolchains}`);
             } else {
                 flags.push(`--target=${targetFromToolchains}`);

src/drivers/cmakeFileApi.ts

@@ -200,6 +200,7 @@ export namespace Toolchains {
 
     export interface Compiler {
         path?: string;
+        commandFragment?: string;
         id?: string;
         version?: string;
         target?: string;
@@ -594,11 +595,15 @@ export async function loadToolchains(filename: string): Promise<Map<string, Code
 
     return toolchains.toolchains.reduce((acc, el) => {
         if (el.compiler.path) {
+            const tc: CodeModelToolchain = { path: el.compiler.path };
             if (el.compiler.target) {
-                acc.set(el.language, { path: el.compiler.path, target: el.compiler.target });
-            } else {
-                acc.set(el.language, { path: el.compiler.path });
+                tc.target = el.compiler.target;
             }
+            if (el.compiler.commandFragment) {
+                // available (optional) since toolchains object version 1.1 (CMake 4.3)
+                tc.commandFragment = el.compiler.commandFragment;
+            }
+            acc.set(el.language, tc);
         }
         return acc;
     }, new Map<string, CodeModelToolchain>());

test/unit-tests/cpptools.test.ts

@@ -227,13 +227,20 @@ suite('CppTools tests', () => {
                         }]
                 }]
             }],
-            toolchains: new Map<string, codeModel.CodeModelToolchain>([['CXX', { path: 'path_from_toolchain_object' }]])
+            toolchains: new Map<string, codeModel.CodeModelToolchain>([['CXX', {
+                path: 'path_from_toolchain_object',
+                commandFragment: '--fragment from -toolchain=object'
+            }]])
         };
 
         provider.updateConfigurationData({ cache, codeModelContent: codeModel3, activeTarget: 'target3', activeBuildTypeVariant: 'Release', folder: smokeFolder });
         let configurations = await provider.provideConfigurations([vscode.Uri.file(sourceFile3)]);
         expect(configurations.length).to.eq(1);
         expect(configurations[0].configuration.compilerPath).to.eq('path_from_toolchain_object');
+        expect(configurations[0].configuration.compilerFragments).to.be.undefined;
+        expect(configurations[0].configuration.compilerArgs?.[0]).to.eq('--fragment');
+        expect(configurations[0].configuration.compilerArgs?.[1]).to.eq('from');
+        expect(configurations[0].configuration.compilerArgs?.[2]).to.eq('-toolchain=object');
 
         configurations = await provider.provideConfigurations([uri1]);
         expect(configurations.length).to.eq(1);
@@ -333,13 +340,18 @@ suite('CppTools tests', () => {
                         }]
                 }]
             }],
-            toolchains: new Map<string, codeModel.CodeModelToolchain>([['CXX', { path: 'path_from_toolchain_object' }]])
+            toolchains: new Map<string, codeModel.CodeModelToolchain>([['CXX', {
+                path: 'path_from_toolchain_object',
+                commandFragment: '--fragment "from" -toolchain=object'
+            }]])
         };
 
         provider.updateConfigurationData({ cache, codeModelContent: codeModel3, activeTarget: 'target3', activeBuildTypeVariant: 'Release', folder: smokeFolder });
         let configurations = await provider.provideConfigurations([vscode.Uri.file(sourceFile3)]);
         expect(configurations.length).to.eq(1);
         expect(configurations[0].configuration.compilerPath).to.eq('path_from_toolchain_object');
+        expect(configurations[0].configuration.compilerFragments?.[0]).to.eq('--fragment "from" -toolchain=object');
+        expect(configurations[0].configuration.compilerArgs).to.be.empty;
 
         configurations = await provider.provideConfigurations([uri1]);
         expect(configurations.length).to.eq(1);

test/unit-tests/driver/driver-codemodel-tests.ts

@@ -3,6 +3,7 @@ import { CMakeExecutable, getCMakeExecutableInformation } from '@cmt/cmakeExecut
 import { ConfigurationReader } from '@cmt/config';
 import { ConfigureTrigger } from '@cmt/cmakeProject';
 import { CodeModelContent } from '@cmt/drivers/codeModel';
+import { versionLess } from '@cmt/util';
 import * as chai from 'chai';
 import { expect } from 'chai';
 import * as chaiString from 'chai-string';
@@ -283,5 +284,40 @@ export function makeCodeModelDriverTestsuite(driverName: string, driver_generato
                 expect(sources).to.include(path.normalize(sourcefile_name).toLowerCase());
             }
         }).timeout(90000);
+
+        function testToolchain(withArguments: boolean) {
+            return async function (this: Mocha.Context) {
+                const cmakeVersion = (await getCMakeExecutableInformation(cmakePath)).version ?? { major: 0, minor: 0, patch: 0 };
+                // toolchains was only added to the file API in CMake 3.20
+                // also, CMAKE_<LANG>_COMPILER with arguments is only supported from CMake 3.19 on
+                if (versionLess(cmakeVersion, '3.20')) {
+                    this.skip();
+                }
+                const compiler = getTestRootFilePath(`test/fakebin/cross-compile-gcc${process.platform === 'win32' ? '.exe' : ''}`);
+                expect(compiler).to.satisfy(fs.existsSync, `${compiler} not found. Run 'yarn pretest-buildfakebin'.`);
+
+                const codemodel_data = await generateCodeModelForConfiguredDriver(
+                    this,
+                    [
+                        '-DCMAKE_TOOLCHAIN_FILE=toolchain-' + (withArguments ? 'with' : 'no') + '-args.cmake',
+                        '-DTEST_FULL_COMPILER_PATH=' + compiler
+                    ]
+                );
+                expect(codemodel_data).to.be.not.null;
+                const toolchain = codemodel_data?.toolchains?.get('CXX');
+                expect(toolchain).to.exist;
+                expect(toolchain?.path).to.equal(compiler);
+                // commandFragment was only added to the file API in CMake 4.3
+                if (!withArguments || versionLess(cmakeVersion, '4.2.20251203')) {
+                    expect(toolchain?.commandFragment).to.be.undefined;
+                } else {
+                    expect(toolchain?.commandFragment).to.equal('--hello world --something=other');
+                }
+            };
+        }
+
+        test('Test toolchain without compiler arguments', testToolchain(false)).timeout(90000);
+
+        test('Test toolchain with compiler arguments', testToolchain(true)).timeout(90000);
     });
 }

test/unit-tests/driver/workspace/test_project/toolchain-no-args.cmake

@@ -0,0 +1 @@
+set(CMAKE_CXX_COMPILER "${TEST_FULL_COMPILER_PATH}")

test/unit-tests/driver/workspace/test_project/toolchain-with-args.cmake

@@ -0,0 +1 @@
+set(CMAKE_CXX_COMPILER "${TEST_FULL_COMPILER_PATH};--hello;world;--something=other")