Make the project managers tell the code model about include paths

... from the environment.

Fixes: QTCREATORBUG-17985
Change-Id: I9b54e550121cfcc0684a6e173337d59d235c6107
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>

src/libs/utils/environment.cpp

@@ -275,9 +275,14 @@ FilePath Environment::searchInPath(const QString &executable,
 
 FilePathList Environment::path() const
 {
-    const QStringList pathComponents = value("PATH")
+    return pathListValue("PATH");
+}
+
+FilePathList Environment::pathListValue(const QString &varName) const
+{
+    const QStringList pathComponents = value(varName)
             .split(OsSpecificAspects::pathListSeparator(m_osType), QString::SkipEmptyParts);
-    return Utils::transform(pathComponents, &FilePath::fromUserInput);
+    return transform(pathComponents, &FilePath::fromUserInput);
 }
 
 void Environment::modifySystemEnvironment(const EnvironmentItems &list)

src/libs/utils/environment.h

@@ -68,6 +68,7 @@ public:
                           const PathFilter &func = PathFilter()) const;
 
     FilePathList path() const;
+    FilePathList pathListValue(const QString &varName) const;
     QStringList appendExeExtensions(const QString &executable) const;
 
     bool isSameExecutable(const QString &exe1, const QString &exe2) const;

src/plugins/autotoolsprojectmanager/autotoolsproject.cpp

@@ -275,5 +275,5 @@ void AutotoolsProject::updateCppCodeModel()
     rpp.setMacros(m_makefileParserThread->macros());
     rpp.setFiles(m_files);
 
-    m_cppCodeModelUpdater->update({this, kitInfo, {rpp}});
+    m_cppCodeModelUpdater->update({this, kitInfo, activeBuildEnvironment(), {rpp}});
 }

src/plugins/baremetal/iarewtoolchain.cpp

@@ -288,7 +288,8 @@ WarningFlags IarToolChain::warningFlags(const QStringList &cxxflags) const
     return WarningFlags::Default;
 }
 
-ToolChain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &) const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -312,9 +313,10 @@ ToolChain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner
 }
 
 HeaderPaths IarToolChain::builtInHeaderPaths(const QStringList &cxxFlags,
-                                             const FilePath &fileName) const
+                                             const FilePath &fileName,
+                                             const Environment &env) const
 {
-    return createBuiltInHeaderPathsRunner()(cxxFlags, fileName.toString(), "");
+    return createBuiltInHeaderPathsRunner(env)(cxxFlags, fileName.toString(), "");
 }
 
 void IarToolChain::addToEnvironment(Environment &env) const

src/plugins/baremetal/iarewtoolchain.h

@@ -63,9 +63,10 @@ public:
     Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const final;
     ProjectExplorer::WarningFlags warningFlags(const QStringList &cxxflags) const final;
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const final;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(const Utils::Environment &) const final;
     ProjectExplorer::HeaderPaths builtInHeaderPaths(const QStringList &cxxFlags,
-                                                    const Utils::FilePath &) const final;
+                                                    const Utils::FilePath &,
+                                                    const Utils::Environment &env) const final;
     void addToEnvironment(Utils::Environment &env) const final;
     ProjectExplorer::IOutputParser *outputParser() const final;
 

src/plugins/baremetal/keiltoolchain.cpp

@@ -298,7 +298,8 @@ WarningFlags KeilToolchain::warningFlags(const QStringList &cxxflags) const
     return WarningFlags::Default;
 }
 
-ToolChain::BuiltInHeaderPathsRunner KeilToolchain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner KeilToolchain::createBuiltInHeaderPathsRunner(
+        const Environment &) const
 {
     const Utils::FilePath compilerCommand = m_compilerCommand;
 
@@ -317,9 +318,10 @@ ToolChain::BuiltInHeaderPathsRunner KeilToolchain::createBuiltInHeaderPathsRunne
 }
 
 HeaderPaths KeilToolchain::builtInHeaderPaths(const QStringList &cxxFlags,
-                                              const FilePath &fileName) const
+                                              const FilePath &fileName,
+                                              const Environment &env) const
 {
-    return createBuiltInHeaderPathsRunner()(cxxFlags, fileName.toString(), "");
+    return createBuiltInHeaderPathsRunner(env)(cxxFlags, fileName.toString(), "");
 }
 
 void KeilToolchain::addToEnvironment(Environment &env) const

src/plugins/baremetal/keiltoolchain.h

