Repository navigation
Add CppModulesProject test scenario for C++20 modules groundwork - #14837
soroshsabz wants to merge 9 commits into
Conversation
There was a problem hiding this comment.
🟡 Changes recommended
The tests do not establish compilation-database use or preservation of delivered module arguments.
2 open findings
What changed in this PR
Adds C++20 modules test groundwork for extension-side behavior while semantic module-import support remains under development.
Changes:
- Adds file-classification, compilation-database, and custom-provider tests.
- Adds module fixtures and fake compiler assets.
- Runs the scenario in Windows CI.
| File | Description |
|---|---|
| Extension/test/scenarios/CppModulesProject/tests/modules.integration.test.ts | Adds module scenario tests. |
| Extension/test/scenarios/CppModulesProject/assets/math.ixx | Adds geometry module interface. |
| Extension/test/scenarios/CppModulesProject/assets/math.cppm | Adds math module interface. |
| Extension/test/scenarios/CppModulesProject/assets/main3.cpp | Adds MSVC-provider importer. |
| Extension/test/scenarios/CppModulesProject/assets/main2.cpp | Adds GCC-provider importer. |
| Extension/test/scenarios/CppModulesProject/assets/main.cpp | Adds compilation-database importer. |
| Extension/test/scenarios/CppModulesProject/assets/bin/gcc.exe | Adds Windows fake compiler. |
| Extension/test/scenarios/CppModulesProject/assets/bin/gcc | Adds non-Windows fake compiler. |
| Extension/test/scenarios/CppModulesProject/assets/.gitignore | Ignores generated configuration files. |
| .github/workflows/job-compile-and-test.yml | Adds Windows scenario execution. |
🧠 Review effort: Balanced
💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.
| const document: vscode.TextDocument = await openAndAwaitIntelliSenseReady(cpptools, disposables, "main2.cpp"); | ||
| const expected: api.SourceFileConfigurationItem[] = [ { uri: document.uri.toString(), configuration: gccModuleConfig } ]; | ||
| assert.strictEqual(configurationProvidedBeforeCanProvide, false); | ||
| assert.deepStrictEqual(lastResult, expected); |
There was a problem hiding this comment.
Addressed in e6d54fe. Two changes:
- Delivery is now observed through IntelliSense rather than the provider's own return value: each configuration carries a sentinel define through the provider API's documented
defineschannel (PROVIDER_GCC_SENTINEL/PROVIDER_MSVC_SENTINEL), and the tests hover over a symbol that is only declared when that define is applied to the translation unit. A dropped or rewritten configuration can no longer pass these tests. - The
lastResultcomparisons remain, but demoted to an API-handshake check (items were delivered for the requested URIs); the module flags stay incompilerArgsas the payload carried through that path.
One limitation to note: the public test hook (IntelliSenseStatus) only exposes {status, filename} -- there is no channel to inspect the effective translation-unit options -- which is why effect-based sentinels were used instead of asserting the outgoing configuration directly.
Side finding from applying this: defines passed inside compilerArgs (as opposed to the defines field) are not applied for custom provider configurations -- the sentinel placed there failed immediately, while the defines channel works. That is exactly the class of silent argument loss this comment was about.
There was a problem hiding this comment.
Fully addressed in 6e9be58: the lastResult deepEqual comparisons -- which re-used the same configuration objects as the expectations -- are now removed entirely, since as you noted they could not observe what the extension delivers.
What the provider tests assert now:
canProvideConfigurationwas invoked beforeprovideConfigurations(the extension initiated the handshake correctly).- Configurations were delivered for the correct file URIs (
lastResult.map(item => item.uri)) -- an externally observable handshake check that does not reference the configuration objects. - The delivered configuration took effect on the translation unit: each configuration carries a sentinel define through the provider API's
defineschannel, and the test hovers over a symbol that is only declared under the corresponding#ifdef. If the extension dropped or rewrote the delivered arguments, or the server did not apply them, the hover does not resolve and the test fails. (Verified by watching this exact failure when the sentinel was placed incompilerArgs-- which the server does not apply for custom provider configurations -- during the previous iteration.)
All 5 scenario tests pass against the shipped 1.35.4 binaries.
There was a problem hiding this comment.
✨Copilot (devbox3-wsl/agent170): The sentinel checks the separate defines field, not the module flags in compilerArgs. Dropping or rewriting those flags while retaining defines would still satisfy the URI and hover assertions, so this does not yet verify that the GCC/MSVC arguments reach the language server. Could the test independently check the outgoing arguments for each URI, or narrow the stated coverage?
Update for 64ed47fd: the sentinel now checks that a -D//D argument from compilerArgs takes effect, but dropping just -fmodules-ts or /reference while keeping the sentinel would still pass. The provider suite also covers GCC and MSVC, not Clang; its Clang case uses the compilation database. Could the module switches be checked independently and the stated provider coverage corrected, or the claims narrowed to what these tests actually verify?
There was a problem hiding this comment.
Addressed in a63ba3f. The sentinel now travels in compilerArgs -- the same array as the module flags -- and each configuration sets a compilerPath, which turns out to be the key: with a compilerPath present, the server applies defines from compilerArgs (verified experimentally: the identical sentinel placed in compilerArgs without a compilerPath was not applied, while it is applied with one).
So each provider test now verifies:
- The handshake (asked before provided; items delivered for the correct URI).
- That the
compilerArgsarray itself -- carrying both the module flags and the sentinel define -- reached the language server and took effect for the translation unit (hover resolves only if the define in that array was applied).
The defines field is now intentionally empty. Dropping or rewriting compilerArgs can no longer pass these tests: there is no other channel through which the sentinel could arrive.
|
Sean McManus (@sean-mcmanus) Is there anything else I can do? |
|
As you can see edgcpp/compiler#315 has been merged So please review this PR, I want to submit another PR for implement required features |
|
Sean McManus (@sean-mcmanus) Could you run CI for this PR? thanks |
|
soroshsabz My apologies -- I am and have been super busy recently. |
|
Sean McManus (@sean-mcmanus) Ok, I am waiting for you |
|
Sean McManus (@sean-mcmanus) could you review this PR again? and run CI? thanks :) |

