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>
2020-02-18 18:25:26 +01:00
parent 57662de841
commit 3f68292dbe
32 changed files with 97 additions and 103 deletions
--- a/src/plugins/android/androidconfigurations.cpp
+++ b/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) {
--- a/src/plugins/android/androidmanager.cpp
+++ b/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;
--- a/src/plugins/android/androidpackageinstallationstep.cpp
+++ b/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(),
-                                                       ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(target()->kit());
    QTC_ASSERT(tc, return false);

    CommandLine cmd{tc->makeCommand(bc->environment())};
--- a/src/plugins/autotest/autotestunittests.cpp
+++ b/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(),
-                                                                           ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(allKits.first());
    if (!toolchain)
        QSKIP("This test requires that there is a kit with a toolchain.");

--- a/src/plugins/clangcodemodel/clangutils.cpp
+++ b/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(
-        target->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *toolchain = ToolChainKitAspect::cxxToolChain(target->kit());

    return toolchain->compilerCommand();
 }
--- a/src/plugins/clangtools/clangtool.cpp
+++ b/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;
 }
--- a/src/plugins/clangtools/clangtoolruncontrol.cpp
+++ b/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(),
-                                                         ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *toolChain = ToolChainKitAspect::cxxToolChain(target->kit());
    QTC_ASSERT(toolChain, return);
    m_targetTriple = toolChain->originalTargetTriple();
    m_toolChainType = toolChain->typeId();
--- a/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
+++ b/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()) {
--- a/src/plugins/clangtools/clangtoolsunittests.cpp
+++ b/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(),
-                                                                     Constants::CXX_LANGUAGE_ID);
+    const ToolChain *const toolchain = ToolChainKitAspect::cxxToolChain(allKits.first());
    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
-            = ToolChainKitAspect::toolChain(KitManager::kits().constFirst(),
-                                            Constants::CXX_LANGUAGE_ID);
+        const auto toolchain = ToolChainKitAspect::cxxToolChain(KitManager::kits().constFirst());
        if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID)
            QSKIP("This test is mingw specific, does not run for other toolchains");
    }
--- a/src/plugins/cmakeprojectmanager/builddirparameters.cpp
+++ b/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);
--- a/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
+++ b/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,
-                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID);
-            if (tc) {
+            if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(k)) {
                const QByteArray targetTriple = tc->originalTargetTriple().toUtf8();
                config.append(CMakeConfigItem("CMAKE_C_COMPILER_TARGET", targetTriple));
                config.append(CMakeConfigItem("CMAKE_CXX_COMPILER_TARGET ", targetTriple));
--- a/src/plugins/cmakeprojectmanager/cmakekitinformation.cpp
+++ b/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 tcCxx = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    const ToolChain *const tcC = ToolChainKitAspect::cToolChain(k);
+    const ToolChain *const tcCxx = ToolChainKitAspect::cxxToolChain(k);
    const CMakeConfig config = configuration(k);

    const bool isQt4 = version && version->qtVersion() < QtSupport::QtVersionNumber(5, 0, 0);
--- a/src/plugins/cppcheck/cppcheckplugin.cpp
+++ b/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);
 }

--- a/src/plugins/ios/iosbuildstep.cpp
+++ b/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";
--- a/src/plugins/ios/iosconfigurations.cpp
+++ b/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::toolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID) == platformToolchains.first
+                            && ToolChainKitAspect::cxxToolChain(kit) == platformToolchains.second
+                            && ToolChainKitAspect::cToolChain(kit) == platformToolchains.first
                            && QtKitAspect::qtVersion(kit) == qtVersion;
                });
                QTC_ASSERT(!resultingKits.contains(kit), continue);