@@ -63,9 +63,11 @@ public:
     Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const final;
     ProjectExplorer::WarningFlags warningFlags(const QStringList &cxxflags) const final;
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const final;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &) const final;
     ProjectExplorer::HeaderPaths builtInHeaderPaths(const QStringList &cxxFlags,
-                                                    const Utils::FilePath &) const final;
+                                                    const Utils::FilePath &,
+                                                    const Utils::Environment &env) const final;
     void addToEnvironment(Utils::Environment &env) const final;
     ProjectExplorer::IOutputParser *outputParser() const final;
 

src/plugins/baremetal/sdcctoolchain.cpp

@@ -274,34 +274,25 @@ WarningFlags SdccToolChain::warningFlags(const QStringList &cxxflags) const
     return WarningFlags::Default;
 }
 
-ToolChain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &) const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
 
     const Utils::FilePath compilerCommand = m_compilerCommand;
-    const Core::Id languageId = language();
     const Abi abi = m_targetAbi;
 
-    HeaderPathsCache headerPaths = headerPathsCache();
+    return [env, compilerCommand, abi](const QStringList &, const QString &, const QString &) {
-
+        return dumpHeaderPaths(compilerCommand, env.toStringList(), abi);
-    return [env, compilerCommand, headerPaths, languageId, abi](const QStringList &flags,
-                                                                const QString &fileName,
-                                                                const QString &) {
-        Q_UNUSED(flags)
-        Q_UNUSED(fileName)
-
-        const HeaderPaths paths = dumpHeaderPaths(compilerCommand, env.toStringList(), abi);
-        headerPaths->insert({}, paths);
-
-        return paths;
     };
 }
 
 HeaderPaths SdccToolChain::builtInHeaderPaths(const QStringList &cxxFlags,
-                                              const FilePath &fileName) const
+                                              const FilePath &fileName,
+                                              const Environment &env) const
 {
-    return createBuiltInHeaderPathsRunner()(cxxFlags, fileName.toString(), "");
+    return createBuiltInHeaderPathsRunner(env)(cxxFlags, fileName.toString(), "");
 }
 
 void SdccToolChain::addToEnvironment(Environment &env) const

src/plugins/baremetal/sdcctoolchain.h

@@ -63,9 +63,11 @@ public:
     Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const final;
     ProjectExplorer::WarningFlags warningFlags(const QStringList &cxxflags) const final;
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const final;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &) const final;
     ProjectExplorer::HeaderPaths builtInHeaderPaths(const QStringList &cxxFlags,
-                                                    const Utils::FilePath &) const final;
+                                                    const Utils::FilePath &,
+                                                    const Utils::Environment &env) const final;
     void addToEnvironment(Utils::Environment &env) const final;
     ProjectExplorer::IOutputParser *outputParser() const final;
 

src/plugins/cmakeprojectmanager/cmakeproject.cpp

@@ -405,7 +405,7 @@ void CMakeProject::updateProjectData(CMakeBuildConfiguration *bc)
                 rpp.setFlagsForC({kitInfo.cToolChain, rpp.flagsForC.commandLineFlags});
         }
 
