ProjectExplorer: Introduce ToolChainKitAspect::{c,cxx}ToolChain

Special accessors to the repeatedly used C and C++ cases to denoise
and slim down user code.  Plus some code cosmetics nearby.

Change-Id: Iba4662bd4731d8c4256e658529f39d5c995691ce
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/android/androidconfigurations.cpp

@@ -1186,9 +1186,9 @@ void AndroidConfigurations::updateAutomaticKitList()
                 if (qt != QtSupport::QtKitAspect::qtVersion(b))
                     return false;
                 return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
-                                      ToolChainKitAspect::toolChain(b, ProjectExplorer::Constants::CXX_LANGUAGE_ID))
+                                      ToolChainKitAspect::cxxToolChain(b))
                         && matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
-                                          ToolChainKitAspect::toolChain(b, ProjectExplorer::Constants::C_LANGUAGE_ID));
+                                          ToolChainKitAspect::cToolChain(b));
             });
 
             const auto initializeKit = [allLanguages, device, tc, qt](Kit *k) {

src/plugins/android/androidmanager.cpp

@@ -287,7 +287,7 @@ QJsonObject AndroidManager::deploymentSettings(const Target *target)
     if (!qt)
         return {};
 
-    auto tc = ProjectExplorer::ToolChainKitAspect::toolChain(target->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    auto tc = ToolChainKitAspect::cxxToolChain(target->kit());
     if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_TYPEID)
         return {};
     QJsonObject settings;

src/plugins/android/androidpackageinstallationstep.cpp

@@ -66,8 +66,7 @@ bool AndroidPackageInstallationStep::init()
         if (bc->environment().searchInPath("sh.exe").isEmpty())
             dirPath = QDir::toNativeSeparators(dirPath);
 
-    ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(),
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(target()->kit());
-                                                       ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     QTC_ASSERT(tc, return false);
 
     CommandLine cmd{tc->makeCommand(bc->environment())};

src/plugins/autotest/autotestunittests.cpp

@@ -67,8 +67,7 @@ void AutoTestUnitTests::initTestCase()
         m_isQt4 = qtVersion->qtVersionString().startsWith('4');
     else
         QSKIP("Could not figure out which Qt version is used for default kit.");
-    const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first(),
+    const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(allKits.first());
-                                                                           ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 

src/plugins/clangcodemodel/clangutils.cpp

@@ -60,6 +60,7 @@ using namespace ClangCodeModel;
 using namespace ClangCodeModel::Internal;
 using namespace Core;
 using namespace CppTools;
+using namespace ProjectExplorer;
 
 namespace ClangCodeModel {
 namespace Utils {
@@ -303,12 +304,11 @@ QString diagnosticCategoryPrefixRemoved(const QString &text)
 
 static ::Utils::FilePath compilerPath(const CppTools::ProjectPart &projectPart)
 {
-    ProjectExplorer::Target *target = projectPart.project->activeTarget();
+    Target *target = projectPart.project->activeTarget();
     if (!target)
         return ::Utils::FilePath();
 
-    ProjectExplorer::ToolChain *toolchain = ProjectExplorer::ToolChainKitAspect::toolChain(
+    ToolChain *toolchain = ToolChainKitAspect::cxxToolChain(target->kit());
-        target->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     return toolchain->compilerCommand();
 }

src/plugins/clangtools/clangtool.cpp

@@ -867,7 +867,7 @@ static bool canAnalyzeProject(Project *project)
                                              || project->projectLanguages().contains(cxx);
         return projectSupportsLanguage
                && CppModelManager::instance()->projectInfo(project).isValid()
-               && ToolChainKitAspect::toolChain(target->kit(), cxx);
+               && ToolChainKitAspect::cxxToolChain(target->kit());
     }
     return false;
 }

src/plugins/clangtools/clangtoolruncontrol.cpp

@@ -222,8 +222,7 @@ ClangToolRunWorker::ClangToolRunWorker(RunControl *runControl,
     QTC_ASSERT(buildConfiguration, return);
     m_environment = buildConfiguration->environment();
 
-    ToolChain *toolChain = ToolChainKitAspect::toolChain(target->kit(),
+    ToolChain *toolChain = ToolChainKitAspect::cxxToolChain(target->kit());
-                                                         ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     QTC_ASSERT(toolChain, return);
     m_targetTriple = toolChain->originalTargetTriple();
     m_toolChainType = toolChain->typeId();

src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp

@@ -166,7 +166,7 @@ static QList<Target *> validTargets(Project *project)
             return false;
         }
 
-        const ToolChain * const toolchain = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+        const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(kit);
         QTC_ASSERT(toolchain, return false);
 
         if (Core::ICore::clangExecutable(CLANG_BINDIR).isEmpty()) {

src/plugins/clangtools/clangtoolsunittests.cpp

@@ -62,8 +62,7 @@ void ClangToolsUnitTests::initTestCase()
     const QList<Kit *> allKits = KitManager::kits();
     if (allKits.count() != 1)
         QSKIP("This test requires exactly one kit to be present");
-    const ToolChain *const toolchain = ToolChainKitAspect::toolChain(allKits.first(),
+    const ToolChain *const toolchain = ToolChainKitAspect::cxxToolChain(allKits.first());
-                                                                     Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 
@@ -100,9 +99,7 @@ void ClangToolsUnitTests::testProject()
     QFETCH(int, expectedDiagCount);
     QFETCH(ClangDiagnosticConfig, diagnosticConfig);
     if (projectFilePath.contains("mingw")) {
-        const ToolChain *const toolchain
+        const auto toolchain = ToolChainKitAspect::cxxToolChain(KitManager::kits().constFirst());
-            = ToolChainKitAspect::toolChain(KitManager::kits().constFirst(),
-                                            Constants::CXX_LANGUAGE_ID);
         if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID)
             QSKIP("This test is mingw specific, does not run for other toolchains");
     }

src/plugins/cmakeprojectmanager/builddirparameters.cpp

@@ -69,10 +69,10 @@ BuildDirParameters::BuildDirParameters(CMakeBuildConfiguration *bc)
 
     cmakeToolId = CMakeKitAspect::cmakeToolId(k);
 
-    auto tc = ToolChainKitAspect::toolChain(k, Constants::CXX_LANGUAGE_ID);
+    auto tc = ToolChainKitAspect::cxxToolChain(k);
     if (tc)
         cxxToolChainId = tc->id();
-    tc = ToolChainKitAspect::toolChain(k, Constants::C_LANGUAGE_ID);
+    tc = ToolChainKitAspect::cToolChain(k);
     if (tc)
         cToolChainId = tc->id();
     sysRoot = SysRootKitAspect::sysRoot(k);

src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp

@@ -88,9 +88,7 @@ CMakeBuildConfiguration::CMakeBuildConfiguration(Target *target, Core::Id id)
         const QString sysRoot = SysRootKitAspect::sysRoot(k).toString();
         if (!sysRoot.isEmpty()) {
             config.append(CMakeConfigItem("CMAKE_SYSROOT", sysRoot.toUtf8()));
-            ToolChain *tc = ToolChainKitAspect::toolChain(k,
+            if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(k)) {
-                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID);
-            if (tc) {
                 const QByteArray targetTriple = tc->originalTargetTriple().toUtf8();
                 config.append(CMakeConfigItem("CMAKE_C_COMPILER_TARGET", targetTriple));
                 config.append(CMakeConfigItem("CMAKE_CXX_COMPILER_TARGET ", targetTriple));

src/plugins/cmakeprojectmanager/cmakekitinformation.cpp

@@ -621,7 +621,7 @@ QVariant CMakeGeneratorKitAspect::defaultValue(const Kit *k) const
 
     if (Utils::HostOsInfo::isWindowsHost()) {
         // *sigh* Windows with its zoo of incompatible stuff again...
-        ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+        ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
         if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
             it = std::find_if(known.constBegin(), known.constEnd(),
                               [extraGenerator](const CMakeTool::Generator &g) {
@@ -954,8 +954,8 @@ Tasks CMakeConfigurationKitAspect::validate(const Kit *k) const
     QTC_ASSERT(k, return Tasks());
 
     const QtSupport::BaseQtVersion *const version = QtSupport::QtKitAspect::qtVersion(k);
-    const ToolChain *const tcC = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
+    const ToolChain *const tcC = ToolChainKitAspect::cToolChain(k);
-    const ToolChain *const tcCxx = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    const ToolChain *const tcCxx = ToolChainKitAspect::cxxToolChain(k);
     const CMakeConfig config = configuration(k);
 
     const bool isQt4 = version && version->qtVersion() < QtSupport::QtVersionNumber(5, 0, 0);

src/plugins/cppcheck/cppcheckplugin.cpp

@@ -148,7 +148,7 @@ void CppcheckPluginPrivate::updateManualRunAction()
     const Target *target = SessionManager::startupTarget();
     const Core::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
     const bool canRun = target && project->projectLanguages().contains(cxx)
-                  && ToolChainKitAspect::toolChain(target->kit(), cxx);
+                  && ToolChainKitAspect::cxxToolChain(target->kit());
     manualRunAction->setEnabled(canRun);
 }
 

src/plugins/ios/iosbuildstep.cpp

@@ -180,7 +180,7 @@ bool IosBuildStep::init()
     if (!bc)
         emit addTask(Task::buildConfigurationMissingTask());
 
-    ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(target()->kit());
     if (!tc)
         emit addTask(Task::compilerMissingTask());
 
@@ -240,7 +240,7 @@ QStringList IosBuildStep::defaultArguments() const
 {
     QStringList res;
     Kit *kit = target()->kit();
-    ToolChain *tc = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit);
     switch (buildConfiguration()->buildType()) {
     case BuildConfiguration::Debug :
         res << "-configuration" << "Debug";

src/plugins/ios/iosconfigurations.cpp

@@ -288,8 +288,8 @@ void IosConfigurations::updateAutomaticKitList()
                     // we do not compare the sdk (thus automatically upgrading it in place if a
                     // new Xcode is used). Change?
                     return DeviceTypeKitAspect::deviceTypeId(kit) == pDeviceType
-                            && ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID) == platformToolchains.second
+                            && ToolChainKitAspect::cxxToolChain(kit) == platformToolchains.second
-                            && ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID) == platformToolchains.first
+                            && ToolChainKitAspect::cToolChain(kit) == platformToolchains.first
                             && QtKitAspect::qtVersion(kit) == qtVersion;
                 });
                 QTC_ASSERT(!resultingKits.contains(kit), continue);

src/plugins/perfprofiler/perfdatareader.cpp

@@ -54,6 +54,8 @@
 #include <QTextStream>
 #include <QtEndian>
 
+using namespace ProjectExplorer;
+
 namespace PerfProfiler {
 namespace Internal {
 
@@ -289,15 +291,14 @@ bool PerfDataReader::acceptsSamples() const
     return m_recording;
 }
 
-QStringList PerfDataReader::collectArguments(const QString &executableDirPath,
+QStringList PerfDataReader::collectArguments(const QString &executableDirPath, const Kit *kit) const
-                                             const ProjectExplorer::Kit *kit) const
 {
     QStringList arguments;
     if (!executableDirPath.isEmpty())
-        arguments << QLatin1String("--app") << executableDirPath;
+        arguments << "--app" << executableDirPath;
 
     if (QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(kit)) {
-        arguments << QLatin1String("--extra") << QString::fromLatin1("%1%5%2%5%3%5%4")
+        arguments << "--extra" << QString("%1%5%2%5%3%5%4")
                      .arg(QDir::toNativeSeparators(qt->libraryPath().toString()))
                      .arg(QDir::toNativeSeparators(qt->pluginPath().toString()))
                      .arg(QDir::toNativeSeparators(qt->hostBinPath().toString()))
@@ -305,20 +306,18 @@ QStringList PerfDataReader::collectArguments(const QString &executableDirPath,
                      .arg(QDir::listSeparator());
     }
 
-    if (auto toolChain = ProjectExplorer::ToolChainKitAspect::toolChain(
+    if (auto toolChain = ToolChainKitAspect::cxxToolChain(kit)) {
-                kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID)) {
+        Abi::Architecture architecture = toolChain->targetAbi().architecture();
-        ProjectExplorer::Abi::Architecture architecture = toolChain->targetAbi().architecture();
+        if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) {
-        if (architecture == ProjectExplorer::Abi::ArmArchitecture &&
+            arguments << "--arch" << "aarch64";
-                toolChain->targetAbi().wordWidth() == 64) {
+        } else if (architecture != Abi::UnknownArchitecture) {
-            arguments << QLatin1String("--arch") << QLatin1String("aarch64");
+            arguments << "--arch" << Abi::toString(architecture);
-        } else if (architecture != ProjectExplorer::Abi::UnknownArchitecture) {
-            arguments << QLatin1String("--arch") << ProjectExplorer::Abi::toString(architecture);
         }
     }
 
-    QString sysroot = ProjectExplorer::SysRootKitAspect::sysRoot(kit).toString();
+    QString sysroot = SysRootKitAspect::sysRoot(kit).toString();
     if (!sysroot.isEmpty())
-        arguments << QLatin1String("--sysroot") << sysroot;
+        arguments << "--sysroot" << sysroot;
 
     return arguments;
 }

src/plugins/projectexplorer/buildconfiguration.cpp

@@ -476,8 +476,7 @@ bool BuildConfiguration::isActive() const
 
 void BuildConfiguration::prependCompilerPathToEnvironment(Kit *k, Environment &env)
 {
-    const ToolChain *tc
+    const ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
-            = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     if (!tc)
         return;

src/plugins/projectexplorer/kitinformation.cpp

@@ -511,19 +511,19 @@ KitAspectWidget *ToolChainKitAspect::createConfigWidget(Kit *k) const
 
 QString ToolChainKitAspect::displayNamePostfix(const Kit *k) const
 {
-    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = cxxToolChain(k);
     return tc ? tc->displayName() : QString();
 }
 
 KitAspect::ItemList ToolChainKitAspect::toUserOutput(const Kit *k) const
 {
-    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = cxxToolChain(k);
     return {{tr("Compiler"), tc ? tc->displayName() : tr("None")}};
 }
 
 void ToolChainKitAspect::addToEnvironment(const Kit *k, Utils::Environment &env) const
 {
-    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = cxxToolChain(k);
     if (tc)
         tc->addToEnvironment(env);
 }
@@ -534,24 +534,24 @@ void ToolChainKitAspect::addToMacroExpander(Kit *kit, Utils::MacroExpander *expa
 
     // Compatibility with Qt Creator < 4.2:
     expander->registerVariable("Compiler:Name", tr("Compiler"),
-                               [kit]() -> QString {
+                               [kit] {
-                                   const ToolChain *tc = toolChain(kit, Constants::CXX_LANGUAGE_ID);
+                                   const ToolChain *tc = cxxToolChain(kit);
                                    return tc ? tc->displayName() : tr("None");
                                });
 
     expander->registerVariable("Compiler:Executable", tr("Path to the compiler executable"),
-                               [kit]() -> QString {
+                               [kit] {
-                                   const ToolChain *tc = toolChain(kit, Constants::CXX_LANGUAGE_ID);
+                                   const ToolChain *tc = cxxToolChain(kit);
                                    return tc ? tc->compilerCommand().toString() : QString();
                                });
 
     expander->registerPrefix("Compiler:Name", tr("Compiler for different languages"),
-                             [kit](const QString &ls) -> QString {
+                             [kit](const QString &ls) {
                                  const ToolChain *tc = toolChain(kit, findLanguage(ls));
                                  return tc ? tc->displayName() : tr("None");
                              });
     expander->registerPrefix("Compiler:Executable", tr("Compiler executable for different languages"),
-                             [kit](const QString &ls) -> QString {
+                             [kit](const QString &ls) {
                                  const ToolChain *tc = toolChain(kit, findLanguage(ls));
                                  return tc ? tc->compilerCommand().toString() : QString();
                              });
@@ -594,6 +594,17 @@ ToolChain *ToolChainKitAspect::toolChain(const Kit *k, Core::Id language)
     return ToolChainManager::findToolChain(toolChainId(k, language));
 }
 
+ToolChain *ToolChainKitAspect::cToolChain(const Kit *k)
+{
+    return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
+}
+
+ToolChain *ToolChainKitAspect::cxxToolChain(const Kit *k)
+{
+    return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
+}
+
+
 QList<ToolChain *> ToolChainKitAspect::toolChains(const Kit *k)
 {
     QTC_ASSERT(k, return QList<ToolChain *>());

src/plugins/projectexplorer/kitinformation.h

@@ -90,6 +90,8 @@ public:
     static Core::Id id();
     static QByteArray toolChainId(const Kit *k, Core::Id language);
     static ToolChain *toolChain(const Kit *k, Core::Id language);
+    static ToolChain *cToolChain(const Kit *k);
+    static ToolChain *cxxToolChain(const Kit *k);
     static QList<ToolChain *> toolChains(const Kit *k);
     static void setToolChain(Kit *k, ToolChain *tc);
     static void setAllToolChainsToMatch(Kit *k, ToolChain *tc);

src/plugins/projectexplorer/rawprojectpart.cpp

@@ -155,8 +155,8 @@ KitInfo::KitInfo(Kit *kit)
 {
     // Toolchains
     if (kit) {
-        cToolChain = ToolChainKitAspect::toolChain(kit, Constants::C_LANGUAGE_ID);
+        cToolChain = ToolChainKitAspect::cToolChain(kit);
-        cxxToolChain = ToolChainKitAspect::toolChain(kit, Constants::CXX_LANGUAGE_ID);
+        cxxToolChain = ToolChainKitAspect::cxxToolChain(kit);
     }
 
     // Sysroot

src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp

@@ -52,6 +52,8 @@
 #include <QRegularExpression>
 #include <QSettings>
 
+using namespace ProjectExplorer;
+
 namespace QbsProjectManager {
 using namespace Constants;
 
@@ -253,27 +255,24 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
 {
     QVariantMap data = defaultData;
 
-    const QString sysroot = ProjectExplorer::SysRootKitAspect::sysRoot(k).toUserOutput();
+    const QString sysroot = SysRootKitAspect::sysRoot(k).toUserOutput();
     if (!sysroot.isEmpty())
         data.insert(QLatin1String(QBS_SYSROOT), sysroot);
 
-    ProjectExplorer::ToolChain *tcC
+    ToolChain *tcC = ToolChainKitAspect::cToolChain(k);
-            = ProjectExplorer::ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
+    ToolChain *tcCxx = ToolChainKitAspect::cxxToolChain(k);
-    ProjectExplorer::ToolChain *tcCxx
-            = ProjectExplorer::ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tcC && !tcCxx)
         return data;
 
-    ProjectExplorer::ToolChain *mainTc = tcCxx ? tcCxx : tcC;
+    ToolChain *mainTc = tcCxx ? tcCxx : tcC;
 
-    ProjectExplorer::Abi targetAbi = mainTc->targetAbi();
+    Abi targetAbi = mainTc->targetAbi();
 
     auto archs = architectures(mainTc);
     if (!archs.isEmpty())
         data.insert(QLatin1String(QBS_ARCHITECTURES), archs);
-    if (mainTc->targetAbi() !=
+    if (mainTc->targetAbi() != Abi::abiFromTargetTriplet(mainTc->originalTargetTriple())
-            ProjectExplorer::Abi::abiFromTargetTriplet(mainTc->originalTargetTriple())
+            || targetAbi.osFlavor() == Abi::AndroidLinuxFlavor) {
-            || targetAbi.osFlavor() == ProjectExplorer::Abi::AndroidLinuxFlavor) {
         data.insert(QLatin1String(QBS_ARCHITECTURE), architecture(mainTc->targetAbi()));
     } else if (archs.count() == 1) {
         data.insert(QLatin1String(QBS_ARCHITECTURE), archs.first());
@@ -281,8 +280,8 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
     data.insert(QLatin1String(QBS_TARGETPLATFORM), targetPlatform(targetAbi, k));
 
     QStringList toolchain = toolchainList(mainTc);
-    if (targetAbi.osFlavor() == ProjectExplorer::Abi::AndroidLinuxFlavor) {
+    if (targetAbi.osFlavor() == Abi::AndroidLinuxFlavor) {
-        const ProjectExplorer::IDevice::ConstPtr dev = ProjectExplorer::DeviceKitAspect::device(k);
+        const IDevice::ConstPtr dev = DeviceKitAspect::device(k);
         if (dev) {
             const QString sdkDir = k->value(Android::Constants::ANDROID_KIT_SDK).toString();
             if (!sdkDir.isEmpty())

src/plugins/qbsprojectmanager/qbsprojectimporter.cpp

@@ -165,10 +165,8 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
             && bgData->cxxCompilerPath.isEmpty()) {
         return true;
     }
-    const ToolChain * const cToolchain
+    const ToolChain * const cToolchain = ToolChainKitAspect::cToolChain(k);
-            = ToolChainKitAspect::toolChain(k, Constants::C_LANGUAGE_ID);
+    const ToolChain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k);
-    const ToolChain * const cxxToolchain
-            = ToolChainKitAspect::toolChain(k, Constants::CXX_LANGUAGE_ID);
     if (!bgData->cCompilerPath.isEmpty()) {
         if (!cToolchain)
             return false;

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp

@@ -827,7 +827,7 @@ QmakeBuildConfiguration::LastKitState::LastKitState(Kit *k)
       m_sysroot(SysRootKitAspect::sysRoot(k).toString()),
       m_mkspec(QmakeKitAspect::mkspec(k))
 {
-    ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
     m_toolchain = tc ? tc->id() : QByteArray();
 }
 

src/plugins/qmakeprojectmanager/qmakekitinformation.cpp

@@ -159,8 +159,7 @@ QString QmakeKitAspect::defaultMkspec(const Kit *k)
     if (!version) // No version, so no qmake
         return {};
 
-    return version->mkspecFor(ToolChainKitAspect::toolChain(k,
+    return version->mkspecFor(ToolChainKitAspect::cxxToolChain(k));
-                        ProjectExplorer::Constants::CXX_LANGUAGE_ID));
 }
 
 } // namespace Internal

src/plugins/qmakeprojectmanager/qmakemakestep.cpp

@@ -167,8 +167,7 @@ bool QmakeMakeStep::init()
     pp->resolveAll();
 
     setOutputParser(new ProjectExplorer::GnuMakeParser());
-    ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(),
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(target()->kit());
-                                                       ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (tc && tc->targetAbi().os() == Abi::DarwinOS)
         appendOutputParser(new XcodebuildParser);
     IOutputParser *parser = target()->kit()->createOutputParser();

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -218,7 +218,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
 
     connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
             this, [this](ToolChain *tc) {
-        if (ToolChainKitAspect::toolChain(kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID) == tc)
+        if (ToolChainKitAspect::cxxToolChain(kit()) == tc)
             scheduleUpdateAllNowOrLater();
     });
 
@@ -610,7 +610,7 @@ Tasks QmakeProject::projectIssues(const Kit *k) const
         result.append(createProjectTask(Task::TaskType::Error, tr("No Qt version set in kit.")));
     else if (!qtFromKit->isValid())
         result.append(createProjectTask(Task::TaskType::Error, tr("Qt version is invalid.")));
-    if (!ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID))
+    if (!ToolChainKitAspect::cxxToolChain(k))
         result.append(createProjectTask(Task::TaskType::Error, tr("No C++ compiler set in kit.")));
 
     const QtSupport::BaseQtVersion *const qtThatContainsProject = projectIsPartOfQt(this);
@@ -1122,7 +1122,7 @@ void QmakeBuildSystem::collectLibraryData(const QmakeProFile *file, DeploymentDa
     if (targetPath.isEmpty())
         return;
     const Kit * const kit = target()->kit();
-    const ToolChain * const toolchain = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(kit);
     if (!toolchain)
         return;
 
@@ -1272,16 +1272,16 @@ void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
     if (!bc)
         return;
 
-    testToolChain(ToolChainKitAspect::toolChain(t->kit(), ProjectExplorer::Constants::C_LANGUAGE_ID),
+    testToolChain(ToolChainKitAspect::cToolChain(t->kit()),
                   getFullPathOf(pro, Variable::QmakeCc, bc));
-    testToolChain(ToolChainKitAspect::toolChain(t->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID),
+    testToolChain(ToolChainKitAspect::cxxToolChain(t->kit()),
                   getFullPathOf(pro, Variable::QmakeCxx, bc));
 }
 
 QString QmakeBuildSystem::executableFor(const QmakeProFile *file)
 {
     const Kit *const kit = target()->kit();
-    const ToolChain *const tc = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    const ToolChain *const tc = ToolChainKitAspect::cxxToolChain(kit);
     if (!tc)
         return QString();
 

src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp

@@ -206,7 +206,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
 
     BaseQtVersion *kitVersion = QtKitAspect::qtVersion(k);
     QString kitSpec = QmakeKitAspect::mkspec(k);
-    ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
     if (kitSpec.isEmpty() && kitVersion)
         kitSpec = kitVersion->mkspecFor(tc);
     QMakeStepConfig::TargetArchConfig kitTargetArch = QMakeStepConfig::NoArch;

src/plugins/qmakeprojectmanager/qmakestep.cpp

@@ -141,16 +141,14 @@ QString QMakeStep::allArguments(const BaseQtVersion *v, ArgumentFlags flags) con
 
 QMakeStepConfig QMakeStep::deducedArguments() const
 {
-    ProjectExplorer::Kit *kit = target()->kit();
+    Kit *kit = target()->kit();
     QMakeStepConfig config;
-    ProjectExplorer::ToolChain *tc
+    Abi targetAbi;
-            = ProjectExplorer::ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit)) {
-    ProjectExplorer::Abi targetAbi;
-    if (tc) {
         targetAbi = tc->targetAbi();
         if (HostOsInfo::isWindowsHost()
             && tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) {
-            config.sysRoot = ProjectExplorer::SysRootKitAspect::sysRoot(kit).toString();
+            config.sysRoot = SysRootKitAspect::sysRoot(kit).toString();
             config.targetTriple = tc->originalTargetTriple();
         }
     }

src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp

@@ -68,6 +68,8 @@
 static Q_LOGGING_CATEGORY(puppetStart, "qtc.puppet.start", QtWarningMsg)
 static Q_LOGGING_CATEGORY(puppetBuild, "qtc.puppet.build", QtWarningMsg)
 
+using namespace ProjectExplorer;
+
 namespace QmlDesigner {
 
 class EventFilter : public QObject {
@@ -525,11 +527,7 @@ QString PuppetCreator::buildCommand() const
     Utils::Environment environment = Utils::Environment::systemEnvironment();
     m_target->kit()->addToEnvironment(environment);
 
-    ProjectExplorer::ToolChain *toolChain
+    if (ToolChain *toolChain = ToolChainKitAspect::cxxToolChain(m_target->kit()))
-            = ProjectExplorer::ToolChainKitAspect::toolChain(m_target->kit(),
-                                                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID);
-
-    if (toolChain)
         return toolChain->makeCommand(environment).toString();
 
     return QString();

src/plugins/qnx/qnxconfiguration.cpp

@@ -178,7 +178,7 @@ void QnxConfiguration::deactivate()
     foreach (Kit *kit, KitManager::kits()) {
         if (kit->isAutoDetected()
                 && DeviceTypeKitAspect::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE
-                && toolChainsToRemove.contains(ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID)))
+                && toolChainsToRemove.contains(ToolChainKitAspect::cxxToolChain(kit)))
             KitManager::deregisterKit(kit);
     }
 

src/plugins/qtsupport/baseqtversion.cpp

@@ -504,8 +504,7 @@ Tasks BaseQtVersion::validateKit(const Kit *k)
     if (!tdt.isEmpty() && !tdt.contains(dt))
         result << BuildSystemTask(Task::Warning, tr("Device type is not supported by Qt version."));
 
-    ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(k)) {
-    if (tc) {
         Abi targetAbi = tc->targetAbi();
         bool fuzzyMatch = false;
         bool fullMatch = false;
@@ -532,7 +531,7 @@ Tasks BaseQtVersion::validateKit(const Kit *k)
                                   version->displayName(), qtAbiString);
             result << BuildSystemTask(fuzzyMatch ? Task::Warning : Task::Error, message);
         }
-    } else if (ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID)) {
+    } else if (ToolChainKitAspect::cToolChain(k)) {
         const QString message = tr("The kit has a Qt version, but no C++ compiler.");
         result << BuildSystemTask(Task::Warning, message);
     }

src/plugins/qtsupport/qtkitinformation.cpp

@@ -219,8 +219,9 @@ void QtKitAspect::fix(ProjectExplorer::Kit *k)
     }
 
     // Set a matching toolchain if we don't have one.
-    if (ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID))
+    if (ToolChainKitAspect::cxxToolChain(k))
         return;
+
     const QString spec = version->mkspec();
     const QList<ToolChain *> possibleTcs = ToolChainManager::toolChains(
                 [version](const ToolChain *t) {