--- a/src/plugins/perfprofiler/perfdatareader.cpp
+++ b/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,
-                                             const ProjectExplorer::Kit *kit) const
+QStringList PerfDataReader::collectArguments(const QString &executableDirPath, const 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(
-                kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID)) {
-        ProjectExplorer::Abi::Architecture architecture = toolChain->targetAbi().architecture();
-        if (architecture == ProjectExplorer::Abi::ArmArchitecture &&
-                toolChain->targetAbi().wordWidth() == 64) {
-            arguments << QLatin1String("--arch") << QLatin1String("aarch64");
-        } else if (architecture != ProjectExplorer::Abi::UnknownArchitecture) {
-            arguments << QLatin1String("--arch") << ProjectExplorer::Abi::toString(architecture);
+    if (auto toolChain = ToolChainKitAspect::cxxToolChain(kit)) {
+        Abi::Architecture architecture = toolChain->targetAbi().architecture();
+        if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) {
+            arguments << "--arch" << "aarch64";
+        } else if (architecture != Abi::UnknownArchitecture) {
+            arguments << "--arch" << 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;
 }
--- a/src/plugins/projectexplorer/buildconfiguration.cpp
+++ b/src/plugins/projectexplorer/buildconfiguration.cpp
@@ -476,8 +476,7 @@ bool BuildConfiguration::isActive() const

 void BuildConfiguration::prependCompilerPathToEnvironment(Kit *k, Environment &env)
 {
-    const ToolChain *tc
-            = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    const ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);

    if (!tc)
        return;
--- a/src/plugins/projectexplorer/kitinformation.cpp
+++ b/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 {
-                                   const ToolChain *tc = toolChain(kit, Constants::CXX_LANGUAGE_ID);
+                               [kit] {
+                                   const ToolChain *tc = cxxToolChain(kit);
                                   return tc ? tc->displayName() : tr("None");
                               });

    expander->registerVariable("Compiler:Executable", tr("Path to the compiler executable"),
-                               [kit]() -> QString {
-                                   const ToolChain *tc = toolChain(kit, Constants::CXX_LANGUAGE_ID);
+                               [kit] {
+                                   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 *>());
--- a/src/plugins/projectexplorer/kitinformation.h
+++ b/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);
--- a/src/plugins/projectexplorer/rawprojectpart.cpp
+++ b/src/plugins/projectexplorer/rawprojectpart.cpp
@@ -155,8 +155,8 @@ KitInfo::KitInfo(Kit *kit)
 {
    // Toolchains
    if (kit) {
-        cToolChain = ToolChainKitAspect::toolChain(kit, Constants::C_LANGUAGE_ID);
-        cxxToolChain = ToolChainKitAspect::toolChain(kit, Constants::CXX_LANGUAGE_ID);
+        cToolChain = ToolChainKitAspect::cToolChain(kit);
+        cxxToolChain = ToolChainKitAspect::cxxToolChain(kit);
    }

    // Sysroot
--- a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
+++ b/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
-            = ProjectExplorer::ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
-    ProjectExplorer::ToolChain *tcCxx
-            = ProjectExplorer::ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tcC = ToolChainKitAspect::cToolChain(k);
+    ToolChain *tcCxx = ToolChainKitAspect::cxxToolChain(k);
    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() !=
-            ProjectExplorer::Abi::abiFromTargetTriplet(mainTc->originalTargetTriple())
-            || targetAbi.osFlavor() == ProjectExplorer::Abi::AndroidLinuxFlavor) {
+    if (mainTc->targetAbi() != Abi::abiFromTargetTriplet(mainTc->originalTargetTriple())
+            || targetAbi.osFlavor() == 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) {
-        const ProjectExplorer::IDevice::ConstPtr dev = ProjectExplorer::DeviceKitAspect::device(k);
+    if (targetAbi.osFlavor() == Abi::AndroidLinuxFlavor) {
+        const IDevice::ConstPtr dev = DeviceKitAspect::device(k);
        if (dev) {
            const QString sdkDir = k->value(Android::Constants::ANDROID_KIT_SDK).toString();
            if (!sdkDir.isEmpty())
--- a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
+++ b/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
-            = ToolChainKitAspect::toolChain(k, Constants::C_LANGUAGE_ID);
-    const ToolChain * const cxxToolchain
-            = ToolChainKitAspect::toolChain(k, Constants::CXX_LANGUAGE_ID);
+    const ToolChain * const cToolchain = ToolChainKitAspect::cToolChain(k);
+    const ToolChain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k);
    if (!bgData->cCompilerPath.isEmpty()) {
        if (!cToolchain)
            return false;
--- a/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
+++ b/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();
 }

--- a/src/plugins/qmakeprojectmanager/qmakekitinformation.cpp
+++ b/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,
-                        ProjectExplorer::Constants::CXX_LANGUAGE_ID));
+    return version->mkspecFor(ToolChainKitAspect::cxxToolChain(k));
 }

 } // namespace Internal
--- a/src/plugins/qmakeprojectmanager/qmakemakestep.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakemakestep.cpp
@@ -167,8 +167,7 @@ bool QmakeMakeStep::init()
    pp->resolveAll();

    setOutputParser(new ProjectExplorer::GnuMakeParser());
-    ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(),
-                                                       ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+    ToolChain *tc = ToolChainKitAspect::cxxToolChain(target()->kit());
    if (tc && tc->targetAbi().os() == Abi::DarwinOS)
        appendOutputParser(new XcodebuildParser);
    IOutputParser *parser = target()->kit()->createOutputParser();
--- a/src/plugins/qmakeprojectmanager/qmakeproject.cpp
+++ b/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();

--- a/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
+++ b/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;
--- a/src/plugins/qmakeprojectmanager/qmakestep.cpp
+++ b/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
-            = ProjectExplorer::ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
-    ProjectExplorer::Abi targetAbi;
-    if (tc) {
+    Abi targetAbi;
+    if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit)) {
        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();
        }
    }
--- a/src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp
+++ b/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
-            = ProjectExplorer::ToolChainKitAspect::toolChain(m_target->kit(),
-                                                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID);
-
-    if (toolChain)
+    if (ToolChain *toolChain = ToolChainKitAspect::cxxToolChain(m_target->kit()))
        return toolChain->makeCommand(environment).toString();

    return QString();
--- a/src/plugins/qnx/qnxconfiguration.cpp
+++ b/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);
    }

--- a/src/plugins/qtsupport/baseqtversion.cpp
+++ b/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 (tc) {
+    if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(k)) {
        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);
    }
--- a/src/plugins/qtsupport/qtkitinformation.cpp
+++ b/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) {