-        m_cppCodeModelUpdater->update({this, kitInfo, rpps});
+        m_cppCodeModelUpdater->update({this, kitInfo, activeBuildEnvironment(), rpps});
     }
     {
         TraceTimer qmlCodemodelTimer("    qml codemodel");

src/plugins/cmakeprojectmanager/tealeafreader.cpp

@@ -311,8 +311,10 @@ static void processCMakeIncludes(const CMakeBuildTarget &cbt, const ToolChain *t
     if (!tc)
         return;
 
-    foreach (const HeaderPath &hp, tc->builtInHeaderPaths(flags, sysroot))
+    foreach (const HeaderPath &hp, tc->builtInHeaderPaths(flags, sysroot,
+                                                          Environment::systemEnvironment())) {
         tcIncludes.insert(FilePath::fromString(hp.path));
+    }
     foreach (const FilePath &i, cbt.includeFiles) {
         if (!tcIncludes.contains(i))
             includePaths.append(i.toString());

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp

@@ -390,7 +390,7 @@ void CompilationDatabaseProject::buildTreeAndProjectParts()
 
     setRootProjectNode(std::move(root));
 
-    m_cppCodeModelUpdater->update({this, kitInfo, rpps});
+    m_cppCodeModelUpdater->update({this, kitInfo, activeBuildEnvironment(), rpps});
 }
 
 CompilationDatabaseProject::CompilationDatabaseProject(const Utils::FilePath &projectFile)

src/plugins/cpptools/projectinfo.cpp

@@ -35,7 +35,7 @@
 namespace CppTools {
 
 ToolChainInfo::ToolChainInfo(const ProjectExplorer::ToolChain *toolChain,
-                             const QString &sysRootPath)
+                             const QString &sysRootPath, const Utils::Environment &env)
 {
     if (toolChain) {
         // Keep the following cheap/non-blocking for the ui thread...
@@ -49,20 +49,21 @@ ToolChainInfo::ToolChainInfo(const ProjectExplorer::ToolChain *toolChain,
         // ...and save the potentially expensive operations for later so that
         // they can be run from a worker thread.
         this->sysRootPath = sysRootPath;
-        headerPathsRunner = toolChain->createBuiltInHeaderPathsRunner();
+        headerPathsRunner = toolChain->createBuiltInHeaderPathsRunner(env);
         macroInspectionRunner = toolChain->createMacroInspectionRunner();
     }
 }
 
 ProjectUpdateInfo::ProjectUpdateInfo(ProjectExplorer::Project *project,
                                      const KitInfo &kitInfo,
+                                     const Utils::Environment &env,
                                      const RawProjectParts &rawProjectParts)
     : project(project)
     , rawProjectParts(rawProjectParts)
     , cToolChain(kitInfo.cToolChain)
     , cxxToolChain(kitInfo.cxxToolChain)
-    , cToolChainInfo(ToolChainInfo(cToolChain, kitInfo.sysRootPath))
+    , cToolChainInfo(ToolChainInfo(cToolChain, kitInfo.sysRootPath, env))
-    , cxxToolChainInfo(ToolChainInfo(cxxToolChain, kitInfo.sysRootPath))
+    , cxxToolChainInfo(ToolChainInfo(cxxToolChain, kitInfo.sysRootPath, env))
 {
 }
 

src/plugins/cpptools/projectinfo.h

@@ -47,7 +47,7 @@ class ToolChainInfo
 public:
     ToolChainInfo() = default;
     ToolChainInfo(const ProjectExplorer::ToolChain *toolChain,
-                  const QString &sysRootPath);
+                  const QString &sysRootPath, const Utils::Environment &env);
 
     bool isValid() const { return type.isValid(); }
 
@@ -69,6 +69,7 @@ public:
     ProjectUpdateInfo() = default;
     ProjectUpdateInfo(ProjectExplorer::Project *project,
                       const KitInfo &kitInfo,
+                      const Utils::Environment &env,
                       const RawProjectParts &rawProjectParts);
     bool isValid() const { return project && !rawProjectParts.isEmpty(); }
 

src/plugins/genericprojectmanager/genericproject.cpp

@@ -502,7 +502,7 @@ void GenericProject::refreshCppCodeModel()
     rpp.setFlagsForC({nullptr, m_cflags});
     rpp.setFiles(m_files);
 
-    m_cppCodeModelUpdater->update({this, kitInfo, {rpp}});
+    m_cppCodeModelUpdater->update({this, kitInfo, activeBuildEnvironment(), {rpp}});
 }
 
 void GenericProject::updateDeploymentData()

src/plugins/nim/project/nimtoolchain.cpp

@@ -85,12 +85,14 @@ WarningFlags NimToolChain::warningFlags(const QStringList &) const
     return WarningFlags::NoWarnings;
 }
 
-ToolChain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &) const
 {
     return ToolChain::BuiltInHeaderPathsRunner();
 }
 
-HeaderPaths NimToolChain::builtInHeaderPaths(const QStringList &, const FilePath &) const
+HeaderPaths NimToolChain::builtInHeaderPaths(const QStringList &, const FilePath &,
+                                             const Environment &) const
 {
     return {};
 }

src/plugins/nim/project/nimtoolchain.h

@@ -44,9 +44,11 @@ public:
     Utils::LanguageExtensions languageExtensions(const QStringList &flags) const final;
     ProjectExplorer::WarningFlags warningFlags(const QStringList &flags) const final;
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &) const override;
     ProjectExplorer::HeaderPaths builtInHeaderPaths(const QStringList &flags,
-                                                    const Utils::FilePath &sysRoot) const final;
+                                                    const Utils::FilePath &sysRoot,
+                                                    const Utils::Environment &) const final;
     void addToEnvironment(Utils::Environment &env) const final;
     Utils::FilePath makeCommand(const Utils::Environment &env) const final;
     Utils::FilePath compilerCommand() const final;

src/plugins/projectexplorer/customtoolchain.cpp

@@ -155,7 +155,8 @@ void CustomToolChain::setPredefinedMacros(const Macros &macros)
     toolChainUpdated();
 }
 
