ProjectExplorer: Some more ToolChain->Toolchain renamings

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

src/plugins/android/androidconfigurations.cpp

@@ -1124,13 +1124,13 @@ void AndroidConfigurations::setConfig(const AndroidConfig &devConfigs)
 
     m_instance->save();
     updateAndroidDevice();
-    registerNewToolChains();
+    registerNewToolchains();
     updateAutomaticKitList();
-    removeOldToolChains();
+    removeOldToolchains();
     emit m_instance->updated();
 }
 
-static bool matchToolChain(const Toolchain *atc, const Toolchain *btc)
+static bool matchToolchain(const Toolchain *atc, const Toolchain *btc)
 {
     if (atc == btc)
         return true;
@@ -1144,21 +1144,21 @@ static bool matchToolChain(const Toolchain *atc, const Toolchain *btc)
     return atc->targetAbi() == btc->targetAbi();
 }
 
-void AndroidConfigurations::registerNewToolChains()
+void AndroidConfigurations::registerNewToolchains()
 {
-    const Toolchains existingAndroidToolChains
+    const Toolchains existingAndroidToolchains
             = ToolchainManager::toolchains(Utils::equal(&Toolchain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
 
-    const Toolchains newToolchains = AndroidToolchainFactory::autodetectToolChains(
+    const Toolchains newToolchains = AndroidToolchainFactory::autodetectToolchains(
-        existingAndroidToolChains);
+        existingAndroidToolchains);
 
     for (Toolchain *tc : newToolchains)
         ToolchainManager::registerToolchain(tc);
 
-    registerCustomToolChainsAndDebuggers();
+    registerCustomToolchainsAndDebuggers();
 }
 
-void AndroidConfigurations::removeOldToolChains()
+void AndroidConfigurations::removeOldToolchains()
 {
     const auto tcs = ToolchainManager::toolchains(Utils::equal(&Toolchain::typeId,
                                                                Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
@@ -1246,7 +1246,7 @@ static QVariant findOrRegisterDebugger(Toolchain *tc,
                                        bool customDebugger = false)
 {
     const auto &currentConfig = AndroidConfigurations::currentConfig();
-    const FilePath ndk = static_cast<AndroidToolChain *>(tc)->ndkLocation();
+    const FilePath ndk = static_cast<AndroidToolchain *>(tc)->ndkLocation();
     const FilePath lldbCommand = currentConfig.lldbPathFromNdk(ndk);
     const Debugger::DebuggerItem *existingLldb = existingDebugger(lldbCommand,
                                                                   Debugger::LldbEngineType);
@@ -1304,22 +1304,22 @@ static QVariant findOrRegisterDebugger(Toolchain *tc,
     return registeredLldb.isNull() ? registeredGdb : registeredLldb;
 }
 
-void AndroidConfigurations::registerCustomToolChainsAndDebuggers()
+void AndroidConfigurations::registerCustomToolchainsAndDebuggers()
 {
-    const Toolchains existingAndroidToolChains = ToolchainManager::toolchains(
+    const Toolchains existingAndroidToolchains = ToolchainManager::toolchains(
         Utils::equal(&Toolchain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
 
     const FilePaths customNdks = FileUtils::toFilePathList(currentConfig().getCustomNdkList());
     const Toolchains customToolchains
-        = AndroidToolchainFactory::autodetectToolChainsFromNdks(existingAndroidToolChains,
+        = AndroidToolchainFactory::autodetectToolchainsFromNdks(existingAndroidToolchains,
                                                                 customNdks,
                                                                 true);
     for (Toolchain *tc : customToolchains) {
         ToolchainManager::registerToolchain(tc);
-        const auto androidToolChain = static_cast<AndroidToolChain *>(tc);
+        const auto androidToolchain = static_cast<AndroidToolchain *>(tc);
         QString abiStr;
-        if (androidToolChain)
+        if (androidToolchain)
-            abiStr = androidToolChain->platformLinkerFlags().at(1).split('-').first();
+            abiStr = androidToolchain->platformLinkerFlags().at(1).split('-').first();
         findOrRegisterDebugger(tc, {abiStr}, true);
     }
 }
@@ -1369,27 +1369,27 @@ void AndroidConfigurations::updateAutomaticKitList()
             continue;
 
         for (const QtVersion *qt : qtVersionsForArch.value(tc->targetAbi())) {
-            FilePath tcNdk = static_cast<const AndroidToolChain *>(tc)->ndkLocation();
+            FilePath tcNdk = static_cast<const AndroidToolchain *>(tc)->ndkLocation();
             if (tcNdk != currentConfig().ndkLocation(qt))
                 continue;
 
             const Toolchains allLanguages
                 = Utils::filtered(toolchains, [tc, tcNdk](Toolchain *otherTc) {
-                      FilePath otherNdk = static_cast<const AndroidToolChain *>(otherTc)->ndkLocation();
+                      FilePath otherNdk = static_cast<const AndroidToolchain *>(otherTc)->ndkLocation();
                       return tc->targetAbi() == otherTc->targetAbi() && tcNdk == otherNdk;
                   });
 
-            QHash<Id, Toolchain *> toolChainForLanguage;
+            QHash<Id, Toolchain *> toolchainForLanguage;
             for (Toolchain *tc : allLanguages)
-                toolChainForLanguage[tc->language()] = tc;
+                toolchainForLanguage[tc->language()] = tc;
 
             Kit *existingKit = Utils::findOrDefault(existingKits, [&](const Kit *b) {
                 if (qt != QtKitAspect::qtVersion(b))
                     return false;
-                return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
+                return matchToolchain(toolchainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
-                                      ToolchainKitAspect::cxxToolChain(b))
+                                      ToolchainKitAspect::cxxToolchain(b))
-                        && matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
+                        && matchToolchain(toolchainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
-                                          ToolchainKitAspect::cToolChain(b));
+                                          ToolchainKitAspect::cToolchain(b));
             });
 
             const auto initializeKit = [allLanguages, tc, qt](Kit *k) {
@@ -1397,7 +1397,7 @@ void AndroidConfigurations::updateAutomaticKitList()
                 k->setAutoDetectionSource("AndroidConfiguration");
                 DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE);
                 for (Toolchain *tc : allLanguages)
-                    ToolchainKitAspect::setToolChain(k, tc);
+                    ToolchainKitAspect::setToolchain(k, tc);
                 QtKitAspect::setQtVersion(k, qt);
                 QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis();
                 Debugger::DebuggerKitAspect::setDebugger(k, findOrRegisterDebugger(tc, abis));

src/plugins/android/androidconfigurations.h

@@ -185,10 +185,10 @@ public:
     static void setConfig(const AndroidConfig &config);
     static AndroidConfigurations *instance();
 
-    static void registerNewToolChains();
+    static void registerNewToolchains();
-    static void registerCustomToolChainsAndDebuggers();
+    static void registerCustomToolchainsAndDebuggers();
     static void removeUnusedDebuggers();
-    static void removeOldToolChains();
+    static void removeOldToolchains();
     static void updateAutomaticKitList();
     static bool force32bitEmulator();
 

src/plugins/android/androidmanager.cpp

@@ -183,7 +183,7 @@ QJsonObject deploymentSettings(const Target *target)
     if (!qt)
         return {};
 
-    auto tc = ToolchainKitAspect::cxxToolChain(target->kit());
+    auto tc = ToolchainKitAspect::cxxToolchain(target->kit());
     if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_TYPEID)
         return {};
     QJsonObject settings;

src/plugins/android/androidpackageinstallationstep.cpp

@@ -73,7 +73,7 @@ bool AndroidPackageInstallationStep::init()
         return false;
     }
 
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit());
     QTC_ASSERT(tc, reportWarningOrError(Tr::tr("\"%1\" step has an invalid C++ toolchain.")
                                         .arg(displayName()), Task::TaskType::Error);
             return false);

src/plugins/android/androidplugin.cpp

@@ -132,11 +132,11 @@ void AndroidPlugin::kitsRestored()
                 &AndroidPlugin::askUserAboutAndroidSetup, Qt::QueuedConnection);
     }
 
-    AndroidConfigurations::registerNewToolChains();
+    AndroidConfigurations::registerNewToolchains();
     AndroidConfigurations::updateAutomaticKitList();
     connect(QtSupport::QtVersionManager::instance(), &QtSupport::QtVersionManager::qtVersionsChanged,
             AndroidConfigurations::instance(), [] {
-        AndroidConfigurations::registerNewToolChains();
+        AndroidConfigurations::registerNewToolchains();
         AndroidConfigurations::updateAutomaticKitList();
     });
     disconnect(KitManager::instance(), &KitManager::kitsLoaded,

src/plugins/android/androidtoolchain.cpp

@@ -34,8 +34,8 @@ Q_GLOBAL_STATIC_WITH_ARGS(ClangTargetsType, ClangTargets, ({
          Abi(Abi::ArmArchitecture, Abi::LinuxOS, Abi::AndroidLinuxFlavor, Abi::ElfFormat, 64)}}
 ));
 
-static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &target,
+static Toolchain *findToolchain(FilePath &compilerPath, Id lang, const QString &target,
-                                const ToolChainList &alreadyKnown)
+                                const ToolchainList &alreadyKnown)
 {
     Toolchain *tc = Utils::findOrDefault(alreadyKnown, [target, compilerPath, lang](Toolchain *tc) {
         return tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
@@ -46,25 +46,25 @@ static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &
     return tc;
 }
 
-AndroidToolChain::AndroidToolChain()
+AndroidToolchain::AndroidToolchain()
     : GccToolchain(Constants::ANDROID_TOOLCHAIN_TYPEID, Clang)
 {
     setTypeDisplayName(Tr::tr("Android Clang"));
 }
 
-FilePath AndroidToolChain::ndkLocation() const
+FilePath AndroidToolchain::ndkLocation() const
 {
     return m_ndkLocation;
 }
 
-void AndroidToolChain::setNdkLocation(const FilePath &ndkLocation)
+void AndroidToolchain::setNdkLocation(const FilePath &ndkLocation)
 {
     m_ndkLocation = ndkLocation;
 }
 
-AndroidToolChain::~AndroidToolChain() = default;
+AndroidToolchain::~AndroidToolchain() = default;
 
-bool AndroidToolChain::isValid() const
+bool AndroidToolchain::isValid() const
 {
     if (m_ndkLocation.isEmpty()) {
         QStringList ndkParts(compilerCommand().toString().split("toolchains/llvm/prebuilt/"));
@@ -85,7 +85,7 @@ bool AndroidToolChain::isValid() const
            && !originalTargetTriple().isEmpty();
 }
 
-void AndroidToolChain::addToEnvironment(Environment &env) const
+void AndroidToolchain::addToEnvironment(Environment &env) const
 {
     const AndroidConfig &config = AndroidConfigurations::currentConfig();
     env.set(QLatin1String("ANDROID_NDK_HOST"), config.toolchainHostFromNdk(m_ndkLocation));
@@ -102,7 +102,7 @@ void AndroidToolChain::addToEnvironment(Environment &env) const
     env.set(QLatin1String("ANDROID_SDK_ROOT"), config.sdkLocation().toUserOutput());
 }
 
-void AndroidToolChain::fromMap(const Store &data)
+void AndroidToolchain::fromMap(const Store &data)
 {
     GccToolchain::fromMap(data);
     if (hasError())
@@ -111,19 +111,19 @@ void AndroidToolChain::fromMap(const Store &data)
         reportError();
 }
 
-QStringList AndroidToolChain::suggestedMkspecList() const
+QStringList AndroidToolchain::suggestedMkspecList() const
 {
     return {"android-g++", "android-clang"};
 }
 
-FilePath AndroidToolChain::makeCommand(const Environment &env) const
+FilePath AndroidToolchain::makeCommand(const Environment &env) const
 {
     Q_UNUSED(env)
     FilePath makePath = AndroidConfigurations::currentConfig().makePathFromNdk(m_ndkLocation);
     return makePath.exists() ? makePath : FilePath("make");
 }
 
-GccToolchain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
+GccToolchain::DetectedAbisResult AndroidToolchain::detectSupportedAbis() const
 {
     for (auto itr = ClangTargets->constBegin(); itr != ClangTargets->constEnd(); ++itr) {
         if (itr.value() == targetAbi())
@@ -132,17 +132,14 @@ GccToolchain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
     return GccToolchain::DetectedAbisResult({targetAbi()}, "");
 }
 
-
+// AndroidToolchainFactory
-// --------------------------------------------------------------------------
-// ToolChainFactory
-// --------------------------------------------------------------------------
 
 AndroidToolchainFactory::AndroidToolchainFactory()
 {
     setDisplayName(Tr::tr("Android Clang"));
     setSupportedToolchainType(Constants::ANDROID_TOOLCHAIN_TYPEID);
     setSupportedLanguages({ProjectExplorer::Constants::CXX_LANGUAGE_ID});
-    setToolchainConstructor([] { return new AndroidToolChain; });
+    setToolchainConstructor([] { return new AndroidToolchain; });
 }
 
 static FilePath clangPlusPlusPath(const FilePath &clangPath)
@@ -169,14 +166,14 @@ static FilePaths uniqueNdksForCurrentQtVersions()
     return uniqueNdks;
 }
 
-ToolChainList AndroidToolchainFactory::autodetectToolChains(const ToolChainList &alreadyKnown)
+ToolchainList AndroidToolchainFactory::autodetectToolchains(const ToolchainList &alreadyKnown)
 {
     const QList<FilePath> uniqueNdks = uniqueNdksForCurrentQtVersions();
-    return autodetectToolChainsFromNdks(alreadyKnown, uniqueNdks);
+    return autodetectToolchainsFromNdks(alreadyKnown, uniqueNdks);
 }
 
-ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
+ToolchainList AndroidToolchainFactory::autodetectToolchainsFromNdks(
-    const ToolChainList &alreadyKnown,
+    const ToolchainList &alreadyKnown,
     const QList<FilePath> &ndkLocations,
     const bool isCustom)
 {
@@ -211,7 +208,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
             while (targetItr != ClangTargets->constEnd()) {
                 const Abi &abi = targetItr.value();
                 const QString target = targetItr.key();
-                Toolchain *tc = findToolChain(compilerCommand, lang, target, alreadyKnown);
+                Toolchain *tc = findToolchain(compilerCommand, lang, target, alreadyKnown);
 
                 QLatin1String customStr = isCustom ? QLatin1String("Custom ") : QLatin1String();
                 const QString displayName(customStr + QString("Android Clang (%1, %2, NDK %3)")
@@ -225,7 +222,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
                 } else {
                     qCDebug(androidTCLog) << "New Clang toolchain found" << abi.toString() << lang
                                           << "for NDK" << ndkLocation;
-                    auto atc = new AndroidToolChain();
+                    auto atc = new AndroidToolchain();
                     atc->setNdkLocation(ndkLocation);
                     atc->setOriginalTargetTriple(target);
                     atc->setLanguage(lang);
@@ -239,7 +236,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
                 // Do not only reset newly created toolchains. This triggers call to
                 // addToEnvironment, so that e.g. JAVA_HOME gets updated.
                 if (auto gccTc = dynamic_cast<GccToolchain*>(tc))
-                    gccTc->resetToolChain(compilerCommand);
+                    gccTc->resetToolchain(compilerCommand);
 
                 tc->setDetection(Toolchain::AutoDetection);
                 result << tc;

src/plugins/android/androidtoolchain.h

@@ -9,12 +9,12 @@
 
 namespace Android::Internal {
 
-using ToolChainList = QList<ProjectExplorer::Toolchain *>;
+using ToolchainList = QList<ProjectExplorer::Toolchain *>;
 
-class AndroidToolChain : public ProjectExplorer::GccToolchain
+class AndroidToolchain : public ProjectExplorer::GccToolchain
 {
 public:
-    ~AndroidToolChain() override;
+    ~AndroidToolchain() override;
 
     bool isValid() const override;
     void addToEnvironment(Utils::Environment &env) const override;
@@ -30,7 +30,7 @@ protected:
     DetectedAbisResult detectSupportedAbis() const override;
 
 private:
-    explicit AndroidToolChain();
+    explicit AndroidToolchain();
 
     friend class AndroidToolchainFactory;
 
@@ -42,7 +42,7 @@ class AndroidToolchainFactory : public ProjectExplorer::ToolchainFactory
 public:
     AndroidToolchainFactory();
 
-    class AndroidToolChainInformation
+    class AndroidToolchainInformation
     {
     public:
         Utils::Id language;
@@ -51,8 +51,8 @@ public:
         QString version;
     };
 
-    static ToolChainList autodetectToolChains(const ToolChainList &alreadyKnown);
+    static ToolchainList autodetectToolchains(const ToolchainList &alreadyKnown);
-    static ToolChainList autodetectToolChainsFromNdks(const ToolChainList &alreadyKnown,
+    static ToolchainList autodetectToolchainsFromNdks(const ToolchainList &alreadyKnown,
                                                       const QList<Utils::FilePath> &ndkLocations,
                                                       const bool isCustom = false);
 };

src/plugins/autotest/autotestunittests.cpp

@@ -59,7 +59,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::cxxToolChain(m_kit);
+    const Toolchain * const toolchain = ToolchainKitAspect::cxxToolchain(m_kit);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 

src/plugins/autotest/loadprojectscenario.cpp

@@ -56,7 +56,7 @@ bool LoadProjectScenario::init()
         return false;
     }
 
-    const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
+    const Toolchain * const toolchain = ToolchainKitAspect::cxxToolchain(m_kit);
     if (!toolchain) {
         qWarning() << "This test requires that there is a kit with a toolchain.";
         return false;

src/plugins/autotoolsprojectmanager/autotoolsbuildsystem.cpp

@@ -144,8 +144,8 @@ void AutotoolsBuildSystem::updateCppCodeModel()
         cxxflags = cflags;
 
     const FilePath includeFileBaseDir = projectDirectory();
-    rpp.setFlagsForC({kitInfo.cToolChain, cflags, includeFileBaseDir});
+    rpp.setFlagsForC({kitInfo.cToolchain, cflags, includeFileBaseDir});
-    rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxflags, includeFileBaseDir});
+    rpp.setFlagsForCxx({kitInfo.cxxToolchain, cxxflags, includeFileBaseDir});
 
     const QString absSrc = project()->projectDirectory().toString();
     BuildConfiguration *bc = target()->activeBuildConfiguration();

src/plugins/clangtools/clangtool.cpp

@@ -1034,7 +1034,7 @@ static bool canAnalyzeProject(Project *project)
                                              || project->projectLanguages().contains(cxx);
         return projectSupportsLanguage
                && CppModelManager::projectInfo(project)
-               && ToolchainKitAspect::cxxToolChain(target->kit());
+               && ToolchainKitAspect::cxxToolchain(target->kit());
     }
     return false;
 }

src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp

@@ -148,7 +148,7 @@ static QList<Target *> validTargets(Project *project)
             return false;
         }
 
-        const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(kit);
+        const Toolchain * const toolchain = ToolchainKitAspect::cxxToolchain(kit);
         QTC_ASSERT(toolchain, return false);
 
         if (Core::ICore::clangExecutable(CLANG_BINDIR).isEmpty()) {

src/plugins/clangtools/clangtoolsunittests.cpp

@@ -50,7 +50,7 @@ void ClangToolsUnitTests::initTestCase()
     if (!m_kit)
         QSKIP("This test requires at least one valid kit with a valid Qt");
 
-    const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
+    const Toolchain * const toolchain = ToolchainKitAspect::cxxToolchain(m_kit);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 
@@ -87,7 +87,7 @@ void ClangToolsUnitTests::testProject()
     QFETCH(int, expectedDiagCountClazy);
     QFETCH(ClangDiagnosticConfig, diagnosticConfig);
     if (projectFilePath.contains("mingw")) {
-        const auto toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
+        const auto toolchain = ToolchainKitAspect::cxxToolchain(m_kit);
         if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID)
             QSKIP("This test is mingw specific, does not run for other toolchains");
     }

src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp

@@ -1091,7 +1091,7 @@ static bool isQnx(const Kit *k)
 
 static bool isWindowsARM64(const Kit *k)
 {
-    Toolchain *toolchain = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *toolchain = ToolchainKitAspect::cxxToolchain(k);
     if (!toolchain)
         return false;
     const Abi targetAbi = toolchain->targetAbi();
@@ -1124,7 +1124,7 @@ static CommandLine defaultInitialCMakeCommand(const Kit *k, const QString &build
         const QString sysRoot = SysRootKitAspect::sysRoot(k).path();
         if (!sysRoot.isEmpty()) {
             cmd.addArg("-DCMAKE_SYSROOT:PATH=" + sysRoot);
-            if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
+            if (Toolchain *tc = ToolchainKitAspect::cxxToolchain(k)) {
                 const QString targetTriple = tc->originalTargetTriple();
                 cmd.addArg("-DCMAKE_C_COMPILER_TARGET:STRING=" + targetTriple);
                 cmd.addArg("-DCMAKE_CXX_COMPILER_TARGET:STRING=" + targetTriple);

src/plugins/cmakeprojectmanager/cmakebuildstep.cpp

@@ -336,7 +336,7 @@ void CMakeBuildStep::setupOutputFormatter(Utils::OutputFormatter *formatter)
     formatter->addLineParser(progressParser);
     cmakeParser->setSourceDirectory(project()->projectDirectory());
     formatter->addLineParsers({cmakeParser, new GnuMakeParser});
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit());
     OutputTaskParser *xcodeBuildParser = nullptr;
     if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
         xcodeBuildParser = new XcodebuildParser;

src/plugins/cmakeprojectmanager/cmakebuildsystem.cpp

@@ -1351,10 +1351,10 @@ void CMakeBuildSystem::updateProjectData()
         addTargetFlagForIos(cFlags, cxxFlags, this, [this] {
             return m_configurationFromCMake.stringValueOf("CMAKE_OSX_DEPLOYMENT_TARGET");
         });
-        if (kitInfo.cxxToolChain)
+        if (kitInfo.cxxToolchain)
-            rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxFlags, includeFileBaseDir});
+            rpp.setFlagsForCxx({kitInfo.cxxToolchain, cxxFlags, includeFileBaseDir});
-        if (kitInfo.cToolChain)
+        if (kitInfo.cToolchain)
-            rpp.setFlagsForC({kitInfo.cToolChain, cFlags, includeFileBaseDir});
+            rpp.setFlagsForC({kitInfo.cToolchain, cFlags, includeFileBaseDir});
     }
 
     m_cppCodeModelUpdater->update({p, kitInfo, buildConfiguration()->environment(), rpps},

src/plugins/cmakeprojectmanager/cmakekitaspect.cpp

@@ -681,7 +681,7 @@ QVariant CMakeGeneratorKitAspectFactory::defaultValue(const Kit *k) const
 
     if (tool->filePath().osType() == OsTypeWindows) {
         // *sigh* Windows with its zoo of incompatible stuff again...
-        Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
+        Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
         if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
             it = std::find_if(known.constBegin(),
                               known.constEnd(),
@@ -1135,8 +1135,8 @@ Tasks CMakeConfigurationKitAspectFactory::validate(const Kit *k) const
         return Tasks();
 
     const QtSupport::QtVersion *const version = QtSupport::QtKitAspect::qtVersion(k);
-    const Toolchain *const tcC = ToolchainKitAspect::cToolChain(k);
+    const Toolchain *const tcC = ToolchainKitAspect::cToolchain(k);
-    const Toolchain *const tcCxx = ToolchainKitAspect::cxxToolChain(k);
+    const Toolchain *const tcCxx = ToolchainKitAspect::cxxToolchain(k);
     const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
 
     const bool isQt4 = version && version->qtVersion() < QVersionNumber(5, 0, 0);

src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp

@@ -56,7 +56,7 @@ struct DirectoryData
     QString toolset;
     FilePath sysroot;
     QtProjectImporter::QtVersionData qt;
-    QVector<ToolchainDescription> toolChains;
+    QVector<ToolchainDescription> toolchains;
 };
 
 static FilePaths scanDirectory(const FilePath &path, const QString &prefix)
@@ -464,7 +464,7 @@ static QMakeAndCMakePrefixPath qtInfoFromCMakeCache(const CMakeConfig &config,
     return {qmakeLocation, resultedPrefixPath};
 }
 
-static QVector<ToolchainDescription> extractToolChainsFromCache(const CMakeConfig &config)
+static QVector<ToolchainDescription> extractToolchainsFromCache(const CMakeConfig &config)
 {
     QVector<ToolchainDescription> result;
     bool haveCCxxCompiler = false;
@@ -563,7 +563,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
             return ci.key == key;
         });
 
-        auto tcd = Utils::findOrDefault(data->toolChains,
+        auto tcd = Utils::findOrDefault(data->toolchains,
                                         [&language](const ToolchainDescription &t) {
                                             return t.language == language;
                                         });
@@ -790,8 +790,8 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
                                       CMakeConfigItem::PATH,
                                       cmakePrefixPath.toUtf8());
 
-        // ToolChains:
+        // Toolchains:
-        data->toolChains = extractToolChainsFromCache(config);
+        data->toolchains = extractToolchainsFromCache(config);
 
         // Update QT_QMAKE_EXECUTABLE and CMAKE_C|XX_COMPILER config values
         updateConfigWithDirectoryData(config, data);
@@ -888,8 +888,8 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
         if (!qmake.isEmpty())
             data->qt = findOrCreateQtVersion(qmake);
 
-        // ToolChains:
+        // Toolchains:
-        data->toolChains = extractToolChainsFromCache(config);
+        data->toolchains = extractToolchainsFromCache(config);
 
         qCInfo(cmInputLog) << "Offering to import" << importPath.toUserOutput();
         result.push_back(static_cast<void *>(data.release()));
@@ -933,11 +933,11 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
 
     const bool compilersMatch = [k, data] {
         const QList<Id> allLanguages = ToolchainManager::allLanguages();
-        for (const ToolchainDescription &tcd : data->toolChains) {
+        for (const ToolchainDescription &tcd : data->toolchains) {
             if (!Utils::contains(allLanguages,
                                  [&tcd](const Id &language) { return language == tcd.language; }))
                 continue;
-            Toolchain *tc = ToolchainKitAspect::toolChain(k, tcd.language);
+            Toolchain *tc = ToolchainKitAspect::toolchain(k, tcd.language);
             if ((!tc || !tc->matchesCompilerCommand(tcd.compilerPath))) {
                 return false;
             }
@@ -946,11 +946,11 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
     }();
     const bool noCompilers = [k, data] {
         const QList<Id> allLanguages = ToolchainManager::allLanguages();
-        for (const ToolchainDescription &tcd : data->toolChains) {
+        for (const ToolchainDescription &tcd : data->toolchains) {
             if (!Utils::contains(allLanguages,
                                  [&tcd](const Id &language) { return language == tcd.language; }))
                 continue;
-            Toolchain *tc = ToolchainKitAspect::toolChain(k, tcd.language);
+            Toolchain *tc = ToolchainKitAspect::toolchain(k, tcd.language);
             if (tc && tc->matchesCompilerCommand(tcd.compilerPath)) {
                 return false;
             }
@@ -995,7 +995,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
 
         SysRootKitAspect::setSysRoot(k, data->sysroot);
 
-        for (const ToolchainDescription &cmtcd : data->toolChains) {
+        for (const ToolchainDescription &cmtcd : data->toolchains) {
             const ToolChainData tcd = findOrCreateToolChains(cmtcd);
             QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
 
@@ -1004,7 +1004,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
                     addTemporaryData(ToolchainKitAspect::id(), tc->id(), k);
             }
 
-            ToolchainKitAspect::setToolChain(k, tcd.tcs.at(0));
+            ToolchainKitAspect::setToolchain(k, tcd.tcs.at(0));
         }
 
         if (!data->cmakePresetDisplayname.isEmpty()) {
@@ -1143,11 +1143,11 @@ void CMakeProjectPlugin::testCMakeProjectImporterQt()
                                                              Environment::systemEnvironment());
     QCOMPARE(realQmake.path(), expectedQmake);
 }
-void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
+void CMakeProjectPlugin::testCMakeProjectImporterToolchain_data()
 {
     QTest::addColumn<QStringList>("cache");
     QTest::addColumn<QByteArrayList>("expectedLanguages");
-    QTest::addColumn<QStringList>("expectedToolChains");
+    QTest::addColumn<QStringList>("expectedToolchains");
 
     QTest::newRow("Empty input")
             << QStringList() << QByteArrayList() << QStringList();
@@ -1180,13 +1180,13 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
             << QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
 }
 
-void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
+void CMakeProjectPlugin::testCMakeProjectImporterToolchain()
 {
     QFETCH(QStringList, cache);
     QFETCH(QByteArrayList, expectedLanguages);
-    QFETCH(QStringList, expectedToolChains);
+    QFETCH(QStringList, expectedToolchains);
 
-    QCOMPARE(expectedLanguages.count(), expectedToolChains.count());
+    QCOMPARE(expectedLanguages.count(), expectedToolchains.count());
 
     CMakeConfig config;
     for (const QString &c : std::as_const(cache)) {
@@ -1197,11 +1197,11 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
         config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
     }
 
-    const QVector<ToolchainDescription> tcs = extractToolChainsFromCache(config);
+    const QVector<ToolchainDescription> tcs = extractToolchainsFromCache(config);
     QCOMPARE(tcs.count(), expectedLanguages.count());
     for (int i = 0; i < tcs.count(); ++i) {
         QCOMPARE(tcs.at(i).language, expectedLanguages.at(i));
-        QCOMPARE(tcs.at(i).compilerPath.toString(), expectedToolChains.at(i));
+        QCOMPARE(tcs.at(i).compilerPath.toString(), expectedToolchains.at(i));
     }
 }
 

src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp

@@ -407,8 +407,8 @@ void CMakeManager::buildFile(Node *node)
             return extension;
 
         const auto toolchain = ProjectFile::isCxx(sourceKind)
-                                   ? ToolchainKitAspect::cxxToolChain(target->kit())
+                                   ? ToolchainKitAspect::cxxToolchain(target->kit())
-                                   : ToolchainKitAspect::cToolChain(target->kit());
+                                   : ToolchainKitAspect::cToolchain(target->kit());
         using namespace ProjectExplorer::Constants;
         static QSet<Id> objIds{
             CLANG_CL_TOOLCHAIN_TYPEID,

src/plugins/cmakeprojectmanager/cmakeprojectplugin.h

@@ -28,8 +28,8 @@ private slots:
     void testCMakeProjectImporterQt_data();
     void testCMakeProjectImporterQt();
 
-    void testCMakeProjectImporterToolChain_data();
+    void testCMakeProjectImporterToolchain_data();
-    void testCMakeProjectImporterToolChain();
+    void testCMakeProjectImporterToolchain();
 #endif
 
 private:

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp

@@ -108,7 +108,7 @@ QString compilerPath(QString pathFlag)
 Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
 {
     if (flags.empty())
-        return ToolchainKitAspect::toolChain(kit, language);
+        return ToolchainKitAspect::toolchain(kit, language);
 
     // Try exact compiler match.
     const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front()));
@@ -131,7 +131,7 @@ Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Ut
             return toolchain;
     }
 
-    toolchain = ToolchainKitAspect::toolChain(kit, language);
+    toolchain = ToolchainKitAspect::toolchain(kit, language);
     qWarning() << "No matching toolchain found, use the default.";
     return toolchain;
 }
@@ -179,21 +179,21 @@ RawProjectPart makeRawProjectPart(const Utils::FilePath &projectFile,
 
     if (fileKind == CppEditor::ProjectFile::Kind::CHeader
             || fileKind == CppEditor::ProjectFile::Kind::CSource) {
-        if (!kitInfo.cToolChain) {
+        if (!kitInfo.cToolchain) {
-            kitInfo.cToolChain = toolchainFromFlags(kit,
+            kitInfo.cToolchain = toolchainFromFlags(kit,
                                                     originalFlags,
                                                     ProjectExplorer::Constants::C_LANGUAGE_ID);
         }
-        addDriverModeFlagIfNeeded(kitInfo.cToolChain, flags, originalFlags);
+        addDriverModeFlagIfNeeded(kitInfo.cToolchain, flags, originalFlags);
-        rpp.setFlagsForC({kitInfo.cToolChain, flags, workingDir});
+        rpp.setFlagsForC({kitInfo.cToolchain, flags, workingDir});
     } else {
-        if (!kitInfo.cxxToolChain) {
+        if (!kitInfo.cxxToolchain) {
-            kitInfo.cxxToolChain = toolchainFromFlags(kit,
+            kitInfo.cxxToolchain = toolchainFromFlags(kit,
                                                       originalFlags,
                                                       ProjectExplorer::Constants::CXX_LANGUAGE_ID);
         }
-        addDriverModeFlagIfNeeded(kitInfo.cxxToolChain, flags, originalFlags);
+        addDriverModeFlagIfNeeded(kitInfo.cxxToolchain, flags, originalFlags);
-        rpp.setFlagsForCxx({kitInfo.cxxToolChain, flags, workingDir});
+        rpp.setFlagsForCxx({kitInfo.cxxToolchain, flags, workingDir});
     }
 
     return rpp;
@@ -350,8 +350,8 @@ void CompilationDatabaseBuildSystem::buildTreeAndProjectParts()
     ProjectExplorer::KitInfo kitInfo(k);
     QTC_ASSERT(kitInfo.isValid(), return);
     // Reset toolchains to pick them based on the database entries.
-    kitInfo.cToolChain = nullptr;
+    kitInfo.cToolchain = nullptr;
-    kitInfo.cxxToolChain = nullptr;
+    kitInfo.cxxToolchain = nullptr;
     RawProjectParts rpps;
 
     QTC_ASSERT(m_parser, return);

src/plugins/conan/conaninstallstep.cpp

@@ -106,7 +106,7 @@ ConanInstallStep::ConanInstallStep(BuildStepList *bsl, Id id)
     setSummaryUpdater([this]() -> QString {
         QList<Toolchain *> tcList = ToolchainKitAspect::toolChains(target()->kit());
         if (tcList.isEmpty())
-            return "<b>" + ToolchainKitAspect::msgNoToolChainInTarget() + "</b>";
+            return "<b>" + ToolchainKitAspect::msgNoToolchainInTarget() + "</b>";
         ProcessParameters param;
         setupProcessParameters(&param);
         return param.summary(displayName());

src/plugins/cppcheck/cppcheckplugin.cpp

@@ -135,7 +135,7 @@ void CppcheckPluginPrivate::updateManualRunAction()
     const Target *target = ProjectManager::startupTarget();
     const Utils::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
     const bool canRun = target && project->projectLanguages().contains(cxx)
-                  && ToolchainKitAspect::cxxToolChain(target->kit());
+                  && ToolchainKitAspect::cxxToolchain(target->kit());
     manualRunAction->setEnabled(canRun);
 }
 

src/plugins/cppeditor/cppmodelmanager.cpp

@@ -412,9 +412,9 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
     const Toolchain * tc = nullptr;
     const ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString()));
     if (classifier.isC()) {
-        tc = ToolchainKitAspect::cToolChain(project->activeTarget()->kit());
+        tc = ToolchainKitAspect::cToolchain(project->activeTarget()->kit());
     } else if (classifier.isCxx() || classifier.isHeader()) {
-        tc = ToolchainKitAspect::cxxToolChain(project->activeTarget()->kit());
+        tc = ToolchainKitAspect::cxxToolchain(project->activeTarget()->kit());
     } else {
         showFallbackWarning(Tr::tr("Could not determine which compiler to invoke."));
         useBuiltinPreprocessor();
@@ -1968,7 +1968,7 @@ void CppModelManager::setupFallbackProjectPart()
     // TODO: Use different fallback toolchain for different kinds of files?
     const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr;
     const Toolchain * const defaultTc = defaultKit
-            ? ToolchainKitAspect::cxxToolChain(defaultKit) : nullptr;
+            ? ToolchainKitAspect::cxxToolchain(defaultKit) : nullptr;
     if (defaultKit && defaultTc) {
         FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
         if (sysroot.isEmpty())

src/plugins/cppeditor/cppprojectinfogenerator.cpp

@@ -66,7 +66,7 @@ const QVector<ProjectPart::ConstPtr> ProjectInfoGenerator::createProjectParts(
     if (!cat.hasParts())
         return result;
 
-    if (m_projectUpdateInfo.cxxToolChainInfo.isValid()) {
+    if (m_projectUpdateInfo.cxxToolchainInfo.isValid()) {
         if (cat.hasCxxSources()) {
             result << createProjectPart(projectFilePath,
                                         rawProjectPart,
@@ -87,7 +87,7 @@ const QVector<ProjectPart::ConstPtr> ProjectInfoGenerator::createProjectParts(
         m_cxxToolchainMissing = true;
     }
 
-    if (m_projectUpdateInfo.cToolChainInfo.isValid()) {
+    if (m_projectUpdateInfo.cToolchainInfo.isValid()) {
         if (cat.hasCSources()) {
             result << createProjectPart(projectFilePath,
                                         rawProjectPart,
@@ -124,12 +124,12 @@ ProjectPart::ConstPtr ProjectInfoGenerator::createProjectPart(
     ToolChainInfo tcInfo;
     if (language == Language::C) {
         flags = rawProjectPart.flagsForC;
-        tcInfo = m_projectUpdateInfo.cToolChainInfo;
+        tcInfo = m_projectUpdateInfo.cToolchainInfo;
     }
     // Use Cxx toolchain for C projects without C compiler in kit and for C++ code
     if (!tcInfo.isValid()) {
         flags = rawProjectPart.flagsForCxx;
-        tcInfo = m_projectUpdateInfo.cxxToolChainInfo;
+        tcInfo = m_projectUpdateInfo.cxxToolchainInfo;
     }
 
     QString explicitTarget;

src/plugins/cppeditor/projectinfo_test.cpp

@@ -356,8 +356,8 @@ public:
     ProjectInfoGeneratorTestHelper()
     {
         TestToolchain aToolChain;
-        projectUpdateInfo.cxxToolChainInfo = {&aToolChain, {}, {}};
+        projectUpdateInfo.cxxToolchainInfo = {&aToolChain, {}, {}};
-        projectUpdateInfo.cToolChainInfo = {&aToolChain, {}, {}};
+        projectUpdateInfo.cToolchainInfo = {&aToolChain, {}, {}};
     }
 
     ProjectInfo::ConstPtr generate()
@@ -426,7 +426,7 @@ void ProjectInfoGeneratorTest::testProjectPartHasLatestLanguageVersionByDefault(
 void ProjectInfoGeneratorTest::testUseMacroInspectionReportForLanguageVersion()
 {
     ProjectInfoGeneratorTestHelper t;
-    t.projectUpdateInfo.cxxToolChainInfo.macroInspectionRunner = [](const QStringList &) {
+    t.projectUpdateInfo.cxxToolchainInfo.macroInspectionRunner = [](const QStringList &) {
         return TestToolchain::MacroInspectionReport{Macros(), Utils::LanguageVersion::CXX17};
     };
     t.rawProjectPart.files = QStringList{ "foo.cpp" };

src/plugins/docker/kitdetector.cpp

@@ -364,7 +364,7 @@ void KitDetectorPrivate::autoDetect()
                    && (!qt || qt->qtAbis().contains(tc->targetAbi()));
         });
         for (Toolchain *toolChain : toolchainsToSet)
-            ToolchainKitAspect::setToolChain(k, toolChain);
+            ToolchainKitAspect::setToolchain(k, toolChain);
 
         if (cmakeId.isValid())
             k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true);

src/plugins/incredibuild/makecommandbuilder.cpp

@@ -37,7 +37,7 @@ FilePath MakeCommandBuilder::defaultCommand() const
 {
     if (BuildConfiguration *buildConfig = buildStep()->buildConfiguration()) {
         if (Target *target = buildStep()->target()) {
-            if (Toolchain *toolChain = ToolchainKitAspect::cxxToolChain(target->kit()))
+            if (Toolchain *toolChain = ToolchainKitAspect::cxxToolchain(target->kit()))
                 return toolChain->makeCommand(buildConfig->environment());
         }
     }

src/plugins/ios/iosbuildstep.cpp

@@ -148,7 +148,7 @@ bool IosBuildStep::init()
     if (!AbstractProcessStep::init())
         return false;
 
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit());
     if (!tc) {
         emit addTask(Task::compilerMissingTask());
         emitFaultyConfigurationMessage();
@@ -195,7 +195,7 @@ QStringList IosBuildStep::defaultArguments() const
 {
     QStringList res;
     Kit *kit = target()->kit();
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit);
     switch (buildConfiguration()->buildType()) {
     case BuildConfiguration::Debug :
         res << "-configuration" << "Debug";

src/plugins/ios/iosconfigurations.cpp

@@ -171,13 +171,13 @@ static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains,
 {
     DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
     if (toolChains.first)
-        ToolchainKitAspect::setToolChain(kit, toolChains.first);
+        ToolchainKitAspect::setToolchain(kit, toolChains.first);
     else
-        ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
+        ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
     if (toolChains.second)
-        ToolchainKitAspect::setToolChain(kit, toolChains.second);
+        ToolchainKitAspect::setToolchain(kit, toolChains.second);
     else
-        ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+        ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     QtKitAspect::setQtVersion(kit, qtVersion);
     // only replace debugger with the default one if we find an unusable one here
@@ -274,8 +274,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::cxxToolChain(kit) == platformToolchains.second
+                            && ToolchainKitAspect::cxxToolchain(kit) == platformToolchains.second
-                            && ToolchainKitAspect::cToolChain(kit) == platformToolchains.first
+                            && ToolchainKitAspect::cToolchain(kit) == platformToolchains.first
                             && QtKitAspect::qtVersion(kit) == qtVersion;
                 });
                 QTC_ASSERT(!resultingKits.contains(kit), continue);
@@ -599,7 +599,7 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
                     toolChain->setDisplayName(target.name);
                     toolChain->setPlatformCodeGenFlags(target.backendFlags);
                     toolChain->setPlatformLinkerFlags(target.backendFlags);
-                    toolChain->resetToolChain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ?
+                    toolChain->resetToolchain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ?
                                                   platform.cxxCompilerPath : platform.cCompilerPath);
                     existingClangToolChains.append(toolChain);
                 }

src/plugins/mcusupport/mcukitmanager.cpp

@@ -85,10 +85,10 @@ public:
         case McuToolChainPackage::ToolChainType::GCC:
         case McuToolChainPackage::ToolChainType::MinGW:
         case McuToolChainPackage::ToolChainType::ArmGcc:
-            ToolchainKitAspect::setToolChain(k,
+            ToolchainKitAspect::setToolchain(k,
                                              tcPackage->toolChain(
                                                  ProjectExplorer::Constants::C_LANGUAGE_ID));
-            ToolchainKitAspect::setToolChain(k,
+            ToolchainKitAspect::setToolchain(k,
                                              tcPackage->toolChain(
                                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID));
             return;

src/plugins/mesonprojectmanager/mesonbuildsystem.cpp

@@ -245,7 +245,7 @@ void MesonBuildSystem::parsingCompleted(bool success)
                 {project(),
                  QtSupport::CppKitInfo(kit()),
                  buildConfiguration()->environment(),
-                 m_parser.buildProjectParts(kitInfo.cxxToolChain, kitInfo.cToolChain)});
+                 m_parser.buildProjectParts(kitInfo.cxxToolchain, kitInfo.cToolchain)});
         }
         setApplicationTargets(m_parser.appsTargets());
         UNLOCK(true);

src/plugins/nim/project/nimbuildsystem.cpp

@@ -169,7 +169,7 @@ void NimBuildSystem::triggerParsing()
 
 FilePath nimPathFromKit(Kit *kit)
 {
-    auto tc = ToolchainKitAspect::toolChain(kit, Constants::C_NIMLANGUAGE_ID);
+    auto tc = ToolchainKitAspect::toolchain(kit, Constants::C_NIMLANGUAGE_ID);
     QTC_ASSERT(tc, return {});
     const FilePath command = tc->compilerCommand();
     return command.isEmpty() ? FilePath() : command.absolutePath();

src/plugins/nim/project/nimcompilerbuildstep.cpp

@@ -159,7 +159,7 @@ CommandLine NimCompilerBuildStep::commandLine()
     auto bc = qobject_cast<NimBuildConfiguration *>(buildConfiguration());
     QTC_ASSERT(bc, return {});
 
-    auto tc = ToolchainKitAspect::toolChain(kit(), Constants::C_NIMLANGUAGE_ID);
+    auto tc = ToolchainKitAspect::toolchain(kit(), Constants::C_NIMLANGUAGE_ID);
     QTC_ASSERT(tc, return {});
 
     CommandLine cmd{tc->compilerCommand()};

src/plugins/nim/project/nimproject.cpp

@@ -52,7 +52,7 @@ NimProject::NimProject(const FilePath &filePath) : Project(Constants::C_NIM_MIME
 Tasks NimProject::projectIssues(const Kit *k) const
 {
     Tasks result = Project::projectIssues(k);
-    auto tc = ToolchainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID);
+    auto tc = ToolchainKitAspect::toolchain(k, Constants::C_NIMLANGUAGE_ID);
     if (!tc) {
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Nim compiler set.")));
         return result;

src/plugins/perfprofiler/perfdatareader.cpp

@@ -288,7 +288,7 @@ void PerfDataReader::collectArguments(CommandLine *cmd, const QString &exe, cons
                      .arg(cmd->executable().osType() == OsTypeWindows ? u';' : u':'));
     }
 
-    if (auto toolChain = ToolchainKitAspect::cxxToolChain(kit)) {
+    if (auto toolChain = ToolchainKitAspect::cxxToolchain(kit)) {
         Abi::Architecture architecture = toolChain->targetAbi().architecture();
         if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) {
             cmd->addArg("--arch");

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -458,7 +458,7 @@ static const GccToolchain *mingwToolChainFromId(const QByteArray &id)
 QString GccToolchain::originalTargetTriple() const
 {
     if (m_subType == Clang) {
-        if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId))
+        if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolchainId))
             return parentTC->originalTargetTriple();
     }
 
@@ -866,7 +866,7 @@ QStringList GccToolchain::suggestedMkspecList() const
     }
 
     if (m_subType == Clang) {
-        if (const Toolchain * const parentTc = ToolchainManager::findToolchain(m_parentToolChainId))
+        if (const Toolchain * const parentTc = ToolchainManager::findToolchain(m_parentToolchainId))
             return parentTc->suggestedMkspecList();
         const Abi abi = targetAbi();
         if (abi.os() == Abi::DarwinOS)
@@ -950,7 +950,7 @@ QList<OutputLineParser *> GccToolchain::createOutputParsers() const
     return GccParser::gccParserSuite();
 }
 
-void GccToolchain::resetToolChain(const FilePath &path)
+void GccToolchain::resetToolchain(const FilePath &path)
 {
     bool resetDisplayName = (displayName() == defaultDisplayName());
 
@@ -1021,7 +1021,7 @@ void GccToolchain::toMap(Store &data) const
     data.insert(supportedAbisKeyC, Utils::transform<QStringList>(m_supportedAbis, &Abi::toString));
 
     if (m_subType == Clang) {
-        data.insert(parentToolChainIdKeyC, m_parentToolChainId);
+        data.insert(parentToolChainIdKeyC, m_parentToolchainId);
         data.insert(priorityKeyC, m_priority);
     }
 }
@@ -1042,10 +1042,10 @@ void GccToolchain::fromMap(const Store &data)
 
     const QString targetAbiString = data.value(targetAbiKeyC).toString();
     if (targetAbiString.isEmpty())
-        resetToolChain(compilerCommand());
+        resetToolchain(compilerCommand());
 
     if (m_subType == Clang) {
-        m_parentToolChainId = data.value(parentToolChainIdKeyC).toByteArray();
+        m_parentToolchainId = data.value(parentToolChainIdKeyC).toByteArray();
         m_priority = data.value(priorityKeyC, PriorityNormal).toInt();
         syncAutodetectedWithParentToolchains();
     }
@@ -1814,13 +1814,13 @@ void GccToolchainConfigWidget::applyImpl()
 
     if (m_subType == GccToolchain::Clang && m_parentToolchainCombo) {
 
-        tc->m_parentToolChainId.clear();
+        tc->m_parentToolchainId.clear();
 
         const QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
         if (!parentId.isEmpty()) {
             for (const Toolchain *mingwTC : mingwToolChains()) {
                 if (parentId == mingwTC->id()) {
-                    tc->m_parentToolChainId = mingwTC->id();
+                    tc->m_parentToolchainId = mingwTC->id();
                     tc->setTargetAbi(mingwTC->targetAbi());
                     tc->setSupportedAbis(mingwTC->supportedAbis());
                     break;
@@ -1868,7 +1868,7 @@ bool GccToolchainConfigWidget::isDirtyImpl() const
     if (!m_parentToolchainCombo)
         return false;
 
-    const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolChainId);
+    const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolchainId);
     const QByteArray parentId = parentTC ? parentTC->id() : QByteArray();
     return parentId != m_parentToolchainCombo->currentData();
 }
@@ -1967,9 +1967,9 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
         return;
     }
 
-    if (!mingwToolChainFromId(m_parentToolChainId)) {
+    if (!mingwToolChainFromId(m_parentToolchainId)) {
         const Toolchains mingwTCs = mingwToolChains();
-        m_parentToolChainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
+        m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
     }
 
     // Subscribe only autodetected toolchains.
@@ -1977,8 +1977,8 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
     m_mingwToolchainAddedConnection
         = connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
               if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
-                  && !mingwToolChainFromId(m_parentToolChainId)) {
+                  && !mingwToolChainFromId(m_parentToolchainId)) {
-                  m_parentToolChainId = tc->id();
+                  m_parentToolchainId = tc->id();
               }
           });
     m_thisToolchainRemovedConnection
@@ -1986,9 +1986,9 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
               if (tc == this) {
                   QObject::disconnect(m_thisToolchainRemovedConnection);
                   QObject::disconnect(m_mingwToolchainAddedConnection);
-              } else if (m_parentToolChainId == tc->id()) {
+              } else if (m_parentToolchainId == tc->id()) {
                   const Toolchains mingwTCs = mingwToolChains();
-                  m_parentToolChainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
+                  m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
               }
           });
 }
@@ -2018,7 +2018,7 @@ bool GccToolchain::matchesCompilerCommand(const FilePath &command) const
 QString GccToolchain::sysRoot() const
 {
     if (m_subType == Clang) {
-        if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId)) {
+        if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolchainId)) {
             const FilePath mingwCompiler = parentTC->compilerCommand();
             return mingwCompiler.parentDir().parentDir().toString();
         }
@@ -2033,7 +2033,7 @@ void GccToolchainConfigWidget::updateParentToolChainComboBox()
     auto *tc = static_cast<GccToolchain *>(toolChain());
     QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
     if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
-        parentId = tc->m_parentToolChainId;
+        parentId = tc->m_parentToolchainId;
 
     const GccToolchain *parentTC = mingwToolChainFromId(parentId);
 

src/plugins/projectexplorer/gcctoolchain.h

@@ -59,7 +59,7 @@ public:
 
     bool operator ==(const Toolchain &) const override;
 
-    void resetToolChain(const Utils::FilePath &);
+    void resetToolchain(const Utils::FilePath &);
     void setPlatformCodeGenFlags(const QStringList &);
     QStringList extraCodeModelFlags() const override;
     QStringList platformCodeGenFlags() const;
@@ -155,7 +155,7 @@ private:
     // "resolved" on macOS from /usr/bin/clang(++) etc to <DeveloperDir>/usr/bin/clang(++)
     // which is used for comparison with matchesCompilerCommand
     mutable std::optional<Utils::FilePath> m_resolvedCompilerCommand;
-    QByteArray m_parentToolChainId;
+    QByteArray m_parentToolchainId;
     int m_priority = PriorityNormal;
     QMetaObject::Connection m_mingwToolchainAddedConnection;
     QMetaObject::Connection m_thisToolchainRemovedConnection;

src/plugins/projectexplorer/kitaspects.cpp

@@ -272,7 +272,7 @@ private:
                 cb->addItem(item->displayName(), item->id());
 
             cb->setEnabled(cb->count() > 1 && !m_isReadOnly);
-            const int index = indexOf(cb, ToolchainKitAspect::toolChain(m_kit, l));
+            const int index = indexOf(cb, ToolchainKitAspect::toolchain(m_kit, l));
             cb->setCurrentIndex(index);
         }
     }
@@ -295,9 +295,9 @@ private:
         Toolchain *tc = ToolchainManager::findToolchain(id);
         QTC_ASSERT(!tc || tc->language() == language, return);
         if (tc)
-            ToolchainKitAspect::setToolChain(m_kit, tc);
+            ToolchainKitAspect::setToolchain(m_kit, tc);
         else
-            ToolchainKitAspect::clearToolChain(m_kit, language);
+            ToolchainKitAspect::clearToolchain(m_kit, language);
     }
 
     int indexOf(QComboBox *cb, const Toolchain *tc)
@@ -386,7 +386,7 @@ Tasks ToolchainKitAspectFactory::validate(const Kit *k) const
 
     const QList<Toolchain*> tcList = ToolchainKitAspect::toolChains(k);
     if (tcList.isEmpty()) {
-        result << BuildSystemTask(Task::Warning, ToolchainKitAspect::msgNoToolChainInTarget());
+        result << BuildSystemTask(Task::Warning, ToolchainKitAspect::msgNoToolchainInTarget());
     } else {
         QSet<Abi> targetAbis;
         for (const Toolchain *tc : tcList) {
@@ -407,12 +407,12 @@ void ToolchainKitAspectFactory::fix(Kit *k)
     QTC_ASSERT(ToolchainManager::isLoaded(), return);
     const QList<Id> languages = ToolchainManager::allLanguages();
     for (const Id l : languages) {
-        const QByteArray tcId = ToolchainKitAspect::toolChainId(k, l);
+        const QByteArray tcId = ToolchainKitAspect::toolchainId(k, l);
         if (!tcId.isEmpty() && !ToolchainManager::findToolchain(tcId)) {
             qWarning("Tool chain set up in kit \"%s\" for \"%s\" not found.",
                      qPrintable(k->displayName()),
                      qPrintable(ToolchainManager::displayNameOfLanguageId(l)));
-            ToolchainKitAspect::clearToolChain(k, l); // make sure to clear out no longer known tool chains
+            ToolchainKitAspect::clearToolchain(k, l); // make sure to clear out no longer known tool chains
         }
     }
 }
@@ -459,9 +459,9 @@ void ToolchainKitAspectFactory::setup(Kit *k)
                 bestTc = tc;
         }
         if (bestTc)
-            ToolchainKitAspect::setToolChain(k, bestTc);
+            ToolchainKitAspect::setToolchain(k, bestTc);
         else
-            ToolchainKitAspect::clearToolChain(k, l);
+            ToolchainKitAspect::clearToolchain(k, l);
     }
 
     k->setSticky(id(), lockToolchains);
@@ -475,19 +475,19 @@ KitAspect *ToolchainKitAspectFactory::createKitAspect(Kit *k) const
 
 QString ToolchainKitAspectFactory::displayNamePostfix(const Kit *k) const
 {
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
     return tc ? tc->displayName() : QString();
 }
 
 KitAspectFactory::ItemList ToolchainKitAspectFactory::toUserOutput(const Kit *k) const
 {
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
     return {{Tr::tr("Compiler"), tc ? tc->displayName() : Tr::tr("None")}};
 }
 
 void ToolchainKitAspectFactory::addToBuildEnvironment(const Kit *k, Environment &env) const
 {
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
     if (tc)
         tc->addToEnvironment(env);
 }
@@ -499,25 +499,25 @@ void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expa
     // Compatibility with Qt Creator < 4.2:
     expander->registerVariable("Compiler:Name", Tr::tr("Compiler"),
                                [kit] {
-                                   const Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
+                                   const Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit);
                                    return tc ? tc->displayName() : Tr::tr("None");
                                });
 
     expander->registerVariable("Compiler:Executable", Tr::tr("Path to the compiler executable"),
                                [kit] {
-                                   const Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
+                                   const Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit);
                                    return tc ? tc->compilerCommand().path() : QString();
                                });
 
     // After 4.2
     expander->registerPrefix("Compiler:Name", Tr::tr("Compiler for different languages"),
                              [kit](const QString &ls) {
-                                 const Toolchain *tc = ToolchainKitAspect::toolChain(kit, findLanguage(ls));
+                                 const Toolchain *tc = ToolchainKitAspect::toolchain(kit, findLanguage(ls));
                                  return tc ? tc->displayName() : Tr::tr("None");
                              });
     expander->registerPrefix("Compiler:Executable", Tr::tr("Compiler executable for different languages"),
                              [kit](const QString &ls) {
-                                 const Toolchain *tc = ToolchainKitAspect::toolChain(kit, findLanguage(ls));
+                                 const Toolchain *tc = ToolchainKitAspect::toolchain(kit, findLanguage(ls));
                                  return tc ? tc->compilerCommand().path() : QString();
                              });
 }
@@ -525,7 +525,7 @@ void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expa
 QList<OutputLineParser *> ToolchainKitAspectFactory::createOutputParsers(const Kit *k) const
 {
     for (const Id langId : {Constants::CXX_LANGUAGE_ID, Constants::C_LANGUAGE_ID}) {
-        if (const Toolchain * const tc = ToolchainKitAspect::toolChain(k, langId))
+        if (const Toolchain * const tc = ToolchainKitAspect::toolchain(k, langId))
             return tc->createOutputParsers();
     }
     return {};
@@ -546,7 +546,7 @@ Id ToolchainKitAspect::id()
     return "PE.Profile.ToolChainsV3";
 }
 
-QByteArray ToolchainKitAspect::toolChainId(const Kit *k, Id language)
+QByteArray ToolchainKitAspect::toolchainId(const Kit *k, Id language)
 {
     QTC_ASSERT(ToolchainManager::isLoaded(), return nullptr);
     if (!k)
@@ -555,19 +555,19 @@ QByteArray ToolchainKitAspect::toolChainId(const Kit *k, Id language)
     return value.value(language.toKey(), QByteArray()).toByteArray();
 }
 
-Toolchain *ToolchainKitAspect::toolChain(const Kit *k, Id language)
+Toolchain *ToolchainKitAspect::toolchain(const Kit *k, Id language)
 {
-    return ToolchainManager::findToolchain(toolChainId(k, language));
+    return ToolchainManager::findToolchain(toolchainId(k, language));
 }
 
-Toolchain *ToolchainKitAspect::cToolChain(const Kit *k)
+Toolchain *ToolchainKitAspect::cToolchain(const Kit *k)
 {
-    return ToolchainManager::findToolchain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
+    return ToolchainManager::findToolchain(toolchainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
 }
 
-Toolchain *ToolchainKitAspect::cxxToolChain(const Kit *k)
+Toolchain *ToolchainKitAspect::cxxToolchain(const Kit *k)
 {
-    return ToolchainManager::findToolchain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
+    return ToolchainManager::findToolchain(toolchainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
 }
 
 
@@ -583,7 +583,7 @@ QList<Toolchain *> ToolchainKitAspect::toolChains(const Kit *k)
     return filtered(tcList, [](Toolchain *tc) { return tc; });
 }
 
-void ToolchainKitAspect::setToolChain(Kit *k, Toolchain *tc)
+void ToolchainKitAspect::setToolchain(Kit *k, Toolchain *tc)
 {
     QTC_ASSERT(tc, return);
     QTC_ASSERT(k, return);
@@ -603,7 +603,7 @@ void ToolchainKitAspect::setToolChain(Kit *k, Toolchain *tc)
  * @param k The kit to set up
  * @param tc The toolchain to match other languages for.
  */
-void ToolchainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
+void ToolchainKitAspect::setAllToolchainsToMatch(Kit *k, Toolchain *tc)
 {
     QTC_ASSERT(tc, return);
     QTC_ASSERT(k, return);
@@ -642,7 +642,7 @@ void ToolchainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
     k->setValue(id(), variantFromStore(result));
 }
 
-void ToolchainKitAspect::clearToolChain(Kit *k, Id language)
+void ToolchainKitAspect::clearToolchain(Kit *k, Id language)
 {
     QTC_ASSERT(language.isValid(), return);
     QTC_ASSERT(k, return);
@@ -685,7 +685,7 @@ Abi ToolchainKitAspect::targetAbi(const Kit *k)
     return candidates.at(0); // Use basically a random Abi...
 }
 
-QString ToolchainKitAspect::msgNoToolChainInTarget()
+QString ToolchainKitAspect::msgNoToolchainInTarget()
 {
     return Tr::tr("No compiler set in kit.");
 }
@@ -704,7 +704,7 @@ void ToolchainKitAspectFactory::onKitsLoaded()
 void ToolchainKitAspectFactory::toolChainUpdated(Toolchain *tc)
 {
     for (Kit *k : KitManager::kits()) {
-        if (ToolchainKitAspect::toolChain(k, tc->language()) == tc)
+        if (ToolchainKitAspect::toolchain(k, tc->language()) == tc)
             notifyAboutUpdate(k);
     }
 }

src/plugins/projectexplorer/kitaspects.h

@@ -24,23 +24,23 @@ public:
     static void setSysRoot(Kit *k, const Utils::FilePath &v);
 };
 
-// ToolChainKitAspect
+// ToolchainKitAspect
 
 class PROJECTEXPLORER_EXPORT ToolchainKitAspect
 {
 public:
     static Utils::Id id();
-    static QByteArray toolChainId(const Kit *k, Utils::Id language);
+    static QByteArray toolchainId(const Kit *k, Utils::Id language);
-    static Toolchain *toolChain(const Kit *k, Utils::Id language);
+    static Toolchain *toolchain(const Kit *k, Utils::Id language);
-    static Toolchain *cToolChain(const Kit *k);
+    static Toolchain *cToolchain(const Kit *k);
-    static Toolchain *cxxToolChain(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 setToolchain(Kit *k, Toolchain *tc);
-    static void setAllToolChainsToMatch(Kit *k, Toolchain *tc);
+    static void setAllToolchainsToMatch(Kit *k, Toolchain *tc);
-    static void clearToolChain(Kit *k, Utils::Id language);
+    static void clearToolchain(Kit *k, Utils::Id language);
     static Abi targetAbi(const Kit *k);
 
-    static QString msgNoToolChainInTarget();
+    static QString msgNoToolchainInTarget();
 };
 
 // DeviceTypeKitAspect

src/plugins/projectexplorer/kitmanager.cpp

@@ -347,7 +347,7 @@ void KitManager::restoreKits()
             kit->setSdkProvided(false);
             kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here?
             for (Toolchain * const tc : it.value())
-                ToolchainKitAspect::setToolChain(kit.get(), tc);
+                ToolchainKitAspect::setToolchain(kit.get(), tc);
             if (contains(resultList, [&kit](const std::unique_ptr<Kit> &existingKit) {
                 return ToolchainKitAspect::toolChains(kit.get())
                          == ToolchainKitAspect::toolChains(existingKit.get());

src/plugins/projectexplorer/project.cpp

@@ -1551,12 +1551,12 @@ void ProjectExplorerPlugin::testSourceToBinaryMapping()
 {
     // Find suitable kit.
     Kit * const kit = findOr(KitManager::kits(), nullptr, [](const Kit *k) {
-        return k->isValid() && ToolchainKitAspect::cxxToolChain(k);
+        return k->isValid() && ToolchainKitAspect::cxxToolchain(k);
     });
     if (!kit)
         QSKIP("The test requires at least one kit with a toolchain.");
 
-    const auto toolchain = ToolchainKitAspect::cxxToolChain(kit);
+    const auto toolchain = ToolchainKitAspect::cxxToolchain(kit);
     QVERIFY(toolchain);
     if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) {
         while (!msvcToolchain->environmentInitialized()) {

src/plugins/projectexplorer/projectimporter.cpp

@@ -322,7 +322,7 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
         Toolchain *tc = toolChainFromVariant(v);
         QTC_ASSERT(tc, continue);
         ToolchainManager::deregisterToolchain(tc);
-        ToolchainKitAspect::setToolChain(k, nullptr);
+        ToolchainKitAspect::setToolchain(k, nullptr);
     }
 }
 
@@ -331,7 +331,7 @@ void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
     for (const QVariant &v : vl) {
         Toolchain *tmpTc = toolChainFromVariant(v);
         QTC_ASSERT(tmpTc, continue);
-        Toolchain *actualTc = ToolchainKitAspect::toolChain(k, tmpTc->language());
+        Toolchain *actualTc = ToolchainKitAspect::toolchain(k, tmpTc->language());
         if (tmpTc && actualTc != tmpTc)
             ToolchainManager::deregisterToolchain(tmpTc);
     }

src/plugins/projectexplorer/rawprojectpart.cpp

@@ -142,8 +142,8 @@ KitInfo::KitInfo(Kit *kit)
 {
     // Toolchains
     if (kit) {
-        cToolChain = ToolchainKitAspect::cToolChain(kit);
+        cToolchain = ToolchainKitAspect::cToolchain(kit);
-        cxxToolChain = ToolchainKitAspect::cxxToolChain(kit);
+        cxxToolchain = ToolchainKitAspect::cxxToolchain(kit);
     }
 
     // Sysroot
@@ -185,8 +185,8 @@ ProjectUpdateInfo::ProjectUpdateInfo(Project *project,
                                      const RppGenerator &rppGenerator)
     : rawProjectParts(rawProjectParts)
     , rppGenerator(rppGenerator)
-    , cToolChainInfo(ToolChainInfo(kitInfo.cToolChain, kitInfo.sysRootPath, env))
+    , cToolchainInfo(ToolChainInfo(kitInfo.cToolchain, kitInfo.sysRootPath, env))
-    , cxxToolChainInfo(ToolChainInfo(kitInfo.cxxToolChain, kitInfo.sysRootPath, env))
+    , cxxToolchainInfo(ToolChainInfo(kitInfo.cxxToolchain, kitInfo.sysRootPath, env))
 {
     if (project) {
         projectName = project->displayName();

src/plugins/projectexplorer/rawprojectpart.h

@@ -119,8 +119,8 @@ public:
     bool isValid() const;
 
     Kit *kit = nullptr;
-    Toolchain *cToolChain = nullptr;
+    Toolchain *cToolchain = nullptr;
-    Toolchain *cxxToolChain = nullptr;
+    Toolchain *cxxToolchain = nullptr;
 
     Utils::QtMajorVersion projectPartQtVersion = Utils::QtMajorVersion::None;
 
@@ -171,8 +171,8 @@ public:
     RawProjectParts rawProjectParts;
     RppGenerator rppGenerator;
 
-    ToolChainInfo cToolChainInfo;
+    ToolChainInfo cToolchainInfo;
-    ToolChainInfo cxxToolChainInfo;
+    ToolChainInfo cxxToolchainInfo;
 };
 
 } // namespace ProjectExplorer

src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp

@@ -238,8 +238,8 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
     if (!sysroot.isEmpty())
         data.insert(QLatin1String(QBS_SYSROOT), sysroot);
 
-    Toolchain *tcC = ToolchainKitAspect::cToolChain(k);
+    Toolchain *tcC = ToolchainKitAspect::cToolchain(k);
-    Toolchain *tcCxx = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *tcCxx = ToolchainKitAspect::cxxToolchain(k);
     if (!tcC && !tcCxx)
         return data;
 

src/plugins/qbsprojectmanager/qbsproject.cpp

@@ -1005,10 +1005,10 @@ void QbsBuildSystem::updateCppCodeModel()
 
     const QtSupport::CppKitInfo kitInfo(kit());
     QTC_ASSERT(kitInfo.isValid(), return);
-    const auto cToolchain = std::shared_ptr<Toolchain>(kitInfo.cToolChain
+    const auto cToolchain = std::shared_ptr<Toolchain>(kitInfo.cToolchain
-            ? kitInfo.cToolChain->clone() : nullptr);
+            ? kitInfo.cToolchain->clone() : nullptr);
-    const auto cxxToolchain = std::shared_ptr<Toolchain>(kitInfo.cxxToolChain
+    const auto cxxToolchain = std::shared_ptr<Toolchain>(kitInfo.cxxToolchain
-            ? kitInfo.cxxToolChain->clone() : nullptr);
+            ? kitInfo.cxxToolchain->clone() : nullptr);
 
     m_cppCodeModelUpdater->update({project(), kitInfo, activeParseEnvironment(), {},
             [projectData, kitInfo, cToolchain, cxxToolchain] {

src/plugins/qbsprojectmanager/qbsprojectimporter.cpp

@@ -145,8 +145,8 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
             && bgData->cxxCompilerPath.isEmpty()) {
         return true;
     }
-    const Toolchain * const cToolchain = ToolchainKitAspect::cToolChain(k);
+    const Toolchain * const cToolchain = ToolchainKitAspect::cToolchain(k);
-    const Toolchain * const cxxToolchain = ToolchainKitAspect::cxxToolChain(k);
+    const Toolchain * const cxxToolchain = ToolchainKitAspect::cxxToolchain(k);
     if (!bgData->cCompilerPath.isEmpty()) {
         if (!cToolchain)
             return false;
@@ -190,7 +190,7 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
             tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
         for (const ToolChainData &tc : std::as_const(tcData)) {
             if (!tc.tcs.isEmpty())
-                ToolchainKitAspect::setToolChain(k, tc.tcs.first());
+                ToolchainKitAspect::setToolchain(k, tc.tcs.first());
         }
         SysRootKitAspect::setSysRoot(k, bgData->sysroot);
     });

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp

@@ -781,7 +781,7 @@ QmakeBuildConfiguration::LastKitState::LastKitState(Kit *k)
       m_sysroot(SysRootKitAspect::sysRoot(k).toString()),
       m_mkspec(QmakeKitAspect::mkspec(k))
 {
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
     m_toolchain = tc ? tc->id() : QByteArray();
 }
 

src/plugins/qmakeprojectmanager/qmakekitaspect.cpp

@@ -98,7 +98,7 @@ QString QmakeKitAspect::defaultMkspec(const Kit *k)
     if (!version) // No version, so no qmake
         return {};
 
-    return version->mkspecFor(ToolchainKitAspect::cxxToolChain(k));
+    return version->mkspecFor(ToolchainKitAspect::cxxToolchain(k));
 }
 
 // QmakeKitAspectFactory

src/plugins/qmakeprojectmanager/qmakemakestep.cpp

@@ -179,7 +179,7 @@ bool QmakeMakeStep::init()
 void QmakeMakeStep::setupOutputFormatter(OutputFormatter *formatter)
 {
     formatter->addLineParser(new GnuMakeParser());
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit());
     OutputTaskParser *xcodeBuildParser = nullptr;
     if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
         xcodeBuildParser = new XcodebuildParser;

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -238,7 +238,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
 
     connect(ToolchainManager::instance(), &ToolchainManager::toolchainUpdated,
             this, [this](Toolchain *tc) {
-        if (ToolchainKitAspect::cxxToolChain(kit()) == tc)
+        if (ToolchainKitAspect::cxxToolchain(kit()) == tc)
             scheduleUpdateAllNowOrLater();
     });
 
@@ -362,8 +362,8 @@ void QmakeBuildSystem::updateCppCodeModel()
             return pro->variableValue(Variable::IosDeploymentTarget).join(QString());
         });
 
-        rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxArgs, includeFileBaseDir});
+        rpp.setFlagsForCxx({kitInfo.cxxToolchain, cxxArgs, includeFileBaseDir});
-        rpp.setFlagsForC({kitInfo.cToolChain, cArgs, includeFileBaseDir});
+        rpp.setFlagsForC({kitInfo.cToolchain, cArgs, includeFileBaseDir});
         rpp.setMacros(ProjectExplorer::Macro::toMacros(pro->cxxDefines()));
         rpp.setPreCompiledHeaders(pro->variableValue(Variable::PrecompiledHeader));
         rpp.setSelectedForBuilding(pro->includedInExactParse());
@@ -757,7 +757,7 @@ Tasks QmakeProject::projectIssues(const Kit *k) const
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Qt version set in kit.")));
     else if (!qtFromKit->isValid())
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("Qt version is invalid.")));
-    if (!ToolchainKitAspect::cxxToolChain(k))
+    if (!ToolchainKitAspect::cxxToolchain(k))
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No C++ compiler set in kit.")));
 
     // A project can be considered part of more than one Qt version, for instance if it is an
@@ -1308,7 +1308,7 @@ static FilePath destDirFor(const TargetInformation &ti)
 
 FilePaths QmakeBuildSystem::allLibraryTargetFiles(const QmakeProFile *file) const
 {
-    const Toolchain *const toolchain = ToolchainKitAspect::cxxToolChain(kit());
+    const Toolchain *const toolchain = ToolchainKitAspect::cxxToolchain(kit());
     if (!toolchain)
         return {};
 
@@ -1467,14 +1467,14 @@ QString QmakeBuildSystem::deviceRoot() const
 void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
 {
     const BuildConfiguration *bc = buildConfiguration();
-    testToolChain(ToolchainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
+    testToolChain(ToolchainKitAspect::cToolchain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
-    testToolChain(ToolchainKitAspect::cxxToolChain(kit()),
+    testToolChain(ToolchainKitAspect::cxxToolchain(kit()),
                   getFullPathOf(pro, Variable::QmakeCxx, bc));
 }
 
 FilePath QmakeBuildSystem::executableFor(const QmakeProFile *file)
 {
-    const Toolchain *const tc = ToolchainKitAspect::cxxToolChain(kit());
+    const Toolchain *const tc = ToolchainKitAspect::cxxToolchain(kit());
     if (!tc)
         return {};
 

src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp

@@ -160,7 +160,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
 
     QtVersion *kitVersion = QtKitAspect::qtVersion(k);
     QString kitSpec = QmakeKitAspect::mkspec(k);
-    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
     if (kitSpec.isEmpty() && kitVersion)
         kitSpec = kitVersion->mkspecFor(tc);
     QMakeStepConfig::OsType kitOsType = QMakeStepConfig::NoOsType;
@@ -241,7 +241,7 @@ Kit *QmakeProjectImporter::createTemporaryKit(const QtProjectImporter::QtVersion
     Q_UNUSED(osType) // TODO use this to select the right toolchain?
     return QtProjectImporter::createTemporaryKit(data, [&data, parsedSpec](Kit *k) -> void {
         for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec))
-            ToolchainKitAspect::setToolChain(k, tc);
+            ToolchainKitAspect::setToolchain(k, tc);
         if (parsedSpec != data.qt->mkspec())
             QmakeKitAspect::setMkspec(k, parsedSpec, QmakeKitAspect::MkspecSource::Code);
     });

src/plugins/qmakeprojectmanager/qmakestep.cpp

@@ -149,7 +149,7 @@ QMakeStepConfig QMakeStep::deducedArguments() const
     Kit *kit = target()->kit();
     QMakeStepConfig config;
     Abi targetAbi;
-    if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit)) {
+    if (Toolchain *tc = ToolchainKitAspect::cxxToolchain(kit)) {
         targetAbi = tc->targetAbi();
         if (HostOsInfo::isWindowsHost()
             && tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) {

src/plugins/qnx/qnxsettingspage.cpp

@@ -182,7 +182,7 @@ void QnxConfiguration::deactivate()
     for (Kit *kit : kits) {
         if (kit->isAutoDetected()
                 && DeviceTypeKitAspect::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE
-                && toolChainsToRemove.contains(ToolchainKitAspect::cxxToolChain(kit))) {
+                && toolChainsToRemove.contains(ToolchainKitAspect::cxxToolchain(kit))) {
             KitManager::deregisterKit(kit);
         }
     }
@@ -240,7 +240,7 @@ Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
                     .arg(target.shortDescription()));
         toolChain->sdpPath.setValue(m_envFile.parentDir());
         toolChain->cpuDir.setValue(target.cpuDir());
-        toolChain->resetToolChain(m_qccCompiler);
+        toolChain->resetToolchain(m_qccCompiler);
         ToolchainManager::registerToolchain(toolChain);
 
         toolChains.append(toolChain);
@@ -258,8 +258,8 @@ void QnxConfiguration::createKit(const QnxTarget &target)
 
     const auto init = [&](Kit *k) {
         QtKitAspect::setQtVersion(k, qnxQt);
-        ToolchainKitAspect::setToolChain(k, toolChains[0]);
+        ToolchainKitAspect::setToolchain(k, toolChains[0]);
-        ToolchainKitAspect::setToolChain(k, toolChains[1]);
+        ToolchainKitAspect::setToolchain(k, toolChains[1]);
 
         if (debugger.isValid())
             DebuggerKitAspect::setDebugger(k, debugger);

src/plugins/qnx/qnxtoolchain.cpp

@@ -208,7 +208,7 @@ void QnxToolChainConfigWidget::applyImpl()
     tc->setDisplayName(displayName); // reset display name
     tc->sdpPath.setValue(m_sdpPath->filePath());
     tc->setTargetAbi(m_abiWidget->currentAbi());
-    tc->resetToolChain(m_compilerCommand->filePath());
+    tc->resetToolchain(m_compilerCommand->filePath());
 }
 
 void QnxToolChainConfigWidget::discardImpl()

src/plugins/qtsupport/baseqtversion.cpp

@@ -542,7 +542,7 @@ Tasks QtVersion::validateKit(const Kit *k)
             result << BuildSystemTask(Task::Warning, Tr::tr("Device type is not supported by Qt version."));
     }
 
-    if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
+    if (Toolchain *tc = ToolchainKitAspect::cxxToolchain(k)) {
         Abi targetAbi = tc->targetAbi();
         Abis supportedAbis = tc->supportedAbis();
         bool fuzzyMatch = false;
@@ -576,7 +576,7 @@ Tasks QtVersion::validateKit(const Kit *k)
                                   version->displayName(), qtAbiString);
             result << BuildSystemTask(fuzzyMatch ? Task::Warning : Task::Error, message);
         }
-    } else if (ToolchainKitAspect::cToolChain(k)) {
+    } else if (ToolchainKitAspect::cToolchain(k)) {
         const QString message = Tr::tr("The kit has a Qt version, but no C++ compiler.");
         result << BuildSystemTask(Task::Warning, message);
     }

src/plugins/qtsupport/qtkitaspect.cpp

@@ -226,7 +226,7 @@ void QtKitAspectFactory::fix(Kit *k)
     }
 
     // Set a matching toolchain if we don't have one.
-    if (ToolchainKitAspect::cxxToolChain(k))
+    if (ToolchainKitAspect::cxxToolchain(k))
         return;
 
     const QString spec = version->mkspec();
@@ -283,7 +283,7 @@ void QtKitAspectFactory::fix(Kit *k)
         });
 
         if (Toolchain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
-            ToolchainKitAspect::setAllToolChainsToMatch(k, bestTc);
+            ToolchainKitAspect::setAllToolchainsToMatch(k, bestTc);
     }
 }
 
@@ -405,7 +405,7 @@ void QtKitAspect::setQtVersion(Kit *k, const QtVersion *v)
 
 void QtKitAspect::addHostBinariesToPath(const Kit *k, Environment &env)
 {
-    if (const Toolchain *tc = ToolchainKitAspect::cxxToolChain(k))
+    if (const Toolchain *tc = ToolchainKitAspect::cxxToolchain(k))
         env.prependOrSetPath(tc->compilerCommand().parentDir());
 
     if (const QtVersion *qt = qtVersion(k))