allow active project selection control intellisense (#4877)

Co-authored-by: Hannia Valera <[email protected]>

Author: Omotola

CHANGELOG.md

@@ -51,6 +51,7 @@ Improvements:
 
 Bug Fixes:
 - Fix stale C/C++ custom-configuration entries persisting after reconfigure/preset switches, which could cause Go to Definition/IntelliSense to surface symbols from inactive sources in the same folder. [#4472](https://github.com/microsoft/vscode-cmake-tools/issues/4472)
+- Fix IntelliSense not updating when switching the active project in multi-project workspaces with multiple `cmake.sourceDirectory` entries. [#4390](https://github.com/microsoft/vscode-cmake-tools/issues/4390)
 - Fix `tasks.json` schema validation rejecting valid CMake task commands `package` and `workflow`. [#4167](https://github.com/microsoft/vscode-cmake-tools/issues/4167)
 - Import the `EXTERNAL_INCLUDE` environment variable from the VS developer environment so that MSVC's external-header diagnostic suppression works correctly. [#4217](https://github.com/microsoft/vscode-cmake-tools/issues/4217)
 - Fix test presets not automatically switching when the build preset changes in multi-config generator setups (e.g., Ninja Multi-Config). The extension now auto-selects a compatible test preset after a build preset change, and properly considers build type when guessing the test preset. [#4395](https://github.com/microsoft/vscode-cmake-tools/issues/4395)

src/cpptools.ts

@@ -363,6 +363,18 @@ export class CppConfigurationProvider implements cpptools.CustomConfigurationPro
     private getConfiguration(uri: vscode.Uri): cpptools.SourceFileConfigurationItem | undefined {
         const normalizedPath = util.platformNormalizePath(uri.fsPath);
         const configurations = this.fileIndex.get(normalizedPath);
+
+        // If we have an active folder, only provide configurations for files
+        // that belong to that folder's project. This ensures IntelliSense
+        // reflects the active project in multi-project workspaces.
+        if (this.activeFolder) {
+            const activeFolderFiles = this.fileIndexByFolder.get(this.activeFolder);
+            if (!activeFolderFiles?.has(normalizedPath)) {
+                // This file is not part of the active folder's project
+                return undefined;
+            }
+        }
+
         if (this.activeTarget && configurations?.has(this.activeTarget)) {
             return configurations!.get(this.activeTarget);
         } else {
@@ -441,6 +453,22 @@ export class CppConfigurationProvider implements cpptools.CustomConfigurationPro
      */
     private activeTarget: string | null = null;
 
+    /**
+     * The active folder path. When set, IntelliSense configurations from this folder
+     * are preferred over configurations from other folders for shared source files.
+     */
+    private activeFolder: string | null = null;
+
+    /**
+     * Set the active folder for IntelliSense configuration resolution.
+     * When a file exists in multiple project folders, configurations from
+     * the active folder will be preferred.
+     * @param folder The folder path, or null to clear
+     */
+    setActiveFolder(folder: string | null) {
+        this.activeFolder = folder ? util.platformNormalizePath(folder) : null;
+    }
+
     private activeBuildType: string | null = null;
     private buildTypesSeen = new Set<string>();
 

src/extension.ts

@@ -977,6 +977,13 @@ export class ExtensionManager implements vscode.Disposable {
             this.onActiveProjectChangedEmitter.fire(vscode.Uri.file(activeProject.folderPath));
             const currentActiveFolderPath = this.activeFolderPath();
             await this.extensionContext.workspaceState.update('activeFolder', currentActiveFolderPath);
+
+            // Update IntelliSense to prefer configurations from the active project
+            this.configProvider.setActiveFolder(activeProject.folderPath);
+            if (this.cppToolsAPI && this.configProvider.ready) {
+                this.cppToolsAPI.didChangeCustomBrowseConfiguration(this.configProvider);
+                this.cppToolsAPI.didChangeCustomConfiguration(this.configProvider);
+            }
         }
     }
 

test/unit-tests/cpptools.test.ts

@@ -469,4 +469,95 @@ suite('CppTools tests', () => {
         expect(activeConfigurations.length).to.eq(1);
         expect(activeConfigurations[0].configuration.defines).to.contain('NEW');
     });
+
+    test('Prefers configurations from active folder in multi-project workspace', async () => {
+        const provider = new CppConfigurationProvider();
+        const cache = await CMakeCache.fromPath(getTestResourceFilePath('TestCMakeCache.txt'));
+
+        // Set up two folders with a file that exists in both
+        const folderA = here;
+        const folderB = path.join(here, '../smoke');
+        const sharedFileName = 'shared.cpp';
+        const fileInFolderA = path.join(folderA, sharedFileName);
+        const fileInFolderB = path.join(folderB, sharedFileName);
+
+        const codeModelA: codeModel.CodeModelContent = {
+            configurations: [{
+                name: 'Release',
+                projects: [{
+                    name: 'projectA',
+                    sourceDirectory: folderA,
+                    targets: [{
+                        name: 'targetA',
+                        type: 'EXECUTABLE',
+                        fileGroups: [{
+                            sources: [fileInFolderA],
+                            isGenerated: false,
+                            defines: ['PROJECT_A'],
+                            compileCommandFragments: ['-DPROJECT_A'],
+                            language: 'CXX'
+                        }]
+                    }]
+                }]
+            }],
+            toolchains: new Map<string, codeModel.CodeModelToolchain>()
+        };
+
+        const codeModelB: codeModel.CodeModelContent = {
+            configurations: [{
+                name: 'Release',
+                projects: [{
+                    name: 'projectB',
+                    sourceDirectory: folderB,
+                    targets: [{
+                        name: 'targetB',
+                        type: 'EXECUTABLE',
+                        fileGroups: [{
+                            sources: [fileInFolderB],
+                            isGenerated: false,
+                            defines: ['PROJECT_B'],
+                            compileCommandFragments: ['-DPROJECT_B'],
+                            language: 'CXX'
+                        }]
+                    }]
+                }]
+            }],
+            toolchains: new Map<string, codeModel.CodeModelToolchain>()
+        };
+
+        // Index both folders
+        provider.updateConfigurationData({ cache, codeModelContent: codeModelA, activeTarget: 'targetA', activeBuildTypeVariant: 'Release', folder: folderA });
+        provider.updateConfigurationData({ cache, codeModelContent: codeModelB, activeTarget: 'targetB', activeBuildTypeVariant: 'Release', folder: folderB });
+
+        // Without active folder set, both files should be available
+        let configsA = await provider.provideConfigurations([vscode.Uri.file(fileInFolderA)]);
+        let configsB = await provider.provideConfigurations([vscode.Uri.file(fileInFolderB)]);
+        expect(configsA.length).to.eq(1);
+        expect(configsB.length).to.eq(1);
+        expect(configsA[0].configuration.defines).to.contain('PROJECT_A');
+        expect(configsB[0].configuration.defines).to.contain('PROJECT_B');
+
+        // Set folderA as active - file in folderB should no longer provide configuration
+        provider.setActiveFolder(folderA);
+        configsA = await provider.provideConfigurations([vscode.Uri.file(fileInFolderA)]);
+        configsB = await provider.provideConfigurations([vscode.Uri.file(fileInFolderB)]);
+        expect(configsA.length).to.eq(1);
+        expect(configsA[0].configuration.defines).to.contain('PROJECT_A');
+        expect(configsB.length).to.eq(0); // Active folder doesn't have this file
+
+        // Switch active folder to B - file in folderA should no longer provide configuration
+        provider.setActiveFolder(folderB);
+        configsA = await provider.provideConfigurations([vscode.Uri.file(fileInFolderA)]);
+        configsB = await provider.provideConfigurations([vscode.Uri.file(fileInFolderB)]);
+        expect(configsA.length).to.eq(0); // Active folder doesn't have this file
+        expect(configsB.length).to.eq(1);
+        expect(configsB[0].configuration.defines).to.contain('PROJECT_B');
+
+        // Clear active folder - both should work again
+        provider.setActiveFolder(null);
+        configsA = await provider.provideConfigurations([vscode.Uri.file(fileInFolderA)]);
+        configsB = await provider.provideConfigurations([vscode.Uri.file(fileInFolderB)]);
+        expect(configsA.length).to.eq(1);
+        expect(configsB.length).to.eq(1);
+    });
 });