-ToolChain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &) const
 {
     const HeaderPaths builtInHeaderPaths = m_builtInHeaderPaths;
 
@@ -173,9 +174,10 @@ ToolChain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRun
 }
 
 HeaderPaths CustomToolChain::builtInHeaderPaths(const QStringList &cxxFlags,
-                                               const FilePath &fileName) const
+                                                const FilePath &fileName,
+                                                const Environment &env) const
 {
-    return createBuiltInHeaderPathsRunner()(cxxFlags, fileName.toString(), "");
+    return createBuiltInHeaderPathsRunner(env)(cxxFlags, fileName.toString(), "");
 }
 
 void CustomToolChain::addToEnvironment(Environment &env) const

src/plugins/projectexplorer/customtoolchain.h

@@ -77,9 +77,11 @@ public:
     const Macros &rawPredefinedMacros() const;
     void setPredefinedMacros(const Macros &macros);
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &) const override;
     HeaderPaths builtInHeaderPaths(const QStringList &cxxFlags,
-                                   const Utils::FilePath &) const override;
+                                   const Utils::FilePath &,
+                                   const Utils::Environment &env) const override;
     void addToEnvironment(Utils::Environment &env) const override;
     QStringList suggestedMkspecList() const override;
     IOutputParser *outputParser() const override;

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -574,7 +574,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Utils::Environment &env,
     if (!originalTargetTriple.isEmpty())
         arguments << "-target" << originalTargetTriple;
 
-    const Utils::optional<HeaderPaths> cachedPaths = headerCache->check(arguments);
+    const Utils::optional<HeaderPaths> cachedPaths = headerCache->check(qMakePair(env, arguments));
     if (cachedPaths)
         return cachedPaths.value();
 
@@ -582,7 +582,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Utils::Environment &env,
                                        arguments,
                                        env.toStringList());
     extraHeaderPathsFunction(paths);
-    headerCache->insert(arguments, paths);
+    headerCache->insert(qMakePair(env, arguments), paths);
 
     qCDebug(gccLog) << "Reporting header paths to code model:";
     for (const HeaderPath &hp : paths) {
@@ -594,14 +594,15 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Utils::Environment &env,
     return paths;
 }
 
