Provide CMAKE_LANG_IMPLICIT_INCLUDE_DIRECTORIES as system includes

Author: huangqinjin

src/cpptools.ts

@@ -468,9 +468,10 @@ export class CppConfigurationProvider implements cpptools.CustomConfigurationPro
 
         const targetFromToolchains = compilerToolchains?.target;
         const targetArchFromToolchains = targetFromToolchains ? parseTargetArch(targetFromToolchains) : undefined;
+        const compilerImplicitIncludes = compilerToolchains?.implicitIncludes?.map(util.platformNormalizePath) || [];
 
         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 [];
@@ -512,12 +513,33 @@ export class CppConfigurationProvider implements cpptools.CustomConfigurationPro
         }
         if (targetFromToolchains) {
             if (useFragments) {
-                compileCommandFragments = compileCommandFragments.slice(0);
                 compileCommandFragments.push(`--target=${targetFromToolchains}`);
             } else {
                 flags.push(`--target=${targetFromToolchains}`);
             }
         }
+        if (compilerImplicitIncludes.length > 0) {
+            // Extract the stem from compiler path.
+            const compilerId = compilerPath.toLocaleLowerCase()
+                .match(/(?:^|[-\/\\])(cl|clang-cl|clang\+\+|clang|g\+\+|gcc)(?:$|[-.])/)?.[1] || "";
+
+            const includeFlag = {
+                "cl": "/external:I",
+                "clang-cl": "-imsvc",
+                "clang++": "-isystem",
+                "clang": "-isystem",
+                "g++": "-isystem",
+                "gcc": "-isystem"
+            }[compilerId] || "-I";
+
+            for (const implicitInclude of compilerImplicitIncludes) {
+                if (useFragments) {
+                    compileCommandFragments.push(`${includeFlag}${shlex.quote(implicitInclude)}`);
+                } else {
+                    flags.push(`${includeFlag}${implicitInclude}`);
+                }
+            }
+        }
 
         this.workspaceBrowseConfiguration = {
             browsePath: newBrowsePath,

src/drivers/cmakeFileApi.ts

@@ -594,11 +594,7 @@ export async function loadToolchains(filename: string): Promise<Map<string, Code
 
     return toolchains.toolchains.reduce((acc, el) => {
         if (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 });
-            }
+            acc.set(el.language, { path: el.compiler.path, implicitIncludes: el.compiler.implicit.includeDirectories });
         }
         return acc;
     }, new Map<string, CodeModelToolchain>());

src/drivers/codeModel.ts

@@ -12,7 +12,7 @@ export type CodeModelFileGroup = api.CodeModel.FileGroup & { frameworks?: { path
 export type CodeModelProject = api.CodeModel.Project;
 // TODO: If requested, move folder, dependencies, and isGeneratorProvided definition to the public API repo to avoid this intersection type.
 export type CodeModelTarget = api.CodeModel.Target & { folder?: { name: string }; dependencies?: { backtrace: number; id: string }[]; isGeneratorProvided?: boolean; install?: {destinations: {path: string}[];  prefix: {path: string}}};
-export type CodeModelToolchain = api.CodeModel.Toolchain;
+export type CodeModelToolchain = api.CodeModel.Toolchain & { implicitIncludes?: string[] };
 export type TargetTypeString = api.CodeModel.TargetType;
 
 /**