IntelliSense flags C++23 features (e.g., import std;, std::println) as errors with GCC 15.1; C++ standard options outdated

[Blinkion]

Environment

• OS and Version: Ubuntu 24.04 LTS
• VS Code Version: 1.100.2
• C/C++ Extension Version: 2.0.0
• If using SSH remote, specify OS of remote machine:

Bug Summary and Steps to Reproduce

Detailed Description:

The VS Code C/C++ extension's IntelliSense (provided by ms-vscode.cpptools) incorrectly reports errors for valid C++23 features, such as import std; and std::println(). This occurs when using GCC 15.1, a compiler that successfully compiles and runs this code with the appropriate C++23 flags (-std=c++23 -fmodules).

A key observation from the attached screenshot (which you should attach to the issue) is that while the code editor shows red squiggles under these C++23 constructs, the terminal output clearly shows successful compilation and execution of the same code.

Furthermore, the C++ standard selection in VS Code settings (e.g., C_Cpp.default.cppStandard or per-project c_cpp_properties.json) does not currently offer a "c++26" option. While C++26 is still under development, the existing "c++23" IntelliSense support appears to be lagging behind features already implemented and available in modern compilers like GCC 15.1.

Expected Behavior:

IntelliSense should accurately parse and recognize standard C++23 features like modules (import std;) and std::println without showing false positive errors when a compatible compiler (like GCC 15.1) is used and the cppStandard is configured to c++23.
The C++ standard selection options in VS Code's C/C++ extension settings should be updated more frequently to include newer standards (e.g., "c++26", even if initially experimental) to better align with ongoing C++ language evolution and compiler support.
The existing c++23 IntelliSense mode should offer comprehensive coverage for features widely supported by major compilers.
Compiler Information (from screenshot):

Compiler: GCC
Version: 15.1.0
Target: x86_64-pc-linux-gnu
Configuration Snippet from gcc -v: Configured with: ../../gcc-15-source/configure --prefix=/opt/gcc-15 --disable-multilib --enable-languages=c,c++
Thread model: posix
Supported LTO compression algorithms: zlib zstd
Steps to Reproduce:

Setup Environment:
Install GCC 15.1.0 (or a similarly capable C++23 compiler).
Ensure VS Code and the ms-vscode.cpptools C/C++ extension are installed and up to date.
Create Project & Configure:
Create a new C++ file (e.g., main.cc).
Populate main.cc with the following C++23 code:
C++

import std;

auto main() -> int {
std::println("Hello world");
return 0;
}
Configure the C/C++ extension settings (c_cpp_properties.json) to use cppStandard: "c++23" and point compilerPath to your GCC 15.1 g++. You might also need to add relevant compilerArgs like -fmodules or -fmodules-ts if IntelliSense requires them, though GCC 15.1 might handle module paths automatically for import std; when built correctly. Example c_cpp_properties.json configuration:
JSON

{
"configurations": [
{
"name": "Linux-GCC15",
"includePath": [
"${workspaceFolder}/**"
],
"defines": [],
"compilerPath": "/opt/gcc-15/bin/g++", // Adjust to your GCC 15.1 path
"cStandard": "c17",
"cppStandard": "c++23",
"intelliSenseMode": "linux-gcc-x64", // Or the mode corresponding to your GCC version
"compilerArgs": [
"-fmodules" // As seen working in your screenshot for compilation
]
}
],
"version": 4
}
Observe IntelliSense Errors:
Open main.cc in the VS Code editor.
Notice that IntelliSense incorrectly underlines import std; and std::println("Hello world"); as errors (e.g., "identifier "std" is undefined", "name followed by '::' must be a class or namespace name", "namespace "std" has no member "println"").
Verify Compilation (Outside VS Code or via Tasks):
Compile the code from the terminal using GCC 15.1 to confirm it's valid:
Bash

If you have a precompiled std module (e.g., bits/std.cc.gcm)

g++ -std=c++23 -fmodules -O2 -c -fmodule-only -fsearch-include-path bits/std.cc

(This step might not be needed if GCC finds the std module automatically)

g++ -std=c++23 -fmodules -O2 main.cc -o main
./main
Observe that the code compiles and runs successfully, printing "Hello world" (as shown in your screenshot).

Configuration and Logs

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/usr/include/c++/13",
                "/usr/include/x86_64-linux-gnu/c++/13",
                "/usr/include/c++/13/backward",
                "/usr/local/include",
                "/usr/include",
                "/usr/include/x86_64-linux-gnu"
            ],
            "defines": [],
            "intelliSenseMode": "linux-gcc-x64",
            "cStandard": "c23",
            "cppStandard": "c++23",
            "compilerPath": "/usr/bin/gcc"
        }
    ],
    "version": 4
}

Other Extensions

No response

Additional context

No response

[sean-mcmanus]

@Blinkion #6302 is tracking modules support.

c++23 hasn't been fully implemented yet by our core IntelliSense parser. See the red blocks in the EDG column at https://en.cppreference.com/w/cpp/compiler_support/23 .

Our 1.26.0+ pre-release has support for c++23 versus c++26 differentiation, and some additional language standard features.

Did you want to use this issue to track anything else in particular?