-ToolChain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &env) const
 {
     // Using a clean environment breaks ccache/distcc/etc.
-    Environment env = Environment::systemEnvironment();
+    Environment fullEnv = env;
-    addToEnvironment(env);
+    addToEnvironment(fullEnv);
 
     // This runner must be thread-safe!
-    return [env,
+    return [fullEnv,
             compilerCommand = m_compilerCommand,
             platformCodeGenFlags = m_platformCodeGenFlags,
             reinterpretOptions = m_optionsReinterpreter,
@@ -610,7 +611,7 @@ ToolChain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner
             extraHeaderPathsFunction = m_extraHeaderPathsFunction](const QStringList &flags,
                                                                    const QString &sysRoot,
                                                                    const QString &) {
-        return builtInHeaderPaths(env,
+        return builtInHeaderPaths(fullEnv,
                                   compilerCommand,
                                   platformCodeGenFlags,
                                   reinterpretOptions,
@@ -624,9 +625,10 @@ ToolChain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner
 }
 
 HeaderPaths GccToolChain::builtInHeaderPaths(const QStringList &flags,
-                                             const FilePath &sysRootPath) const
+                                             const FilePath &sysRootPath,
+                                             const Environment &env) const
 {
-    return createBuiltInHeaderPathsRunner()(flags,
+    return createBuiltInHeaderPathsRunner(env)(flags,
                                                sysRootPath.isEmpty() ? sysRoot()
                                                                      : sysRootPath.toString(),
                                                originalTargetTriple());
@@ -1391,14 +1393,15 @@ QString ClangToolChain::sysRoot() const
     return mingwCompiler.parentDir().parentDir().toString();
 }
 
-ToolChain::BuiltInHeaderPathsRunner ClangToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner ClangToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &env) const
 {
     // Using a clean environment breaks ccache/distcc/etc.
-    Environment env = Environment::systemEnvironment();
+    Environment fullEnv = env;
-    addToEnvironment(env);
+    addToEnvironment(fullEnv);
 
     // This runner must be thread-safe!
-    return [env,
+    return [fullEnv,
             compilerCommand = m_compilerCommand,
             platformCodeGenFlags = m_platformCodeGenFlags,
             reinterpretOptions = m_optionsReinterpreter,
@@ -1407,7 +1410,7 @@ ToolChain::BuiltInHeaderPathsRunner ClangToolChain::createBuiltInHeaderPathsRunn
             extraHeaderPathsFunction = m_extraHeaderPathsFunction](const QStringList &flags,
                                                                    const QString &sysRoot,
                                                                    const QString &target) {
-        return builtInHeaderPaths(env,
+        return builtInHeaderPaths(fullEnv,
                                   compilerCommand,
                                   platformCodeGenFlags,
                                   reinterpretOptions,

src/plugins/projectexplorer/gcctoolchain.h

@@ -83,9 +83,10 @@ public:
     MacroInspectionRunner createMacroInspectionRunner() const override;
     Macros predefinedMacros(const QStringList &cxxflags) const override;
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(const Utils::Environment &env) const override;
     HeaderPaths builtInHeaderPaths(const QStringList &flags,
-                                   const Utils::FilePath &sysRootPath) const override;
+                                   const Utils::FilePath &sysRootPath,
+                                   const Utils::Environment &env) const override;
 
     void addToEnvironment(Utils::Environment &env) const override;
     Utils::FilePath makeCommand(const Utils::Environment &environment) const override;
@@ -225,7 +226,8 @@ public:
     QString originalTargetTriple() const override;
     QString sysRoot() const override;
 
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &env) const override;
 
     std::unique_ptr<ToolChainConfigWidget> createConfigurationWidget() override;
 

src/plugins/projectexplorer/msvctoolchain.cpp

@@ -1119,27 +1119,29 @@ WarningFlags MsvcToolChain::warningFlags(const QStringList &cflags) const
     return flags;
 }
 
-ToolChain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunner() const
+ToolChain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &env) const
 {
-    Utils::Environment env(m_lastEnvironment);
+    Utils::Environment fullEnv = env;
-    addToEnvironment(env);
+    addToEnvironment(fullEnv);
 
-    return [this, env](const QStringList &, const QString &, const QString &) {
+    return [this, fullEnv](const QStringList &, const QString &, const QString &) {
         QMutexLocker locker(&m_headerPathsMutex);
         if (m_headerPaths.isEmpty()) {
-            foreach (const QString &path,
+            m_headerPaths = transform<QVector>(fullEnv.pathListValue("INCLUDE"),
-                     env.value(QLatin1String("INCLUDE")).split(QLatin1Char(';'))) {
+                                               [](const FilePath &p) {
-                m_headerPaths.append({path, HeaderPathType::BuiltIn});
+                return HeaderPath(p.toString(), HeaderPathType::BuiltIn);
-            }
+            });
         }
         return m_headerPaths;
     };
 }
 
 HeaderPaths MsvcToolChain::builtInHeaderPaths(const QStringList &cxxflags,
-                                              const Utils::FilePath &sysRoot) const
+                                              const Utils::FilePath &sysRoot,
+                                              const Environment &env) const
 {
-    return createBuiltInHeaderPathsRunner()(cxxflags, sysRoot.toString(), "");
+    return createBuiltInHeaderPathsRunner(env)(cxxflags, sysRoot.toString(), "");
 }
 
 void MsvcToolChain::addToEnvironment(Utils::Environment &env) const
@@ -1750,14 +1752,15 @@ Utils::LanguageVersion ClangClToolChain::msvcLanguageVersion(const QStringList &
     return MsvcToolChain::msvcLanguageVersion(cxxflags, language, macros);
 }
 
-ClangClToolChain::BuiltInHeaderPathsRunner ClangClToolChain::createBuiltInHeaderPathsRunner() const
+ClangClToolChain::BuiltInHeaderPathsRunner ClangClToolChain::createBuiltInHeaderPathsRunner(
+        const Environment &env) const
 {
     {
         QMutexLocker locker(&m_headerPathsMutex);
         m_headerPaths.clear();
     }
 
-    return MsvcToolChain::createBuiltInHeaderPathsRunner();
+    return MsvcToolChain::createBuiltInHeaderPathsRunner(env);
 }
 
 // --------------------------------------------------------------------------

src/plugins/projectexplorer/msvctoolchain.h

@@ -79,9 +79,11 @@ public:
     Macros predefinedMacros(const QStringList &cxxflags) const override;
     Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     WarningFlags warningFlags(const QStringList &cflags) const override;
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &env) const override;
     HeaderPaths builtInHeaderPaths(const QStringList &cxxflags,
-                                   const Utils::FilePath &sysRoot) const override;
+                                   const Utils::FilePath &sysRoot,
+                                   const Utils::Environment &env) const override;
     void addToEnvironment(Utils::Environment &env) const override;
 
     Utils::FilePath makeCommand(const Utils::Environment &environment) const override;
@@ -175,7 +177,8 @@ public:
     QVariantMap toMap() const override;
     bool fromMap(const QVariantMap &data) override;
     std::unique_ptr<ToolChainConfigWidget> createConfigurationWidget() override;
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
+            const Utils::Environment &env) const override;
 
     const QList<MsvcToolChain *> &msvcToolchains() const;
     QString clangPath() const { return m_clangPath; }

src/plugins/projectexplorer/project.cpp

@@ -48,8 +48,9 @@
 #include <projectexplorer/kitmanager.h>
 #include <projectexplorer/projecttree.h>
 
-#include <utils/pointeralgorithm.h>
+#include <utils/environment.h>
 #include <utils/macroexpander.h>
+#include <utils/pointeralgorithm.h>
 #include <utils/qtcassert.h>
 
 #include <QFileDialog>
@@ -811,6 +812,14 @@ Task Project::createProjectTask(Task::TaskType type, const QString &description)
     return Task(type, description, Utils::FilePath(), -1, Core::Id());
 }
 