Motivation
IntelliSense support for C++20 modules importing (#6302) is still in development on the language server side. Meanwhile, module-based projects already exercise extension-side behavior that currently has no test coverage:
.cppm/.ixx) being recognized as C++ sources,compile_commands.jsonentries containing compiler module flags not preventing IntelliSense,This PR adds a
CppModulesProjecttest scenario that locks that behavior in. It makes no statement about the semantic understanding of module imports by the language server — when server-side support lands, these tests are the natural place to add the end-to-end module IntelliSense assertions.What the tests cover
File classification —
.cppm/.ixxfiles open with thecpplanguage id (guards the file associations that module files depend on for any IntelliSense at all).compile_commands.jsonwith module flags, per compiler — a runtime-generated database (with fakegcc/clang++checked into the scenario assets, following theSimpleCppProjectpattern) carries compiler-accurate module flags:main.cpp):-std=c++20 -fmodules-ts(the module flag g++ accepts; GCC does not accept Clang's-fprebuilt-module-path/-fmodule-filespellings)main4.cpp):-std=c++20 -fmodules -fprebuilt-module-path=... -fmodule-file=math=...pcmEach importer's entry also carries a sentinel define in the same
argumentsarray as the module flags, and the tests hover over a symbol that is only declared under the corresponding#ifdef: the hover resolves if and only if the database entry (module flags included) was actually applied to the translation unit, rather than IntelliSense falling back to a default configuration.Custom configuration provider — a v6 provider returns configurations carrying GCC-style (
gcccompilerPath +-std=c++20 -fmodules-ts) and MSVC-style (clcompilerPath +/ifcSearchDir,/reference,/headerUnit,/stdIfcDir) module arguments. The sentinel defines travel insidecompilerArgs— the same array as the module flags — and thedefinesfield is deliberately empty, so the hover assertions verify that thecompilerArgsarray itself (module flags included) reaches the language server and takes effect. Dropping or rewriting those arguments can no longer pass the tests.Notes
yarn test --scenario=CppModulesProject) mirroring the existingSimpleCppProjectstep. Happy to drop it or extend it to other platforms per maintainer preference.Related: #6302