+Utils::Environment Project::activeBuildEnvironment() const
+{
+    const BuildConfiguration * const buildConfiguration = activeTarget()
+            ? activeTarget()->activeBuildConfiguration() : nullptr;
+    return buildConfiguration ? buildConfiguration->environment()
+                              : Utils::Environment::systemEnvironment();
+}
+
 Core::Context Project::projectContext() const
 {
     return Core::Context(d->m_id);

src/plugins/projectexplorer/project.h

@@ -42,7 +42,10 @@
 #include <functional>
 
 namespace Core { class Context; }
-namespace Utils { class MacroExpander; }
+namespace Utils {
+class Environment;
+class MacroExpander;
+}
 
 namespace ProjectExplorer {
 
@@ -263,6 +266,8 @@ protected:
     static ProjectExplorer::Task createProjectTask(ProjectExplorer::Task::TaskType type,
                                                    const QString &description);
 
+    Utils::Environment activeBuildEnvironment() const;
+
 private:
     void handleSubTreeChanged(FolderNode *node);
     void setActiveTarget(Target *target);

src/plugins/projectexplorer/toolchain.h

@@ -37,17 +37,16 @@
 #include <coreplugin/id.h>
 
 #include <utils/cpplanguage_details.h>
+#include <utils/environment.h>
 
 #include <QObject>
 #include <QSet>
-#include <QString>
+#include <QStringList>
 #include <QVariantMap>
 
 #include <functional>
 #include <memory>
 
-namespace Utils { class Environment; }
-
 namespace ProjectExplorer {
 
 namespace Internal { class ToolChainPrivate; }
@@ -129,8 +128,8 @@ public:
         Utils::LanguageVersion languageVersion;
     };
 
-    using MacrosCache = std::shared_ptr<Cache<ToolChain::MacroInspectionReport, 64>>;
+    using MacrosCache = std::shared_ptr<Cache<QStringList, ToolChain::MacroInspectionReport, 64>>;
-    using HeaderPathsCache = std::shared_ptr<Cache<HeaderPaths>>;
+    using HeaderPathsCache = std::shared_ptr<Cache<QPair<Utils::Environment, QStringList>, HeaderPaths>>;
 
     // A MacroInspectionRunner is created in the ui thread and runs in another thread.
     using MacroInspectionRunner = std::function<MacroInspectionReport(const QStringList &cxxflags)>;
@@ -140,9 +139,10 @@ public:
     // A BuiltInHeaderPathsRunner is created in the ui thread and runs in another thread.
     using BuiltInHeaderPathsRunner = std::function<HeaderPaths(
         const QStringList &cxxflags, const QString &sysRoot, const QString &originalTargetTriple)>;
-    virtual BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const = 0;
+    virtual BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(const Utils::Environment &env) const = 0;
     virtual HeaderPaths builtInHeaderPaths(const QStringList &cxxflags,
-                                           const Utils::FilePath &sysRoot) const = 0;
+                                           const Utils::FilePath &sysRoot,
+                                           const Utils::Environment &env) const = 0;
     virtual void addToEnvironment(Utils::Environment &env) const = 0;
     virtual Utils::FilePath makeCommand(const Utils::Environment &env) const = 0;
 

src/plugins/projectexplorer/toolchaincache.h

@@ -27,14 +27,14 @@
 
 #include <QMutex>
 #include <QMutexLocker>
-#include <QStringList>
+#include <QPair>
 #include <QVector>
 
 #include <utils/optional.h>
 
 namespace ProjectExplorer {
 
-template<class T, int Size = 16>
+template<class K, class T, int Size = 16>
 class Cache
 {
 public:
@@ -61,14 +61,14 @@ public:
         return *this;
     }
 
-    void insert(const QStringList &compilerArguments, const T &values)
+    void insert(const K &key, const T &values)
     {
         CacheItem runResults;
-        runResults.first = compilerArguments;
+        runResults.first = key;
         runResults.second = values;
 
         QMutexLocker locker(&m_mutex);
-        if (!checkImpl(compilerArguments)) {
+        if (!checkImpl(key)) {
             if (m_cache.size() < Size) {
                 m_cache.push_back(runResults);
             } else {
@@ -78,10 +78,10 @@ public:
         }
     }
 
-    Utils::optional<T> check(const QStringList &compilerArguments)
+    Utils::optional<T> check(const K &key)
     {
         QMutexLocker locker(&m_mutex);
-        return checkImpl(compilerArguments);
+        return checkImpl(key);
     }
 
     void invalidate()
@@ -91,17 +91,17 @@ public:
     }
 
 private:
-    Utils::optional<T> checkImpl(const QStringList &compilerArguments)
+    Utils::optional<T> checkImpl(const K &key)
     {
         auto it = std::stable_partition(m_cache.begin(), m_cache.end(), [&](const CacheItem &ci) {
-            return ci.first != compilerArguments;
+            return ci.first != key;
         });
         if (it != m_cache.end())
             return m_cache.back().second;
         return {};
     }
 
-    using CacheItem = QPair<QStringList, T>;
+    using CacheItem = QPair<K, T>;
 
     QMutex m_mutex;
     QVector<CacheItem> m_cache;

src/plugins/projectexplorer/toolchainsettingsaccessor.cpp

@@ -318,8 +318,8 @@ public:
     Macros predefinedMacros(const QStringList &cxxflags) const override { Q_UNUSED(cxxflags); return Macros(); }
     LanguageExtensions languageExtensions(const QStringList &cxxflags) const override { Q_UNUSED(cxxflags); return LanguageExtension::None; }
     WarningFlags warningFlags(const QStringList &cflags) const override { Q_UNUSED(cflags); return WarningFlags::NoWarnings; }
-    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override { return BuiltInHeaderPathsRunner(); }
+    BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(const Utils::Environment &) const override { return BuiltInHeaderPathsRunner(); }
-    HeaderPaths builtInHeaderPaths(const QStringList &cxxflags, const FilePath &sysRoot) const override
+    HeaderPaths builtInHeaderPaths(const QStringList &cxxflags, const FilePath &sysRoot, const Utils::Environment &) const override
     { Q_UNUSED(cxxflags); Q_UNUSED(sysRoot); return {}; }
     void addToEnvironment(Environment &env) const override { Q_UNUSED(env); }
     FilePath makeCommand(const Environment &) const override { return FilePath::fromString("make"); }

src/plugins/qbsprojectmanager/qbsproject.cpp

@@ -533,6 +533,8 @@ void QbsProject::handleQbsParsingDone(bool success)
     m_qbsProject = m_qbsProjectParser->qbsProject();
     m_qbsProjects.insert(activeTarget(), m_qbsProject);
     bool dataChanged = false;
+    bool envChanged = m_lastParseEnv != m_qbsProjectParser->environment();
+    m_lastParseEnv = m_qbsProjectParser->environment();
     if (success) {
         QTC_ASSERT(m_qbsProject.isValid(), return);
         const qbs::ProjectData &projectData = m_qbsProject.projectData();
@@ -552,6 +554,8 @@ void QbsProject::handleQbsParsingDone(bool success)
 
     if (dataChanged)
         updateAfterParse();
+    else if (envChanged)
+        updateCppCodeModel();
     emitParsingFinished(success);
 }
 
@@ -1085,7 +1089,7 @@ void QbsProject::updateCppCodeModel()
     }
 
     CppTools::GeneratedCodeModelSupport::update(m_extraCompilers);
-    m_cppCodeModelUpdater->update({this, kitInfo, rpps});
+    m_cppCodeModelUpdater->update({this, kitInfo, activeBuildEnvironment(), rpps});
 }
 
 void QbsProject::updateQmlJsCodeModel()

src/plugins/qbsprojectmanager/qbsproject.h

@@ -144,6 +144,7 @@ private:
     QHash<ProjectExplorer::Target *, qbs::Project> m_qbsProjects;
     qbs::Project m_qbsProject; // for activeTarget()
     qbs::ProjectData m_projectData; // Cached m_qbsProject.projectData()
+    Utils::Environment m_lastParseEnv;
     QSet<Core::IDocument *> m_qbsDocuments;
 
     QbsProjectParser *m_qbsProjectParser = nullptr;

src/plugins/qbsprojectmanager/qbsprojectparser.cpp

@@ -82,6 +82,7 @@ void QbsProjectParser::parse(const QVariantMap &config, const Environment &env,
     QTC_ASSERT(!dir.isEmpty(), return);
 
     m_currentProgressBase = 0;
+    m_environment = env;
 
     qbs::SetupProjectParameters params;
     QVariantMap userConfig = config;

src/plugins/qbsprojectmanager/qbsprojectparser.h

@@ -50,6 +50,7 @@ public:
                const QString &configName);
     void startRuleExecution();
     void cancel();
+    Utils::Environment environment() const { return m_environment; }
 
     qbs::Project qbsProject() const;
     qbs::ErrorInfo error();
@@ -69,6 +70,7 @@ private:
 
     void handleRuleExecutionDone();
 
+    Utils::Environment m_environment;
     QString m_projectFilePath;
     qbs::SetupProjectJob *m_qbsSetupProjectJob = nullptr;
     qbs::BuildJob *m_ruleExecutionJob = nullptr;

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -287,7 +287,7 @@ void QmakeProject::updateCppCodeModel()
     }
 
     CppTools::GeneratedCodeModelSupport::update(generators);
-    m_cppCodeModelUpdater->update({this, kitInfo, rpps});
+    m_cppCodeModelUpdater->update({this, kitInfo, activeBuildEnvironment(), rpps});
 }
 
 void QmakeProject::updateQmlJSCodeModel()

tests/auto/toolchaincache/tst_toolchaincache.cpp

@@ -46,7 +46,7 @@ void tst_ToolChainCache::insertOne()
 {
     const QStringList key1 = {"one"};
     const QString value1 = "value1";
-    ProjectExplorer::Cache<QString, 2> cache;
+    ProjectExplorer::Cache<QStringList, QString, 2> cache;
 
     cache.insert(key1, value1);
 
@@ -59,7 +59,7 @@ void tst_ToolChainCache::insertOneOne()
 {
     const QStringList key1 = {"one"};
     const QString value1 = "value1";
-    ProjectExplorer::Cache<QString, 2> cache;
+    ProjectExplorer::Cache<QStringList, QString, 2> cache;
 
     cache.insert(key1, value1);
     cache.insert(key1, value1);
@@ -75,7 +75,7 @@ void tst_ToolChainCache::insertOneTwo()
     const QString value1 = "value1";
     const QStringList key2 = {"two"};
     const QString value2 = "value2";
-    ProjectExplorer::Cache<QString, 2> cache;
+    ProjectExplorer::Cache<QStringList, QString, 2> cache;
 
     cache.insert(key1, value1);
     cache.insert(key2, value2);
@@ -95,7 +95,7 @@ void tst_ToolChainCache::insertOneTwoThree()
     const QString value2 = "value2";
     const QStringList key3 = {"three"};
     const QString value3 = "value3";
-    ProjectExplorer::Cache<QString, 2> cache;
+    ProjectExplorer::Cache<QStringList, QString, 2> cache;
 
     cache.insert(key1, value1);
     cache.insert(key2, value2);
@@ -117,7 +117,7 @@ void tst_ToolChainCache::insertOneTwoOneThree()
     const QString value2 = "value2";
     const QStringList key3 = {"three"};
     const QString value3 = "value3";
-    ProjectExplorer::Cache<QString, 2> cache;
+    ProjectExplorer::Cache<QStringList, QString, 2> cache;
 
     cache.insert(key1, value1);
     cache.insert(key2, value2);

tests/unit/mockup/projectexplorer/toolchain.h

@@ -33,6 +33,8 @@
 
 #include <functional>
 
+namespace Utils { class Environment; }
+
 namespace ProjectExplorer {
 
 class ToolChain
@@ -45,7 +47,9 @@ public:
 
     using BuiltInHeaderPathsRunner = std::function<HeaderPaths(
         const QStringList &cxxflags, const QString &sysRoot, const QString &originalTargetTriple)>;
-    virtual BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const { return BuiltInHeaderPathsRunner(); }
+    virtual BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(const Utils::Environment &env) const {
+        return BuiltInHeaderPathsRunner();
+    }
 
     class MacroInspectionReport
     {