ProjectExplorer: Rename ToolChain to Toolchain

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

src/plugins/android/androidconfigurations.cpp

@@ -1130,7 +1130,7 @@ void AndroidConfigurations::setConfig(const AndroidConfig &devConfigs)
     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;
@@ -1147,12 +1147,12 @@ static bool matchToolChain(const ToolChain *atc, const ToolChain *btc)
 void AndroidConfigurations::registerNewToolChains()
 {
     const Toolchains existingAndroidToolChains
-            = ToolChainManager::toolchains(Utils::equal(&ToolChain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
+            = ToolChainManager::toolchains(Utils::equal(&Toolchain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
 
     const Toolchains newToolchains = AndroidToolchainFactory::autodetectToolChains(
         existingAndroidToolChains);
 
-    for (ToolChain *tc : newToolchains)
+    for (Toolchain *tc : newToolchains)
         ToolChainManager::registerToolChain(tc);
 
     registerCustomToolChainsAndDebuggers();
@@ -1160,9 +1160,9 @@ void AndroidConfigurations::registerNewToolChains()
 
 void AndroidConfigurations::removeOldToolChains()
 {
-    const auto tcs = ToolChainManager::toolchains(Utils::equal(&ToolChain::typeId,
+    const auto tcs = ToolChainManager::toolchains(Utils::equal(&Toolchain::typeId,
                                                                Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
-    for (ToolChain *tc : tcs) {
+    for (Toolchain *tc : tcs) {
         if (!tc->isValid())
             ToolChainManager::deregisterToolChain(tc);
     }
@@ -1241,7 +1241,7 @@ static const Debugger::DebuggerItem *existingDebugger(const FilePath &command,
     return nullptr;
 }
 
-static QVariant findOrRegisterDebugger(ToolChain *tc,
+static QVariant findOrRegisterDebugger(Toolchain *tc,
                                        const QStringList &abisList,
                                        bool customDebugger = false)
 {
@@ -1307,14 +1307,14 @@ static QVariant findOrRegisterDebugger(ToolChain *tc,
 void AndroidConfigurations::registerCustomToolChainsAndDebuggers()
 {
     const Toolchains existingAndroidToolChains = ToolChainManager::toolchains(
-        Utils::equal(&ToolChain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
+        Utils::equal(&Toolchain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
 
     const FilePaths customNdks = FileUtils::toFilePathList(currentConfig().getCustomNdkList());
     const Toolchains customToolchains
         = AndroidToolchainFactory::autodetectToolChainsFromNdks(existingAndroidToolChains,
                                                                 customNdks,
                                                                 true);
-    for (ToolChain *tc : customToolchains) {
+    for (Toolchain *tc : customToolchains) {
         ToolChainManager::registerToolChain(tc);
         const auto androidToolChain = static_cast<AndroidToolChain *>(tc);
         QString abiStr;
@@ -1359,12 +1359,12 @@ void AndroidConfigurations::updateAutomaticKitList()
     }
 
     // register new kits
-    const Toolchains toolchains = ToolChainManager::toolchains([](const ToolChain *tc) {
+    const Toolchains toolchains = ToolChainManager::toolchains([](const Toolchain *tc) {
         return tc->isAutoDetected() && tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
                && tc->isValid();
     });
     QList<Kit *> unhandledKits = existingKits;
-    for (ToolChain *tc : toolchains) {
+    for (Toolchain *tc : toolchains) {
         if (tc->language() != ProjectExplorer::Constants::CXX_LANGUAGE_ID)
             continue;
 
@@ -1374,13 +1374,13 @@ void AndroidConfigurations::updateAutomaticKitList()
                 continue;
 
             const Toolchains allLanguages
-                = Utils::filtered(toolchains, [tc, tcNdk](ToolChain *otherTc) {
+                = Utils::filtered(toolchains, [tc, tcNdk](Toolchain *otherTc) {
                       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)
+            for (Toolchain *tc : allLanguages)
                 toolChainForLanguage[tc->language()] = tc;
 
             Kit *existingKit = Utils::findOrDefault(existingKits, [&](const Kit *b) {
@@ -1396,7 +1396,7 @@ void AndroidConfigurations::updateAutomaticKitList()
                 k->setAutoDetected(true);
                 k->setAutoDetectionSource("AndroidConfiguration");
                 DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE);
-                for (ToolChain *tc : allLanguages)
+                for (Toolchain *tc : allLanguages)
                     ToolChainKitAspect::setToolChain(k, tc);
                 QtKitAspect::setQtVersion(k, qt);
                 QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis();

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/androidtoolchain.cpp

@@ -34,10 +34,10 @@ 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)
 {
-    ToolChain *tc = Utils::findOrDefault(alreadyKnown, [target, compilerPath, lang](ToolChain *tc) {
+    Toolchain *tc = Utils::findOrDefault(alreadyKnown, [target, compilerPath, lang](Toolchain *tc) {
         return tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
                 && tc->language() == lang
                 && tc->targetAbi() == ClangTargets->value(target)
@@ -180,7 +180,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
     const QList<FilePath> &ndkLocations,
     const bool isCustom)
 {
-    QList<ToolChain *> result;
+    QList<Toolchain *> result;
     const AndroidConfig config = AndroidConfigurations::currentConfig();
 
     const Id LanguageIds[] {
@@ -211,7 +211,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)")
@@ -241,7 +241,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
                 if (auto gccTc = dynamic_cast<GccToolChain*>(tc))
                     gccTc->resetToolChain(compilerCommand);
 
-                tc->setDetection(ToolChain::AutoDetection);
+                tc->setDetection(Toolchain::AutoDetection);
                 result << tc;
                 ++targetItr;
             }

src/plugins/android/androidtoolchain.h

@@ -9,7 +9,7 @@
 
 namespace Android::Internal {
 
-using ToolChainList = QList<ProjectExplorer::ToolChain *>;
+using ToolChainList = QList<ProjectExplorer::Toolchain *>;
 
 class AndroidToolChain : public ProjectExplorer::GccToolChain
 {

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/baremetal/iarewtoolchain.cpp

@@ -280,10 +280,10 @@ private:
 
 // IarToolChain
 
-class IarToolChain final : public ToolChain
+class IarToolChain final : public Toolchain
 {
 public:
-    IarToolChain() : ToolChain(Constants::IAREW_TOOLCHAIN_TYPEID)
+    IarToolChain() : Toolchain(Constants::IAREW_TOOLCHAIN_TYPEID)
     {
         setTypeDisplayName(Tr::tr("IAREW"));
         setTargetAbiKey("TargetAbi");
@@ -305,7 +305,7 @@ public:
 
     std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() final;
 
-    bool operator==(const ToolChain &other) const final;
+    bool operator==(const Toolchain &other) const final;
 
     QStringList extraCodeModelFlags() const final { return m_extraCodeModelFlags(); }
 
@@ -318,7 +318,7 @@ private:
     friend class IarToolChainConfigWidget;
 };
 
-ToolChain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -340,7 +340,7 @@ ToolChain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() con
         macros.append({"__spec_string", "", MacroType::Define});
         macros.append({"__constrange(__a,__b)", "", MacroType::Define});
 
-        const auto languageVersion = ToolChain::languageVersion(languageId, macros);
+        const auto languageVersion = Toolchain::languageVersion(languageId, macros);
         const auto report = MacroInspectionReport{macros, languageVersion};
         macrosCache->insert({}, report);
 
@@ -359,7 +359,7 @@ WarningFlags IarToolChain::warningFlags(const QStringList &cxxflags) const
     return WarningFlags::Default;
 }
 
-ToolChain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     Environment env = Environment::systemEnvironment();
@@ -394,9 +394,9 @@ std::unique_ptr<ToolchainConfigWidget> IarToolChain::createConfigurationWidget()
     return std::make_unique<IarToolChainConfigWidget>(this);
 }
 
-bool IarToolChain::operator==(const ToolChain &other) const
+bool IarToolChain::operator==(const Toolchain &other) const
 {
-    if (!ToolChain::operator==(other))
+    if (!Toolchain::operator==(other))
         return false;
 
     const auto customTc = static_cast<const IarToolChain *>(&other);
@@ -518,7 +518,7 @@ Toolchains IarToolchainFactory::autoDetectToolchains(
     Toolchains result;
 
     for (const Candidate &candidate : std::as_const(candidates)) {
-        const Toolchains filtered = Utils::filtered(alreadyKnown, [candidate](ToolChain *tc) {
+        const Toolchains filtered = Utils::filtered(alreadyKnown, [candidate](Toolchain *tc) {
             return tc->typeId() == Constants::IAREW_TOOLCHAIN_TYPEID
                 && tc->compilerCommand() == candidate.compilerPath
                 && (tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID
@@ -551,14 +551,14 @@ Toolchains IarToolchainFactory::autoDetectToolchain(const Candidate &candidate,
     const Abi abi = guessAbi(macros);
 
     const auto tc = new IarToolChain;
-    tc->setDetection(ToolChain::AutoDetection);
+    tc->setDetection(Toolchain::AutoDetection);
     tc->setLanguage(languageId);
     tc->setCompilerCommand(candidate.compilerPath);
     tc->setTargetAbi(abi);
     tc->setDisplayName(buildDisplayName(abi.architecture(), languageId,
                                         candidate.compilerVersion));
 
-    const auto languageVersion = ToolChain::languageVersion(languageId, macros);
+    const auto languageVersion = Toolchain::languageVersion(languageId, macros);
     tc->predefinedMacrosCache()->insert({}, {macros, languageVersion});
     return {tc};
 }
@@ -608,7 +608,7 @@ void IarToolChainConfigWidget::applyImpl()
     if (m_macros.isEmpty())
         return;
 
-    const auto languageVersion = ToolChain::languageVersion(tc->language(), m_macros);
+    const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
     tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
 
     setFromToolchain();

src/plugins/baremetal/keiltoolchain.cpp

@@ -418,11 +418,11 @@ private:
 
 // KeilToolChain
 
-class KeilToolChain final : public ToolChain
+class KeilToolChain final : public Toolchain
 {
 public:
     KeilToolChain() :
-        ToolChain(Constants::KEIL_TOOLCHAIN_TYPEID)
+        Toolchain(Constants::KEIL_TOOLCHAIN_TYPEID)
     {
         setTypeDisplayName(Tr::tr("KEIL"));
         setTargetAbiKey("TargetAbi");
@@ -445,7 +445,7 @@ public:
 
     std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() final;
 
-    bool operator==(const ToolChain &other) const final;
+    bool operator==(const Toolchain &other) const final;
 
     QStringList extraCodeModelFlags() const final;
 
@@ -458,7 +458,7 @@ private:
     friend class KeilToolChainConfigWidget;
 };
 
-ToolChain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -491,7 +491,7 @@ WarningFlags KeilToolChain::warningFlags(const QStringList &cxxflags) const
     return WarningFlags::Default;
 }
 
-ToolChain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     const FilePath compiler = compilerCommand();
@@ -520,9 +520,9 @@ std::unique_ptr<ToolchainConfigWidget> KeilToolChain::createConfigurationWidget(
     return std::make_unique<KeilToolChainConfigWidget>(this);
 }
 
-bool KeilToolChain::operator ==(const ToolChain &other) const
+bool KeilToolChain::operator ==(const Toolchain &other) const
 {
-    if (!ToolChain::operator ==(other))
+    if (!Toolchain::operator ==(other))
         return false;
 
     const auto customTc = static_cast<const KeilToolChain *>(&other);
@@ -667,7 +667,7 @@ Toolchains KeilToolchainFactory::autoDetectToolchains(
 
     for (const Candidate &candidate : std::as_const(candidates)) {
         const Toolchains filtered = Utils::filtered(
-                    alreadyKnown, [candidate](ToolChain *tc) {
+                    alreadyKnown, [candidate](Toolchain *tc) {
             return tc->typeId() == Constants::IAREW_TOOLCHAIN_TYPEID
                 && tc->compilerCommand() == candidate.compilerPath
                 && (tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID
@@ -710,14 +710,14 @@ Toolchains KeilToolchainFactory::autoDetectToolchain(const Candidate &candidate,
     }
 
     const auto tc = new KeilToolChain;
-    tc->setDetection(ToolChain::AutoDetection);
+    tc->setDetection(Toolchain::AutoDetection);
     tc->setLanguage(language);
     tc->setCompilerCommand(candidate.compilerPath);
     tc->m_extraCodeModelFlags.setValue(extraArgs);
     tc->setTargetAbi(abi);
     tc->setDisplayName(buildDisplayName(abi.architecture(), language, candidate.compilerVersion));
 
-    const auto languageVersion = ToolChain::languageVersion(language, macros);
+    const auto languageVersion = Toolchain::languageVersion(language, macros);
     tc->predefinedMacrosCache()->insert({}, {macros, languageVersion});
     return {tc};
 }
@@ -765,7 +765,7 @@ void KeilToolChainConfigWidget::applyImpl()
     if (m_macros.isEmpty())
         return;
 
-    const auto languageVersion = ToolChain::languageVersion(tc->language(), m_macros);
+    const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
     tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
 
     setFromToolChain();

src/plugins/baremetal/sdcctoolchain.cpp

@@ -199,10 +199,10 @@ private:
 
 // SdccToolChain
 
-class SdccToolChain final : public ToolChain
+class SdccToolChain final : public Toolchain
 {
 public:
-    SdccToolChain() : ToolChain(Constants::SDCC_TOOLCHAIN_TYPEID)
+    SdccToolChain() : Toolchain(Constants::SDCC_TOOLCHAIN_TYPEID)
     {
         setTypeDisplayName(Tr::tr("SDCC"));
         setTargetAbiKey("TargetAbi");
@@ -220,7 +220,7 @@ public:
 
     std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() final;
 
-    bool operator==(const ToolChain &other) const final;
+    bool operator==(const Toolchain &other) const final;
 
     FilePath makeCommand(const Environment &) const final { return {}; }
 
@@ -229,7 +229,7 @@ private:
     friend class SdccToolChainConfigWidget;
 };
 
-ToolChain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -263,7 +263,7 @@ WarningFlags SdccToolChain::warningFlags(const QStringList &cxxflags) const
     return WarningFlags::Default;
 }
 
-ToolChain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     Environment env = Environment::systemEnvironment();
@@ -288,9 +288,9 @@ std::unique_ptr<ToolchainConfigWidget> SdccToolChain::createConfigurationWidget(
     return std::make_unique<SdccToolChainConfigWidget>(this);
 }
 
-bool SdccToolChain::operator==(const ToolChain &other) const
+bool SdccToolChain::operator==(const Toolchain &other) const
 {
-    if (!ToolChain::operator==(other))
+    if (!Toolchain::operator==(other))
         return false;
 
     const auto customTc = static_cast<const SdccToolChain *>(&other);
@@ -388,7 +388,7 @@ Toolchains SdccToolchainFactory::autoDetectToolchains(
     Toolchains result;
 
     for (const Candidate &candidate : std::as_const(candidates)) {
-        const Toolchains filtered = Utils::filtered(alreadyKnown, [candidate](ToolChain *tc) {
+        const Toolchains filtered = Utils::filtered(alreadyKnown, [candidate](Toolchain *tc) {
             return tc->typeId() == Constants::SDCC_TOOLCHAIN_TYPEID
                 && tc->compilerCommand() == candidate.compilerPath
                 && (tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID);
@@ -429,14 +429,14 @@ Toolchains SdccToolchainFactory::autoDetectToolchain(const Candidate &candidate,
             continue;
 
         const auto tc = new SdccToolChain;
-        tc->setDetection(ToolChain::AutoDetection);
+        tc->setDetection(Toolchain::AutoDetection);
         tc->setLanguage(language);
         tc->setCompilerCommand(candidate.compilerPath);
         tc->setTargetAbi(abi);
         tc->setDisplayName(buildDisplayName(abi.architecture(), language,
                                             candidate.compilerVersion));
 
-        const auto languageVersion = ToolChain::languageVersion(language, macros);
+        const auto languageVersion = Toolchain::languageVersion(language, macros);
         tc->predefinedMacrosCache()->insert({}, {macros, languageVersion});
 
         tcs.push_back(tc);
@@ -482,7 +482,7 @@ void SdccToolChainConfigWidget::applyImpl()
     if (m_macros.isEmpty())
         return;
 
-    const auto languageVersion = ToolChain::languageVersion(tc->language(), m_macros);
+    const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
     tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
 
     setFromToolchain();

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.");
 

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

@@ -335,7 +335,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/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

@@ -585,7 +585,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
                                   data->qt.qt->qmakeFilePath().toString().toUtf8());
 }
 
-ToolChain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset)
+Toolchain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset)
 {
     // A compiler path example. Note that the compiler version is not the same version from MsvcToolChain
     // ... \MSVC\14.29.30133\bin\Hostx64\x64\cl.exe
@@ -601,16 +601,16 @@ ToolChain *findExternalToolchain(const QString &presetArchitecture, const QStrin
     //      "strategy": "external"
     //  }
 
-    auto msvcToolchains = ToolChainManager::toolchains([](const ToolChain *tc) {
+    auto msvcToolchains = ToolChainManager::toolchains([](const Toolchain *tc) {
         return  tc->typeId() ==  ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
     });
 
-    const QSet<Abi::OSFlavor> msvcFlavors = Utils::toSet(Utils::transform(msvcToolchains, [](const ToolChain *tc) {
+    const QSet<Abi::OSFlavor> msvcFlavors = Utils::toSet(Utils::transform(msvcToolchains, [](const Toolchain *tc) {
         return tc->targetAbi().osFlavor();
     }));
 
     return ToolChainManager::toolChain(
-        [presetArchitecture, presetToolset, msvcFlavors](const ToolChain *tc) -> bool {
+        [presetArchitecture, presetToolset, msvcFlavors](const Toolchain *tc) -> bool {
             if (tc->typeId() != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
                 return false;
 
@@ -732,7 +732,7 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
             data->toolset = configurePreset.toolset.value().value.value();
 
         if (architectureExternalStrategy && toolsetExternalStrategy) {
-            const ToolChain *tc
+            const Toolchain *tc
                 = findExternalToolchain(configurePreset.architecture->value.value_or(QString()),
                                         configurePreset.toolset->value.value_or(QString()));
             if (tc)
@@ -937,7 +937,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
             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;
             }
@@ -950,7 +950,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
             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;
             }
@@ -1000,7 +1000,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
             QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
 
             if (tcd.areTemporary) {
-                for (ToolChain *tc : tcd.tcs)
+                for (Toolchain *tc : tcd.tcs)
                     addTemporaryData(ToolChainKitAspect::id(), tc->id(), k);
             }
 

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp

@@ -75,9 +75,9 @@ Utils::Id getCompilerId(QString compilerName)
     return ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
 }
 
-ToolChain *toolchainFromCompilerId(const Utils::Id &compilerId, const Utils::Id &language)
+Toolchain *toolchainFromCompilerId(const Utils::Id &compilerId, const Utils::Id &language)
 {
-    return ToolChainManager::toolChain([&compilerId, &language](const ToolChain *tc) {
+    return ToolChainManager::toolChain([&compilerId, &language](const Toolchain *tc) {
         if (!tc->isValid() || tc->language() != language)
             return false;
         return tc->typeId() == compilerId;
@@ -105,14 +105,14 @@ QString compilerPath(QString pathFlag)
     return QDir::fromNativeSeparators(pathFlag);
 }
 
-ToolChain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
+Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
 {
     if (flags.empty())
         return ToolChainKitAspect::toolChain(kit, language);
 
     // Try exact compiler match.
     const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front()));
-    ToolChain *toolchain = ToolChainManager::toolChain([&compiler, &language](const ToolChain *tc) {
+    Toolchain *toolchain = ToolChainManager::toolChain([&compiler, &language](const Toolchain *tc) {
         return tc->isValid() && tc->language() == language && tc->compilerCommand() == compiler;
     });
     if (toolchain)
@@ -136,7 +136,7 @@ ToolChain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Ut
     return toolchain;
 }
 
-void addDriverModeFlagIfNeeded(const ToolChain *toolchain,
+void addDriverModeFlagIfNeeded(const Toolchain *toolchain,
                                QStringList &flags,
                                const QStringList &originalFlags)
 {

src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp

@@ -39,7 +39,7 @@ void CompilationDatabaseTests::initTestCase()
     if (allKits.empty())
         QSKIP("This test requires at least one kit to be present.");
 
-    ToolChain *toolchain = ToolChainManager::toolChain([](const ToolChain *tc) {
+    Toolchain *toolchain = ToolChainManager::toolChain([](const Toolchain *tc) {
         return tc->isValid() && tc->language() == ProjectExplorer::Constants::CXX_LANGUAGE_ID;
     });
     if (!toolchain)

src/plugins/conan/conaninstallstep.cpp

@@ -104,7 +104,7 @@ ConanInstallStep::ConanInstallStep(BuildStepList *bsl, Id id)
     });
 
     setSummaryUpdater([this]() -> QString {
-        QList<ToolChain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
+        QList<Toolchain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
         if (tcList.isEmpty())
             return "<b>" + ToolChainKitAspect::msgNoToolChainInTarget() + "</b>";
         ProcessParameters param;
@@ -124,7 +124,7 @@ bool ConanInstallStep::init()
     if (!AbstractProcessStep::init())
         return false;
 
-    const QList<ToolChain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
+    const QList<Toolchain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
     if (tcList.isEmpty()) {
         emit addTask(Task::compilerMissingTask());
         emitFaultyConfigurationMessage();

src/plugins/cppeditor/compileroptionsbuilder_test.cpp

@@ -46,7 +46,7 @@ public:
         tcInfo.isMsvc2015ToolChain = isMsvc2015;
         tcInfo.extraCodeModelFlags = extraFlags;
         tcInfo.macroInspectionRunner = [this](const QStringList &) {
-            return ToolChain::MacroInspectionReport{toolchainMacros, languageVersion};
+            return Toolchain::MacroInspectionReport{toolchainMacros, languageVersion};
         };
         RawProjectPartFlags rppFlags;
         rppFlags.commandLineFlags = flags;

src/plugins/cppeditor/cppmodelmanager.cpp

@@ -409,7 +409,7 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
         return;
     }
 
-    const ToolChain * tc = nullptr;
+    const Toolchain * tc = nullptr;
     const ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString()));
     if (classifier.isC()) {
         tc = ToolChainKitAspect::cToolChain(project->activeTarget()->kit());
@@ -1964,7 +1964,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
+    const Toolchain * const defaultTc = defaultKit
             ? ToolChainKitAspect::cxxToolChain(defaultKit) : nullptr;
     if (defaultKit && defaultTc) {
         FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
@@ -1974,7 +1974,7 @@ void CppModelManager::setupFallbackProjectPart()
         tcInfo = ToolChainInfo(defaultTc, sysroot, env);
         const auto macroInspectionWrapper = [runner = tcInfo.macroInspectionRunner](
                 const QStringList &flags) {
-            ToolChain::MacroInspectionReport report = runner(flags);
+            Toolchain::MacroInspectionReport report = runner(flags);
             report.languageVersion = LanguageVersion::LatestCxx;
             return report;
         };

src/plugins/cppeditor/projectinfo_test.cpp

@@ -69,7 +69,7 @@ public:
 
         // Create project part for C
         tcInfo.macroInspectionRunner = [](const QStringList &) {
-            return ToolChain::MacroInspectionReport{{}, Utils::LanguageVersion::C11};
+            return Toolchain::MacroInspectionReport{{}, Utils::LanguageVersion::C11};
         };
         const ProjectPart::ConstPtr cprojectpart = ProjectPart::create({}, {}, {}, {}, {}, {}, {},
                                                                   tcInfo);
@@ -77,7 +77,7 @@ public:
 
         // Create project part for CXX
         tcInfo.macroInspectionRunner = [](const QStringList &) {
-            return ToolChain::MacroInspectionReport{{}, Utils::LanguageVersion::CXX98};
+            return Toolchain::MacroInspectionReport{{}, Utils::LanguageVersion::CXX98};
         };
         const ProjectPart::ConstPtr cxxprojectpart = ProjectPart::create({}, {}, {}, {}, {}, {}, {},
                                                                     tcInfo);
@@ -330,10 +330,10 @@ void ProjectPartChooserTest::testDoNotIndicateFromDependencies()
 }
 
 namespace {
-class TestToolchain : public ToolChain
+class TestToolchain : public Toolchain
 {
 public:
-    TestToolchain() : ToolChain("dummy") {}
+    TestToolchain() : Toolchain("dummy") {}
 
 private:
     MacroInspectionRunner createMacroInspectionRunner() const override { return {}; }

src/plugins/cppeditor/projectpart.cpp

@@ -96,10 +96,10 @@ static HeaderPaths getHeaderPaths(const RawProjectPart &rpp,
     return headerPaths;
 }
 
-static ToolChain::MacroInspectionReport getToolchainMacros(
+static Toolchain::MacroInspectionReport getToolchainMacros(
         const RawProjectPartFlags &flags, const ToolChainInfo &tcInfo, Utils::Language language)
 {
-    ToolChain::MacroInspectionReport report;
+    Toolchain::MacroInspectionReport report;
     if (tcInfo.macroInspectionRunner) {
         report = tcInfo.macroInspectionRunner(flags.commandLineFlags);
     } else if (language == Utils::Language::C) { // No compiler set in kit.

src/plugins/cppeditor/projectpart.h

@@ -110,7 +110,7 @@ private:
 
     CPlusPlus::LanguageFeatures deriveLanguageFeatures() const;
 
-    const ProjectExplorer::ToolChain::MacroInspectionReport m_macroReport;
+    const ProjectExplorer::Toolchain::MacroInspectionReport m_macroReport;
 
 public:
     // Must come last due to initialization order.

src/plugins/docker/kitdetector.cpp

@@ -46,7 +46,7 @@ public:
 
 private:
     QtVersions autoDetectQtVersions() const;
-    QList<ToolChain *> autoDetectToolChains();
+    QList<Toolchain *> autoDetectToolChains();
     void autoDetectPython();
     QList<Id> autoDetectCMake();
     void autoDetectDebugger();
@@ -107,7 +107,7 @@ void KitDetectorPrivate::undoAutoDetect() const
 
     emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Removing toolchain entries..."));
     const Toolchains toolchains = ToolChainManager::toolchains();
-    for (ToolChain *toolChain : toolchains) {
+    for (Toolchain *toolChain : toolchains) {
         if (toolChain && toolChain->detectionSource() == m_sharedId) {
             emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolChain->displayName()));
             ToolChainManager::deregisterToolChain(toolChain);
@@ -164,7 +164,7 @@ void KitDetectorPrivate::listAutoDetected() const
     }
 
     emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Toolchains:"));
-    for (ToolChain *toolChain : ToolChainManager::toolchains()) {
+    for (Toolchain *toolChain : ToolChainManager::toolchains()) {
         if (toolChain->detectionSource() == m_sharedId)
             emit q->logOutput(toolChain->displayName());
     }
@@ -259,7 +259,7 @@ Toolchains KitDetectorPrivate::autoDetectToolChains()
         emit q->logOutput(ProjectExplorer::Tr::tr("Searching toolchains of type %1").arg(factory->displayName()));
         const ToolchainDetector detector(alreadyKnown, m_device, m_searchPaths);
         const Toolchains newToolChains = factory->autoDetect(detector);
-        for (ToolChain *toolChain : newToolChains) {
+        for (Toolchain *toolChain : newToolChains) {
             emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput()));
             toolChain->setDetectionSource(m_sharedId);
             ToolChainManager::registerToolChain(toolChain);
@@ -359,11 +359,11 @@ void KitDetectorPrivate::autoDetect()
             QtSupport::QtKitAspect::setQtVersion(k, qt);
         }
         Toolchains toolchainsToSet;
-        toolchainsToSet = ToolChainManager::toolchains([qt, this](const ToolChain *tc) {
+        toolchainsToSet = ToolChainManager::toolchains([qt, this](const Toolchain *tc) {
             return tc->detectionSource() == m_sharedId
                    && (!qt || qt->qtAbis().contains(tc->targetAbi()));
         });
-        for (ToolChain *toolChain : toolchainsToSet)
+        for (Toolchain *toolChain : toolchainsToSet)
             ToolChainKitAspect::setToolChain(k, toolChain);
 
         if (cmakeId.isValid())

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

@@ -101,7 +101,7 @@ static bool isSimulatorDeviceId(const Id &id)
 static QList<GccToolChain *> clangToolChains(const Toolchains &toolChains)
 {
     QList<GccToolChain *> clangToolChains;
-    for (ToolChain *toolChain : toolChains)
+    for (Toolchain *toolChain : toolChains)
         if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
             clangToolChains.append(static_cast<GccToolChain *>(toolChain));
     return clangToolChains;
@@ -593,8 +593,8 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
                 if (!toolChain) {
                     toolChain = new GccToolChain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
                                                  GccToolChain::Clang);
-                    toolChain->setPriority(ToolChain::PriorityHigh);
+                    toolChain->setPriority(Toolchain::PriorityHigh);
-                    toolChain->setDetection(ToolChain::AutoDetection);
+                    toolChain->setDetection(Toolchain::AutoDetection);
                     toolChain->setLanguage(l);
                     toolChain->setDisplayName(target.name);
                     toolChain->setPlatformCodeGenFlags(target.backendFlags);

src/plugins/mcusupport/mcupackage.cpp

@@ -364,9 +364,9 @@ bool McuToolChainPackage::isDesktopToolchain() const
            || m_type == ToolChainType::MinGW;
 }
 
-ToolChain *McuToolChainPackage::msvcToolChain(Id language)
+Toolchain *McuToolChainPackage::msvcToolChain(Id language)
 {
-    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+    Toolchain *toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
         const Abi abi = t->targetAbi();
         return abi.osFlavor() == Abi::WindowsMsvc2019Flavor
                && abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
@@ -376,9 +376,9 @@ ToolChain *McuToolChainPackage::msvcToolChain(Id language)
     return toolChain;
 }
 
-ToolChain *McuToolChainPackage::gccToolChain(Id language)
+Toolchain *McuToolChainPackage::gccToolChain(Id language)
 {
-    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+    Toolchain *toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
         const Abi abi = t->targetAbi();
         return abi.os() != Abi::WindowsOS && abi.architecture() == Abi::X86Architecture
                && abi.wordWidth() == 64 && t->language() == language;
@@ -386,9 +386,9 @@ ToolChain *McuToolChainPackage::gccToolChain(Id language)
     return toolChain;
 }
 
-static ToolChain *mingwToolChain(const FilePath &path, Id language)
+static Toolchain *mingwToolChain(const FilePath &path, Id language)
 {
-    ToolChain *toolChain = ToolChainManager::toolChain([&path, language](const ToolChain *t) {
+    Toolchain *toolChain = ToolChainManager::toolChain([&path, language](const Toolchain *t) {
         // find a MinGW toolchain having the same path from registered toolchains
         const Abi abi = t->targetAbi();
         return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
@@ -398,7 +398,7 @@ static ToolChain *mingwToolChain(const FilePath &path, Id language)
     if (!toolChain) {
         // if there's no MinGW toolchain having the same path,
         // a proper MinGW would be selected from the registered toolchains.
-        toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+        toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
             const Abi abi = t->targetAbi();
             return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
                    && abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
@@ -408,9 +408,9 @@ static ToolChain *mingwToolChain(const FilePath &path, Id language)
     return toolChain;
 }
 
-static ToolChain *armGccToolChain(const FilePath &path, Id language)
+static Toolchain *armGccToolChain(const FilePath &path, Id language)
 {
-    ToolChain *toolChain = ToolChainManager::toolChain([&path, language](const ToolChain *t) {
+    Toolchain *toolChain = ToolChainManager::toolChain([&path, language](const Toolchain *t) {
         return t->compilerCommand() == path && t->language() == language;
     });
     if (!toolChain) {
@@ -421,10 +421,10 @@ static ToolChain *armGccToolChain(const FilePath &path, Id language)
                                               == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID;
                                    });
         if (gccFactory) {
-            const QList<ToolChain *> detected = gccFactory->detectForImport({path, language});
+            const QList<Toolchain *> detected = gccFactory->detectForImport({path, language});
             if (!detected.isEmpty()) {
                 toolChain = detected.first();
-                toolChain->setDetection(ToolChain::ManualDetection);
+                toolChain->setDetection(Toolchain::ManualDetection);
                 toolChain->setDisplayName("Arm GCC");
                 ToolChainManager::registerToolChain(toolChain);
             }
@@ -434,9 +434,9 @@ static ToolChain *armGccToolChain(const FilePath &path, Id language)
     return toolChain;
 }
 
-static ToolChain *iarToolChain(const FilePath &path, Id language)
+static Toolchain *iarToolChain(const FilePath &path, Id language)
 {
-    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+    Toolchain *toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
         return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
                && t->language() == language;
     });
@@ -455,7 +455,7 @@ static ToolChain *iarToolChain(const FilePath &path, Id language)
             for (auto tc : detected) {
                 if (tc->language() == language) {
                     toolChain = tc;
-                    toolChain->setDetection(ToolChain::ManualDetection);
+                    toolChain->setDetection(Toolchain::ManualDetection);
                     toolChain->setDisplayName("IAREW");
                     ToolChainManager::registerToolChain(toolChain);
                 }
@@ -466,7 +466,7 @@ static ToolChain *iarToolChain(const FilePath &path, Id language)
     return toolChain;
 }
 
-ToolChain *McuToolChainPackage::toolChain(Id language) const
+Toolchain *McuToolChainPackage::toolChain(Id language) const
 {
     switch (m_type) {
     case ToolChainType::MSVC:

src/plugins/mcusupport/mcupackage.h

@@ -13,7 +13,7 @@
 #include <QObject>
 
 namespace ProjectExplorer {
-class ToolChain;
+class Toolchain;
 }
 
 namespace Utils {
@@ -116,12 +116,12 @@ public:
 
     ToolChainType toolchainType() const;
     bool isDesktopToolchain() const;
-    ProjectExplorer::ToolChain *toolChain(Utils::Id language) const;
+    ProjectExplorer::Toolchain *toolChain(Utils::Id language) const;
     QString toolChainName() const;
     QVariant debuggerId() const;
 
-    static ProjectExplorer::ToolChain *msvcToolChain(Utils::Id language);
+    static ProjectExplorer::Toolchain *msvcToolChain(Utils::Id language);
-    static ProjectExplorer::ToolChain *gccToolChain(Utils::Id language);
+    static ProjectExplorer::Toolchain *gccToolChain(Utils::Id language);
 
 private:
     const ToolChainType m_type;

src/plugins/mcusupport/mcusupportoptions.h

@@ -21,7 +21,7 @@ class InfoLabel;
 
 namespace ProjectExplorer {
 class Kit;
-class ToolChain;
+class Toolchain;
 } // namespace ProjectExplorer
 
 namespace McuSupport {

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -184,7 +184,7 @@ McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::
 McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                   const QStringList &versions)
 {
-    ToolChain *toolChain = McuToolChainPackage::msvcToolChain(
+    Toolchain *toolChain = McuToolChainPackage::msvcToolChain(
         ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     const FilePath detectionPath = FilePath("cl").withExecutableSuffix();
@@ -209,7 +209,7 @@ McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &se
 McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                  const QStringList &versions)
 {
-    ToolChain *toolChain = McuToolChainPackage::gccToolChain(
+    Toolchain *toolChain = McuToolChainPackage::gccToolChain(
         ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     const FilePath detectionPath = FilePath("bin/g++").withExecutableSuffix();
@@ -328,8 +328,8 @@ McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &set
     if (qtcEnvironmentVariableIsSet(envVar))
         defaultPath = FilePath::fromUserInput(qtcEnvironmentVariable(envVar));
     else {
-        const ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainManager::toolChain(
+        const ProjectExplorer::Toolchain *tc = ProjectExplorer::ToolChainManager::toolChain(
-            [](const ProjectExplorer::ToolChain *t) {
+            [](const ProjectExplorer::Toolchain *t) {
                 return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
             });
         if (tc) {

src/plugins/mcusupport/mcutarget.h

@@ -9,7 +9,7 @@
 #include <QVersionNumber>
 
 namespace ProjectExplorer {
-class ToolChain;
+class Toolchain;
 }
 
 namespace Utils {

src/plugins/mcusupport/test/unittest.cpp

@@ -70,7 +70,7 @@ using Legacy::Constants::TOOLCHAIN_FILE_CMAKE_VARIABLE;
 using CMakeProjectManager::CMakeConfigurationKitAspect;
 using ProjectExplorer::Kit;
 using ProjectExplorer::KitManager;
-using ProjectExplorer::ToolChain;
+using ProjectExplorer::Toolchain;
 using ProjectExplorer::ToolChainManager;
 
 using testing::_;
@@ -214,7 +214,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
 {
     ProjectExplorer::ToolchainFactory toolchainFactory;
     Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
-    ToolChain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolChain(iarId)};
+    Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolChain(iarId)};
     iarToolchain->setLanguage(cxxLanguageId);
     ToolChainManager::registerToolChain(iarToolchain);
 
@@ -229,7 +229,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
     iarToolchain = iarToolchainPackage->toolChain(cxxLanguageId);
     QVERIFY(iarToolchain != nullptr);
     QCOMPARE(iarToolchain->displayName(), "IAREW");
-    QCOMPARE(iarToolchain->detection(), ToolChain::UninitializedDetection);
+    QCOMPARE(iarToolchain->detection(), Toolchain::UninitializedDetection);
 }
 
 void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QStringList &versions)
@@ -238,7 +238,7 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
     ProjectExplorer::ToolchainFactory toolchainFactory;
     Id armGccId{ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID};
 
-    ToolChain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
+    Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
     armToolchain->setLanguage(cxxLanguageId);
     ToolChainManager::registerToolChain(armToolchain);
 

src/plugins/mesonprojectmanager/mesonprojectparser.cpp

@@ -254,8 +254,8 @@ void MesonProjectParser::update(const QFuture<MesonProjectParser::ParserData *>
 RawProjectPart MesonProjectParser::buildRawPart(
     const Target &target,
     const Target::SourceGroup &sources,
-    const ToolChain *cxxToolChain,
+    const Toolchain *cxxToolChain,
-    const ToolChain *cToolChain)
+    const Toolchain *cToolChain)
 {
     RawProjectPart part;
     part.setDisplayName(target.name);
@@ -274,7 +274,7 @@ RawProjectPart MesonProjectParser::buildRawPart(
 }
 
 RawProjectParts MesonProjectParser::buildProjectParts(
-    const ToolChain *cxxToolChain, const ToolChain *cToolChain)
+    const Toolchain *cxxToolChain, const Toolchain *cToolChain)
 {
     RawProjectParts parts;
     for_each_source_group(m_parserResult.targets,

src/plugins/mesonprojectmanager/mesonprojectparser.h

@@ -57,8 +57,8 @@ public:
     QList<ProjectExplorer::BuildTargetInfo> appsTargets() const;
 
     ProjectExplorer::RawProjectParts buildProjectParts(
-        const ProjectExplorer::ToolChain *cxxToolChain,
+        const ProjectExplorer::Toolchain *cxxToolChain,
-        const ProjectExplorer::ToolChain *cToolChain);
+        const ProjectExplorer::Toolchain *cToolChain);
 
     void setEnvironment(const Utils::Environment &environment) { m_env = environment; }
 
@@ -78,8 +78,8 @@ private:
     void update(const QFuture<ParserData *> &data);
     ProjectExplorer::RawProjectPart buildRawPart(const Target &target,
                                                  const Target::SourceGroup &sources,
-                                                 const ProjectExplorer::ToolChain *cxxToolChain,
+                                                 const ProjectExplorer::Toolchain *cxxToolChain,
-                                                 const ProjectExplorer::ToolChain *cToolChain);
+                                                 const ProjectExplorer::Toolchain *cToolChain);
 
     MesonOutputParser m_outputParser;
     Utils::Environment m_env;

src/plugins/nim/project/nimtoolchain.cpp

@@ -32,7 +32,7 @@ NimToolChain::NimToolChain()
 {}
 
 NimToolChain::NimToolChain(Utils::Id typeId)
-    : ToolChain(typeId)
+    : Toolchain(typeId)
     , m_version(std::make_tuple(-1,-1,-1))
 {
     setLanguage(Constants::C_NIMLANGUAGE_ID);
@@ -41,9 +41,9 @@ NimToolChain::NimToolChain(Utils::Id typeId)
     setCompilerCommandKey("Nim.NimToolChain.CompilerCommand");
 }
 
-ToolChain::MacroInspectionRunner NimToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner NimToolChain::createMacroInspectionRunner() const
 {
-    return ToolChain::MacroInspectionRunner();
+    return Toolchain::MacroInspectionRunner();
 }
 
 LanguageExtensions NimToolChain::languageExtensions(const QStringList &) const
@@ -56,10 +56,10 @@ WarningFlags NimToolChain::warningFlags(const QStringList &) const
     return WarningFlags::NoWarnings;
 }
 
-ToolChain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
-    return ToolChain::BuiltInHeaderPathsRunner();
+    return Toolchain::BuiltInHeaderPathsRunner();
 }
 
 void NimToolChain::addToEnvironment(Environment &env) const
@@ -91,7 +91,7 @@ QString NimToolChain::compilerVersion() const
 
 void NimToolChain::fromMap(const Store &data)
 {
-    ToolChain::fromMap(data);
+    Toolchain::fromMap(data);
     if (hasError())
         return;
     parseVersion(compilerCommand(), m_version);
@@ -220,7 +220,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
     if (compilerPath.isEmpty())
         return result;
 
-    result = Utils::filtered(detector.alreadyKnown, [compilerPath](ToolChain *tc) {
+    result = Utils::filtered(detector.alreadyKnown, [compilerPath](Toolchain *tc) {
         return tc->typeId() == Constants::C_NIMTOOLCHAIN_TYPEID
                 && tc->compilerCommand() == compilerPath;
     });
@@ -229,7 +229,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
         return result;
 
     auto tc = new NimToolChain;
-    tc->setDetection(ToolChain::AutoDetection);
+    tc->setDetection(Toolchain::AutoDetection);
     tc->setCompilerCommand(compilerPath);
     result.append(tc);
     return result;
@@ -240,7 +240,7 @@ Toolchains NimToolchainFactory::detectForImport(const ToolChainDescription &tcd)
     Toolchains result;
     if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
         auto tc = new NimToolChain;
-        tc->setDetection(ToolChain::ManualDetection); // FIXME: sure?
+        tc->setDetection(Toolchain::ManualDetection); // FIXME: sure?
         tc->setCompilerCommand(tcd.compilerPath);
         result.append(tc);
     }

src/plugins/nim/project/nimtoolchain.h

@@ -8,7 +8,7 @@
 
 namespace Nim {
 
-class NimToolChain : public ProjectExplorer::ToolChain
+class NimToolChain : public ProjectExplorer::Toolchain
 {
 public:
     NimToolChain();

src/plugins/projectexplorer/customtoolchain.cpp

@@ -44,11 +44,11 @@ const char outputParserKeyC[] = "ProjectExplorer.CustomToolChain.OutputParser";
 // CustomToolChain
 // --------------------------------------------------------------------------
 
-class CustomToolChain : public ToolChain
+class CustomToolChain : public Toolchain
 {
 public:
     CustomToolChain()
-        : ToolChain(Constants::CUSTOM_TOOLCHAIN_TYPEID)
+        : Toolchain(Constants::CUSTOM_TOOLCHAIN_TYPEID)
         , m_outputParserId(GccParser::id())
     {
         setTypeDisplayName(Tr::tr("Custom"));
@@ -82,7 +82,7 @@ public:
 
     std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() override;
 
-    bool operator ==(const ToolChain &) const override;
+    bool operator ==(const Toolchain &) const override;
 
     void setMakeCommand(const FilePath &);
     FilePath makeCommand(const Environment &environment) const override;
@@ -123,7 +123,7 @@ bool CustomToolChain::isValid() const
     return true;
 }
 
-ToolChain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner() const
 {
     const Macros theMacros = m_predefinedMacros;
     const Id lang = language();
@@ -138,7 +138,7 @@ ToolChain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner()
                 macros.append({cxxFlag.mid(2).trimmed().toUtf8(), MacroType::Undefine});
 
         }
-        return MacroInspectionReport{macros, ToolChain::languageVersion(lang, macros)};
+        return MacroInspectionReport{macros, Toolchain::languageVersion(lang, macros)};
     };
 }
 
@@ -166,7 +166,7 @@ void CustomToolChain::setPredefinedMacros(const Macros &macros)
     toolChainUpdated();
 }
 
-ToolChain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     const HeaderPaths builtInHeaderPaths = m_builtInHeaderPaths;
@@ -273,7 +273,7 @@ QString CustomToolChain::mkspecs() const
 
 void CustomToolChain::toMap(Store &data) const
 {
-    ToolChain::toMap(data);
+    Toolchain::toMap(data);
     data.insert(makeCommandKeyC, m_makeCommand.toString());
     QStringList macros = Utils::transform<QList>(m_predefinedMacros, [](const Macro &m) { return QString::fromUtf8(m.toByteArray()); });
     data.insert(predefinedMacrosKeyC, macros);
@@ -285,7 +285,7 @@ void CustomToolChain::toMap(Store &data) const
 
 void CustomToolChain::fromMap(const Store &data)
 {
-    ToolChain::fromMap(data);
+    Toolchain::fromMap(data);
     if (hasError())
         return;
 
@@ -298,9 +298,9 @@ void CustomToolChain::fromMap(const Store &data)
     setOutputParserId(Id::fromSetting(data.value(outputParserKeyC)));
 }
 
-bool CustomToolChain::operator ==(const ToolChain &other) const
+bool CustomToolChain::operator ==(const Toolchain &other) const
 {
-    if (!ToolChain::operator ==(other))
+    if (!Toolchain::operator ==(other))
         return false;
 
     auto customTc = static_cast<const CustomToolChain *>(&other);

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -363,7 +363,7 @@ static Id idForSubType(GccToolChain::SubType subType)
 }
 
 GccToolChain::GccToolChain(Id typeId, SubType subType)
-    : ToolChain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
+    : Toolchain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
 {
     setTypeDisplayName(Tr::tr("GCC"));
     setTargetAbiKey(targetAbiKeyC);
@@ -437,7 +437,7 @@ LanguageExtensions GccToolChain::defaultLanguageExtensions() const
 
 static const Toolchains mingwToolChains()
 {
-    return ToolChainManager::toolchains([](const ToolChain *tc) -> bool {
+    return ToolChainManager::toolchains([](const Toolchain *tc) -> bool {
         return tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID;
     });
 }
@@ -447,7 +447,7 @@ static const GccToolChain *mingwToolChainFromId(const QByteArray &id)
     if (id.isEmpty())
         return nullptr;
 
-    for (const ToolChain *tc : mingwToolChains()) {
+    for (const Toolchain *tc : mingwToolChains()) {
         if (tc->id() == id)
             return static_cast<const GccToolChain *>(tc);
     }
@@ -546,7 +546,7 @@ static QStringList filteredFlags(const QStringList &allFlags, bool considerSysro
     return filtered;
 }
 
-ToolChain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() const
 {
     // Using a clean environment breaks ccache/distcc/etc.
     Environment env = compilerCommand().deviceEnvironment();
@@ -702,7 +702,7 @@ WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
 
 FilePaths GccToolChain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const
 {
-    return ToolChain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
+    return Toolchain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
 }
 
 static QStringList gccPrepareArguments(const QStringList &flags,
@@ -770,7 +770,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Environment &env,
     return paths;
 }
 
-ToolChain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner(
         const Environment &env) const
 {
     // Using a clean environment breaks ccache/distcc/etc.
@@ -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)
@@ -1014,7 +1014,7 @@ QStringList GccToolChain::platformLinkerFlags() const
 
 void GccToolChain::toMap(Store &data) const
 {
-    ToolChain::toMap(data);
+    Toolchain::toMap(data);
     data.insert(compilerPlatformCodeGenFlagsKeyC, m_platformCodeGenFlags);
     data.insert(compilerPlatformLinkerFlagsKeyC, m_platformLinkerFlags);
     data.insert(originalTargetTripleKeyC, m_originalTargetTriple);
@@ -1028,7 +1028,7 @@ void GccToolChain::toMap(Store &data) const
 
 void GccToolChain::fromMap(const Store &data)
 {
-    ToolChain::fromMap(data);
+    Toolchain::fromMap(data);
     if (hasError())
         return;
 
@@ -1051,9 +1051,9 @@ void GccToolChain::fromMap(const Store &data)
     }
 }
 
-bool GccToolChain::operator ==(const ToolChain &other) const
+bool GccToolChain::operator ==(const Toolchain &other) const
 {
-    if (!ToolChain::operator ==(other))
+    if (!Toolchain::operator ==(other))
         return false;
 
     auto gccTc = static_cast<const GccToolChain *>(&other);
@@ -1254,22 +1254,22 @@ static Utils::FilePaths renesasRl78SearchPathsFromRegistry()
     return searchPaths;
 }
 
-static ToolChain *constructRealGccToolchain()
+static Toolchain *constructRealGccToolchain()
 {
     return new GccToolChain(Constants::GCC_TOOLCHAIN_TYPEID, GccToolChain::RealGcc);
 }
 
-static ToolChain *constructClangToolchain()
+static Toolchain *constructClangToolchain()
 {
     return new GccToolChain(Constants::CLANG_TOOLCHAIN_TYPEID, GccToolChain::Clang);
 }
 
-static ToolChain *constructMinGWToolchain()
+static Toolchain *constructMinGWToolchain()
 {
     return new GccToolChain(Constants::MINGW_TOOLCHAIN_TYPEID, GccToolChain::MinGW);
 }
 
-static ToolChain *constructLinuxIccToolchain()
+static Toolchain *constructLinuxIccToolchain()
 {
     return new GccToolChain(Constants::LINUXICC_TOOLCHAIN_TYPEID, GccToolChain::LinuxIcc);
 }
@@ -1557,7 +1557,7 @@ Toolchains GccToolchainFactory::autoDetectSdkClangToolchain(const Toolchains &kn
     if (compilerPath.isEmpty())
         return {};
 
-    for (ToolChain * const existingTc : known) {
+    for (Toolchain * const existingTc : known) {
         if (existingTc->compilerCommand() == compilerPath)
             return {existingTc};
     }
@@ -1572,12 +1572,12 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
                                                      const GccToolChain::SubType subType)
 {
     Toolchains existingCandidates = filtered(known,
-            [language](const ToolChain *tc) { return tc->language() == language; });
+            [language](const Toolchain *tc) { return tc->language() == language; });
 
     Toolchains result;
     for (const FilePath &compilerPath : std::as_const(compilerPaths)) {
         bool alreadyExists = false;
-        for (ToolChain * const existingTc : existingCandidates) {
+        for (Toolchain * const existingTc : existingCandidates) {
             // We have a match if the existing toolchain ultimately refers to the same file
             // as the candidate path, either directly or via a hard or soft link.
             // Exceptions:
@@ -1644,11 +1644,11 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolChainDescription &
         auto tc = new GccToolChain({}, detectedSubType);
 
         tc->setLanguage(tcd.language);
-        tc->setDetection(ToolChain::AutoDetection);
+        tc->setDetection(Toolchain::AutoDetection);
         tc->predefinedMacrosCache()
             ->insert(QStringList(),
-                     ToolChain::MacroInspectionReport{macros,
+                     Toolchain::MacroInspectionReport{macros,
-                                                      ToolChain::languageVersion(tcd.language, macros)});
+                                                      Toolchain::languageVersion(tcd.language, macros)});
         tc->setCompilerCommand(tcd.compilerPath);
         tc->setSupportedAbis(detectedAbis.supportedAbis);
         tc->setTargetAbi(abi);
@@ -1656,7 +1656,7 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolChainDescription &
         tc->setDisplayName(tc->defaultDisplayName()); // reset displayname
         // lower priority of g++/gcc on macOS - usually just a frontend to clang
         if (detectedSubType == GccToolChain::RealGcc && abi.binaryFormat() == Abi::MachOFormat)
-            tc->setPriority(ToolChain::PriorityLow);
+            tc->setPriority(Toolchain::PriorityLow);
         result.append(tc);
     }
     return result;
@@ -1671,7 +1671,7 @@ class TargetTripleWidget : public QWidget
     Q_OBJECT
 
 public:
-    TargetTripleWidget(const ToolChain *toolchain)
+    TargetTripleWidget(const Toolchain *toolchain)
     {
         const auto layout = new QHBoxLayout(this);
         layout->setContentsMargins(0, 0, 0, 0);
@@ -1759,17 +1759,17 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
 
         ToolChainManager *tcManager = ToolChainManager::instance();
         m_parentToolChainConnections.append(
-            connect(tcManager, &ToolChainManager::toolChainUpdated, this, [this](ToolChain *tc) {
+            connect(tcManager, &ToolChainManager::toolChainUpdated, this, [this](Toolchain *tc) {
                 if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
                     updateParentToolChainComboBox();
             }));
         m_parentToolChainConnections.append(
-            connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](ToolChain *tc) {
+            connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](Toolchain *tc) {
                 if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
                     updateParentToolChainComboBox();
             }));
         m_parentToolChainConnections.append(
-            connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](ToolChain *tc) {
+            connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](Toolchain *tc) {
                 if (tc->id() == toolChain()->id()) {
                     for (QMetaObject::Connection &connection : m_parentToolChainConnections)
                         QObject::disconnect(connection);
@@ -1808,8 +1808,8 @@ void GccToolChainConfigWidget::applyImpl()
 
     tc->predefinedMacrosCache()
         ->insert(tc->platformCodeGenFlags(),
-                 ToolChain::MacroInspectionReport{m_macros,
+                 Toolchain::MacroInspectionReport{m_macros,
-                                                  ToolChain::languageVersion(tc->language(),
+                                                  Toolchain::languageVersion(tc->language(),
                                                                              m_macros)});
 
     if (m_subType == GccToolChain::Clang && m_parentToolchainCombo) {
@@ -1818,7 +1818,7 @@ void GccToolChainConfigWidget::applyImpl()
 
         const QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
         if (!parentId.isEmpty()) {
-            for (const ToolChain *mingwTC : mingwToolChains()) {
+            for (const Toolchain *mingwTC : mingwToolChains()) {
                 if (parentId == mingwTC->id()) {
                     tc->m_parentToolChainId = mingwTC->id();
                     tc->setTargetAbi(mingwTC->targetAbi());
@@ -1959,7 +1959,7 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
     if (!ToolChainManager::isLoaded()) {
         connect(ToolChainManager::instance(), &ToolChainManager::toolChainsLoaded, this,
                 [id = id()] {
-            if (ToolChain * const tc = ToolChainManager::findToolChain(id)) {
+            if (Toolchain * const tc = ToolChainManager::findToolChain(id)) {
                 if (tc->typeId() == Constants::CLANG_TOOLCHAIN_TYPEID)
                     static_cast<GccToolChain *>(tc)->syncAutodetectedWithParentToolchains();
             }
@@ -1975,14 +1975,14 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
     // Subscribe only autodetected toolchains.
     ToolChainManager *tcManager = ToolChainManager::instance();
     m_mingwToolchainAddedConnection
-        = connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](ToolChain *tc) {
+        = connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](Toolchain *tc) {
               if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
                   && !mingwToolChainFromId(m_parentToolChainId)) {
                   m_parentToolChainId = tc->id();
               }
           });
     m_thisToolchainRemovedConnection
-        = connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](ToolChain *tc) {
+        = connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](Toolchain *tc) {
               if (tc == this) {
                   QObject::disconnect(m_thisToolchainRemovedConnection);
                   QObject::disconnect(m_mingwToolchainAddedConnection);
@@ -2012,7 +2012,7 @@ bool GccToolChain::matchesCompilerCommand(const FilePath &command) const
             && m_resolvedCompilerCommand->isSameExecutable(command))
             return true;
     }
-    return ToolChain::matchesCompilerCommand(command);
+    return Toolchain::matchesCompilerCommand(command);
 }
 
 QString GccToolChain::sysRoot() const
@@ -2044,7 +2044,7 @@ void GccToolChainConfigWidget::updateParentToolChainComboBox()
     if (tc->isAutoDetected())
         return;
 
-    for (const ToolChain *mingwTC : mingwToolChains()) {
+    for (const Toolchain *mingwTC : mingwToolChains()) {
         if (mingwTC->id() == parentId)
             continue;
         if (mingwTC->language() != tc->language())

src/plugins/projectexplorer/gcctoolchain.h

@@ -26,7 +26,7 @@ const QStringList gccPredefinedMacrosOptions(Utils::Id languageId);
 // GccToolChain
 // --------------------------------------------------------------------------
 
-class PROJECTEXPLORER_EXPORT GccToolChain : public ToolChain
+class PROJECTEXPLORER_EXPORT GccToolChain : public Toolchain
 {
 public:
     enum SubType { RealGcc, Clang, MinGW, LinuxIcc };
@@ -57,7 +57,7 @@ public:
 
     std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() override;
 
-    bool operator ==(const ToolChain &) const override;
+    bool operator ==(const Toolchain &) const override;
 
     void resetToolChain(const Utils::FilePath &);
     void setPlatformCodeGenFlags(const QStringList &);

src/plugins/projectexplorer/kitaspects.cpp

@@ -160,7 +160,7 @@ FilePath SysRootKitAspect::sysRoot(const Kit *k)
     if (!k->value(SysRootKitAspect::id()).toString().isEmpty())
         return FilePath::fromSettings(k->value(SysRootKitAspect::id()));
 
-    for (ToolChain *tc : ToolChainKitAspect::toolChains(k)) {
+    for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) {
         if (!tc->sysRoot().isEmpty())
             return FilePath::fromString(tc->sysRoot());
     }
@@ -172,7 +172,7 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
     if (!k)
         return;
 
-    for (ToolChain *tc : ToolChainKitAspect::toolChains(k)) {
+    for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) {
         if (!tc->sysRoot().isEmpty()) {
             // It's the sysroot from toolchain, don't set it.
             if (tc->sysRoot() == v.toString())
@@ -249,26 +249,26 @@ private:
         const GuardLocker locker(m_ignoreChanges);
         const QList<Id> keys = m_languageComboboxMap.keys();
         for (const Id l : keys) {
-            const Toolchains ltcList = ToolChainManager::toolchains(equal(&ToolChain::language, l));
+            const Toolchains ltcList = ToolChainManager::toolchains(equal(&Toolchain::language, l));
 
             QComboBox *cb = m_languageComboboxMap.value(l);
             cb->clear();
             cb->addItem(Tr::tr("<No compiler>"), QByteArray());
 
-            const QList<ToolChain *> same = Utils::filtered(ltcList, [device](ToolChain *tc) {
+            const QList<Toolchain *> same = Utils::filtered(ltcList, [device](Toolchain *tc) {
                 return tc->compilerCommand().isSameDevice(device->rootPath());
             });
-            const QList<ToolChain *> other = Utils::filtered(ltcList, [device](ToolChain *tc) {
+            const QList<Toolchain *> other = Utils::filtered(ltcList, [device](Toolchain *tc) {
                 return !tc->compilerCommand().isSameDevice(device->rootPath());
             });
 
-            for (ToolChain *item : same)
+            for (Toolchain *item : same)
                 cb->addItem(item->displayName(), item->id());
 
             if (!same.isEmpty() && !other.isEmpty())
                 cb->insertSeparator(cb->count());
 
-            for (ToolChain *item : other)
+            for (Toolchain *item : other)
                 cb->addItem(item->displayName(), item->id());
 
             cb->setEnabled(cb->count() > 1 && !m_isReadOnly);
@@ -292,7 +292,7 @@ private:
             return;
 
         const QByteArray id = m_languageComboboxMap.value(language)->itemData(idx).toByteArray();
-        ToolChain *tc = ToolChainManager::findToolChain(id);
+        Toolchain *tc = ToolChainManager::findToolChain(id);
         QTC_ASSERT(!tc || tc->language() == language, return);
         if (tc)
             ToolChainKitAspect::setToolChain(m_kit, tc);
@@ -300,7 +300,7 @@ private:
             ToolChainKitAspect::clearToolChain(m_kit, language);
     }
 
-    int indexOf(QComboBox *cb, const ToolChain *tc)
+    int indexOf(QComboBox *cb, const Toolchain *tc)
     {
         const QByteArray id = tc ? tc->id() : QByteArray();
         for (int i = 0; i < cb->count(); ++i) {
@@ -342,8 +342,8 @@ private:
 
     void onKitsLoaded() override;
 
-    void toolChainUpdated(ToolChain *tc);
+    void toolChainUpdated(Toolchain *tc);
-    void toolChainRemoved(ToolChain *tc);
+    void toolChainRemoved(Toolchain *tc);
 };
 
 ToolChainKitAspectFactory::ToolChainKitAspectFactory()
@@ -361,10 +361,10 @@ static QMap<Id, QByteArray> defaultToolChainIds()
 {
     QMap<Id, QByteArray> toolChains;
     const Abi abi = Abi::hostAbi();
-    const Toolchains tcList = ToolChainManager::toolchains(equal(&ToolChain::targetAbi, abi));
+    const Toolchains tcList = ToolChainManager::toolchains(equal(&Toolchain::targetAbi, abi));
     const QList<Id> languages = ToolChainManager::allLanguages();
     for (Id l : languages) {
-        ToolChain *tc = findOrDefault(tcList, equal(&ToolChain::language, l));
+        Toolchain *tc = findOrDefault(tcList, equal(&Toolchain::language, l));
         toolChains.insert(l, tc ? tc->id() : QByteArray());
     }
     return toolChains;
@@ -384,12 +384,12 @@ Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
 {
     Tasks result;
 
-    const QList<ToolChain*> tcList = ToolChainKitAspect::toolChains(k);
+    const QList<Toolchain*> tcList = ToolChainKitAspect::toolChains(k);
     if (tcList.isEmpty()) {
         result << BuildSystemTask(Task::Warning, ToolChainKitAspect::msgNoToolChainInTarget());
     } else {
         QSet<Abi> targetAbis;
-        for (const ToolChain *tc : tcList) {
+        for (const Toolchain *tc : tcList) {
             targetAbis.insert(tc->targetAbi());
             result << tc->validateKit(k);
         }
@@ -443,18 +443,18 @@ void ToolChainKitAspectFactory::setup(Kit *k)
         }
 
         const QByteArray id = i.value().toByteArray();
-        ToolChain *tc = ToolChainManager::findToolChain(id);
+        Toolchain *tc = ToolChainManager::findToolChain(id);
         if (tc)
             continue;
 
         // ID is not found: Might be an ABI string...
         lockToolchains = false;
         const QString abi = QString::fromUtf8(id);
-        const Toolchains possibleTcs = ToolChainManager::toolchains([abi, l](const ToolChain *t) {
+        const Toolchains possibleTcs = ToolChainManager::toolchains([abi, l](const Toolchain *t) {
             return t->targetAbi().toString() == abi && t->language() == l;
         });
-        ToolChain *bestTc = nullptr;
+        Toolchain *bestTc = nullptr;
-        for (ToolChain *tc : possibleTcs) {
+        for (Toolchain *tc : possibleTcs) {
             if (!bestTc || tc->priority() > bestTc->priority())
                 bestTc = tc;
         }
@@ -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 {};
@@ -534,7 +534,7 @@ QList<OutputLineParser *> ToolChainKitAspectFactory::createOutputParsers(const K
 QSet<Id> ToolChainKitAspectFactory::availableFeatures(const Kit *k) const
 {
     QSet<Id> result;
-    for (ToolChain *tc : ToolChainKitAspect::toolChains(k))
+    for (Toolchain *tc : ToolChainKitAspect::toolChains(k))
         result.insert(tc->typeId().withPrefix("ToolChain."));
     return result;
 }
@@ -555,35 +555,35 @@ 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));
 }
 
-ToolChain *ToolChainKitAspect::cToolChain(const Kit *k)
+Toolchain *ToolChainKitAspect::cToolChain(const Kit *k)
 {
     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));
 }
 
 
-QList<ToolChain *> ToolChainKitAspect::toolChains(const Kit *k)
+QList<Toolchain *> ToolChainKitAspect::toolChains(const Kit *k)
 {
     QTC_ASSERT(k, return {});
 
     const Store value = storeFromVariant(k->value(ToolChainKitAspect::id()));
-    const QList<ToolChain *> tcList
+    const QList<Toolchain *> tcList
             = transform<QList>(ToolChainManager::allLanguages(), [&value](Id l) {
                 return ToolChainManager::findToolChain(value.value(l.toKey()).toByteArray());
             });
-    return filtered(tcList, [](ToolChain *tc) { return tc; });
+    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);
@@ -618,9 +618,9 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
         if (l == tc->language())
             continue;
 
-        ToolChain *match = nullptr;
+        Toolchain *match = nullptr;
-        ToolChain *bestMatch = nullptr;
+        Toolchain *bestMatch = nullptr;
-        for (ToolChain *other : allTcList) {
+        for (Toolchain *other : allTcList) {
             if (!other->isValid() || other->language() != l)
                 continue;
             if (other->targetAbi() == tc->targetAbi())
@@ -654,11 +654,11 @@ void ToolChainKitAspect::clearToolChain(Kit *k, Id language)
 
 Abi ToolChainKitAspect::targetAbi(const Kit *k)
 {
-    const QList<ToolChain *> tcList = toolChains(k);
+    const QList<Toolchain *> tcList = toolChains(k);
     // Find the best possible ABI for all the tool chains...
     Abi cxxAbi;
     QHash<Abi, int> abiCount;
-    for (ToolChain *tc : tcList) {
+    for (Toolchain *tc : tcList) {
         Abi ta = tc->targetAbi();
         if (tc->language() == Id(Constants::CXX_LANGUAGE_ID))
             cxxAbi = tc->targetAbi();
@@ -701,7 +701,7 @@ void ToolChainKitAspectFactory::onKitsLoaded()
             this, &ToolChainKitAspectFactory::toolChainUpdated);
 }
 
-void ToolChainKitAspectFactory::toolChainUpdated(ToolChain *tc)
+void ToolChainKitAspectFactory::toolChainUpdated(Toolchain *tc)
 {
     for (Kit *k : KitManager::kits()) {
         if (ToolChainKitAspect::toolChain(k, tc->language()) == tc)
@@ -709,7 +709,7 @@ void ToolChainKitAspectFactory::toolChainUpdated(ToolChain *tc)
     }
 }
 
-void ToolChainKitAspectFactory::toolChainRemoved(ToolChain *tc)
+void ToolChainKitAspectFactory::toolChainRemoved(Toolchain *tc)
 {
     Q_UNUSED(tc)
     for (Kit *k : KitManager::kits())

src/plugins/projectexplorer/kitaspects.h

@@ -12,7 +12,7 @@
 
 namespace ProjectExplorer {
 
-class ToolChain;
+class Toolchain;
 
 // SysRootKitAspect
 
@@ -31,12 +31,12 @@ class PROJECTEXPLORER_EXPORT ToolChainKitAspect
 public:
     static Utils::Id id();
     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 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 Abi targetAbi(const Kit *k);
 

src/plugins/projectexplorer/kitmanager.cpp

@@ -151,8 +151,8 @@ void KitManager::destroy()
 
 static bool kitMatchesAbiList(const Kit *kit, const Abis &abis)
 {
-    const QList<ToolChain *> toolchains = ToolChainKitAspect::toolChains(kit);
+    const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit);
-    for (const ToolChain * const tc : toolchains) {
+    for (const Toolchain * const tc : toolchains) {
         const Abi tcAbi = tc->targetAbi();
         for (const Abi &abi : abis) {
             if (tcAbi.os() == abi.os() && tcAbi.architecture() == abi.architecture()
@@ -183,8 +183,8 @@ static Id deviceTypeForKit(const Kit *kit)
 {
     if (isHostKit(kit))
         return Constants::DESKTOP_DEVICE_TYPE;
-    const QList<ToolChain *> toolchains = ToolChainKitAspect::toolChains(kit);
+    const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit);
-    for (const ToolChain * const tc : toolchains) {
+    for (const Toolchain * const tc : toolchains) {
         const Abi tcAbi = tc->targetAbi();
         switch (tcAbi.os()) {
         case Abi::BareMetalOS:
@@ -298,7 +298,7 @@ void KitManager::restoreKits()
 
     if (resultList.empty() || !haveKitForBinary) {
         // No kits exist yet, so let's try to autoconfigure some from the toolchains we know.
-        QHash<Abi, QHash<Utils::Id, ToolChain *>> uniqueToolchains;
+        QHash<Abi, QHash<Utils::Id, Toolchain *>> uniqueToolchains;
 
         // On Linux systems, we usually detect a plethora of same-ish toolchains. The following
         // algorithm gives precedence to icecc and ccache and otherwise simply chooses the one with
@@ -306,8 +306,8 @@ void KitManager::restoreKits()
         // TODO: This should not need to be done here. Instead, it should be a convenience
         // operation on some lower level, e.g. in the toolchain class(es).
         // Also, we shouldn't detect so many doublets in the first place.
-        for (ToolChain * const tc : ToolChainManager::toolchains()) {
+        for (Toolchain * const tc : ToolChainManager::toolchains()) {
-            ToolChain *&bestTc = uniqueToolchains[tc->targetAbi()][tc->language()];
+            Toolchain *&bestTc = uniqueToolchains[tc->targetAbi()][tc->language()];
             if (!bestTc) {
                 bestTc = tc;
                 continue;
@@ -346,7 +346,7 @@ void KitManager::restoreKits()
             auto kit = std::make_unique<Kit>();
             kit->setSdkProvided(false);
             kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here?
-            for (ToolChain * const tc : it.value())
+            for (Toolchain * const tc : it.value())
                 ToolChainKitAspect::setToolChain(kit.get(), tc);
             if (contains(resultList, [&kit](const std::unique_ptr<Kit> &existingKit) {
                 return ToolChainKitAspect::toolChains(kit.get())

src/plugins/projectexplorer/makestep.cpp

@@ -127,10 +127,10 @@ QString MakeStep::defaultDisplayName()
     return Tr::tr("Make");
 }
 
-static const QList<ToolChain *> preferredToolChains(const Kit *kit)
+static const QList<Toolchain *> preferredToolChains(const Kit *kit)
 {
     // prefer CXX, then C, then others
-    return Utils::sorted(ToolChainKitAspect::toolChains(kit), [](ToolChain *tcA, ToolChain *tcB) {
+    return Utils::sorted(ToolChainKitAspect::toolChains(kit), [](Toolchain *tcA, Toolchain *tcB) {
         if (tcA->language() == tcB->language())
             return false;
         if (tcA->language() == Constants::CXX_LANGUAGE_ID)
@@ -146,7 +146,7 @@ static const QList<ToolChain *> preferredToolChains(const Kit *kit)
 FilePath MakeStep::defaultMakeCommand() const
 {
     const Environment env = makeEnvironment();
-    for (const ToolChain *tc : preferredToolChains(kit())) {
+    for (const Toolchain *tc : preferredToolChains(kit())) {
         FilePath make = tc->makeCommand(env);
         if (!make.isEmpty()) {
             IDevice::ConstPtr dev = BuildDeviceKitAspect::device(kit());
@@ -169,8 +169,8 @@ Task MakeStep::makeCommandMissingTask()
 
 bool MakeStep::isJobCountSupported() const
 {
-    const QList<ToolChain *> tcs = preferredToolChains(kit());
+    const QList<Toolchain *> tcs = preferredToolChains(kit());
-    const ToolChain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
+    const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
     return tc && tc->isJobCountSupported();
 }
 
@@ -236,8 +236,8 @@ Environment MakeStep::makeEnvironment() const
     env.setupEnglishOutput();
     if (makeCommand().isEmpty()) {
         // We also prepend "L" to the MAKEFLAGS, so that nmake / jom are less verbose
-        const QList<ToolChain *> tcs = preferredToolChains(target()->kit());
+        const QList<Toolchain *> tcs = preferredToolChains(target()->kit());
-        const ToolChain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
+        const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
         if (tc && tc->targetAbi().os() == Abi::WindowsOS
                 && tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor) {
             env.set(MAKEFLAGS, 'L' + env.expandedValueForKey(MAKEFLAGS));

src/plugins/projectexplorer/msvctoolchain.cpp

@@ -709,7 +709,7 @@ Utils::LanguageVersion MsvcToolChain::msvcLanguageVersion(const QStringList & /*
 
     if (language == Constants::CXX_LANGUAGE_ID) {
         if (!msvcLang.isEmpty()) // >= Visual Studio 2015 Update 3
-            return ToolChain::cxxLanguageVersion(msvcLang);
+            return Toolchain::cxxLanguageVersion(msvcLang);
         if (mscVer >= 1800) // >= Visual Studio 2013 (12.0)
             return LanguageVersion::CXX14;
         if (mscVer >= 1600) // >= Visual Studio 2010 (10.0)
@@ -854,7 +854,7 @@ static void addToAvailableMsvcToolchains(const MsvcToolChain *toolchain)
 }
 
 MsvcToolChain::MsvcToolChain(Utils::Id typeId)
-    : ToolChain(typeId)
+    : Toolchain(typeId)
 {
     setDisplayName("Microsoft Visual C++ Compiler");
     setTypeDisplayName(Tr::tr("MSVC"));
@@ -979,7 +979,7 @@ Abis MsvcToolChain::supportedAbis() const
 
 void MsvcToolChain::toMap(Store &data) const
 {
-    ToolChain::toMap(data);
+    Toolchain::toMap(data);
     data.insert(varsBatKeyC, m_vcvarsBat);
     if (!m_varsBatArg.isEmpty())
         data.insert(varsBatArgKeyC, m_varsBatArg);
@@ -989,7 +989,7 @@ void MsvcToolChain::toMap(Store &data) const
 
 void MsvcToolChain::fromMap(const Store &data)
 {
-    ToolChain::fromMap(data);
+    Toolchain::fromMap(data);
     if (hasError()) {
         g_availableMsvcToolchains.removeOne(this);
         return;
@@ -1029,7 +1029,7 @@ bool static hasFlagEffectOnMacros(const QString &flag)
     return true;
 }
 
-ToolChain::MacroInspectionRunner MsvcToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner MsvcToolChain::createMacroInspectionRunner() const
 {
     Utils::Environment env(m_lastEnvironment);
     addToEnvironment(env);
@@ -1120,10 +1120,10 @@ WarningFlags MsvcToolChain::warningFlags(const QStringList &cflags) const
 FilePaths MsvcToolChain::includedFiles(const QStringList &flags,
                                        const FilePath &directoryPath) const
 {
-    return ToolChain::includedFiles("/FI", flags, directoryPath, PossiblyConcatenatedFlag::Yes);
+    return Toolchain::includedFiles("/FI", flags, directoryPath, PossiblyConcatenatedFlag::Yes);
 }
 
-ToolChain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunner(
         const Environment &env) const
 {
     Utils::Environment fullEnv = env;
@@ -1266,7 +1266,7 @@ static QString msvcVarsToDisplay(const MsvcToolChain &tc)
 class MsvcBasedToolChainConfigWidget : public ToolchainConfigWidget
 {
 public:
-    explicit MsvcBasedToolChainConfigWidget(ToolChain *tc)
+    explicit MsvcBasedToolChainConfigWidget(Toolchain *tc)
         : ToolchainConfigWidget(tc)
         , m_nameDisplayLabel(new QLabel(this))
         , m_varsBatDisplayLabel(new QLabel(this))
@@ -1303,7 +1303,7 @@ protected:
 class MsvcToolChainConfigWidget final : public MsvcBasedToolChainConfigWidget
 {
 public:
-    explicit MsvcToolChainConfigWidget(ToolChain *tc)
+    explicit MsvcToolChainConfigWidget(Toolchain *tc)
         : MsvcBasedToolChainConfigWidget(tc)
         , m_varsBatPathCombo(new QComboBox(this))
         , m_varsBatArchCombo(new QComboBox(this))
@@ -1515,7 +1515,7 @@ std::unique_ptr<ToolchainConfigWidget> MsvcToolChain::createConfigurationWidget(
 class ClangClToolChainConfigWidget final : public MsvcBasedToolChainConfigWidget
 {
 public:
-    explicit ClangClToolChainConfigWidget(ToolChain *tc)
+    explicit ClangClToolChainConfigWidget(Toolchain *tc)
         : MsvcBasedToolChainConfigWidget(tc)
         , m_varsBatDisplayCombo(new QComboBox(this))
     {
@@ -1669,7 +1669,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
                              .arg(Abi::toString(targetAbi.osFlavor()).toUpper());
     for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
         ClangClToolChain *tc = static_cast<ClangClToolChain *>(
-            Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
+            Utils::findOrDefault(alreadyKnown, [&](Toolchain *tc) -> bool {
                 if (tc->typeId() != Constants::CLANG_CL_TOOLCHAIN_TYPEID)
                     return false;
                 if (tc->targetAbi() != targetAbi)
@@ -1684,7 +1684,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
             auto cltc = new ClangClToolChain;
             cltc->setClangPath(clangClPath);
             cltc->setDisplayName(name);
-            cltc->setDetection(ToolChain::AutoDetection);
+            cltc->setDetection(Toolchain::AutoDetection);
             cltc->setLanguage(language);
             cltc->setupVarsBat(toolChain->targetAbi(), toolChain->varsBat(), toolChain->varsBatArg());
             res << cltc;
@@ -1711,7 +1711,7 @@ void ClangClToolChainConfigWidget::applyImpl()
     if (results.isEmpty()) {
         clangClToolChain->resetVarsBat();
     } else {
-        for (const ToolChain *toolchain : results) {
+        for (const Toolchain *toolchain : results) {
             if (toolchain->language() == clangClToolChain->language()) {
                 auto mstc = static_cast<const MsvcToolChain *>(toolchain);
                 clangClToolChain->setupVarsBat(mstc->targetAbi(), mstc->varsBat(), mstc->varsBatArg());
@@ -1805,7 +1805,7 @@ std::unique_ptr<ToolchainConfigWidget> ClangClToolChain::createConfigurationWidg
     return std::make_unique<ClangClToolChainConfigWidget>(this);
 }
 
-bool ClangClToolChain::operator==(const ToolChain &other) const
+bool ClangClToolChain::operator==(const Toolchain &other) const
 {
     if (!MsvcToolChain::operator==(other))
         return false;
@@ -1847,7 +1847,7 @@ LanguageVersion ClangClToolChain::msvcLanguageVersion(const QStringList &cxxflag
                                                       const Macros &macros) const
 {
     if (cxxflags.contains("--driver-mode=g++"))
-        return ToolChain::languageVersion(language, macros);
+        return Toolchain::languageVersion(language, macros);
     return MsvcToolChain::msvcLanguageVersion(cxxflags, language, macros);
 }
 
@@ -1910,7 +1910,7 @@ static Toolchains findOrCreateToolchains(const ToolchainDetector &detector,
 {
     Toolchains res;
     for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
-        ToolChain *tc = Utils::findOrDefault(detector.alreadyKnown, [&](ToolChain *tc) -> bool {
+        Toolchain *tc = Utils::findOrDefault(detector.alreadyKnown, [&](Toolchain *tc) -> bool {
             if (tc->typeId() != Constants::MSVC_TOOLCHAIN_TYPEID)
                 return false;
             if (tc->targetAbi() != abi)
@@ -1966,7 +1966,7 @@ static void detectCppBuildTools2015(Toolchains *list)
             auto tc = new MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID);
             tc->setupVarsBat(abi, vcVarsBat, QLatin1String(e.varsBatArg));
             tc->setDisplayName(name + QLatin1String(e.postFix));
-            tc->setDetection(ToolChain::AutoDetection);
+            tc->setDetection(Toolchain::AutoDetection);
             tc->setLanguage(language);
             list->append(tc);
         }
@@ -2005,7 +2005,7 @@ Toolchains MsvcToolchainFactory::autoDetect(const ToolchainDetector &detector) c
             if (!fi.exists())
                 continue;
 
-            QList<ToolChain *> tmp;
+            QList<Toolchain *> tmp;
             const QVector<QPair<MsvcToolChain::Platform, QString>> platforms = {
                 {MsvcToolChain::x86, "x86"},
                 {MsvcToolChain::amd64, "x64"},
@@ -2069,15 +2069,15 @@ Toolchains MsvcToolchainFactory::autoDetect(const ToolchainDetector &detector) c
 
     detectCppBuildTools2015(&results);
 
-    for (ToolChain *tc : std::as_const(results))
+    for (Toolchain *tc : std::as_const(results))
-        tc->setDetection(ToolChain::AutoDetection);
+        tc->setDetection(Toolchain::AutoDetection);
 
     return results;
 }
 
-bool MsvcToolChain::operator==(const ToolChain &other) const
+bool MsvcToolChain::operator==(const Toolchain &other) const
 {
-    if (!ToolChain::operator==(other))
+    if (!Toolchain::operator==(other))
         return false;
 
     const auto *msvcTc = dynamic_cast<const MsvcToolChain *>(&other);

src/plugins/projectexplorer/msvctoolchain.h

@@ -20,7 +20,7 @@ namespace ProjectExplorer::Internal {
 // MsvcToolChain
 // --------------------------------------------------------------------------
 
-class MsvcToolChain : public ToolChain
+class MsvcToolChain : public Toolchain
 {
 public:
     enum Type { WindowsSDK, VS };
@@ -61,7 +61,7 @@ public:
     void resetVarsBat();
     Platform platform() const;
 
-    bool operator==(const ToolChain &) const override;
+    bool operator==(const Toolchain &) const override;
 
     bool isJobCountSupported() const override { return false; }
 
@@ -153,7 +153,7 @@ public:
                                                const Utils::Id &language,
                                                const Macros &macros) const override;
 
-    bool operator==(const ToolChain &) const override;
+    bool operator==(const Toolchain &) const override;
 
     int priority() const override;
 

src/plugins/projectexplorer/projectimporter.cpp

@@ -310,7 +310,7 @@ bool ProjectImporter::findTemporaryHandler(Utils::Id id) const
     return Utils::contains(m_temporaryHandlers, [id](const TemporaryInformationHandler &ch) { return ch.id == id; });
 }
 
-static ToolChain *toolChainFromVariant(const QVariant &v)
+static Toolchain *toolChainFromVariant(const QVariant &v)
 {
     const QByteArray tcId = v.toByteArray();
     return ToolChainManager::findToolChain(tcId);
@@ -319,7 +319,7 @@ static ToolChain *toolChainFromVariant(const QVariant &v)
 void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
 {
     for (const QVariant &v : vl) {
-        ToolChain *tc = toolChainFromVariant(v);
+        Toolchain *tc = toolChainFromVariant(v);
         QTC_ASSERT(tc, continue);
         ToolChainManager::deregisterToolChain(tc);
         ToolChainKitAspect::setToolChain(k, nullptr);
@@ -329,9 +329,9 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
 void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
 {
     for (const QVariant &v : vl) {
-        ToolChain *tmpTc = toolChainFromVariant(v);
+        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);
     }
@@ -375,7 +375,7 @@ static ProjectImporter::ToolChainData createToolChains(const ToolChainDescriptio
         if (data.tcs.isEmpty())
             continue;
 
-        for (ToolChain *tc : std::as_const(data.tcs))
+        for (Toolchain *tc : std::as_const(data.tcs))
             ToolChainManager::registerToolChain(tc);
 
         data.areTemporary = true;
@@ -389,10 +389,10 @@ ProjectImporter::ToolChainData
 ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
 {
     ToolChainData result;
-    result.tcs = ToolChainManager::toolchains([&tcd](const ToolChain *tc) {
+    result.tcs = ToolChainManager::toolchains([&tcd](const Toolchain *tc) {
         return tc->language() == tcd.language && tc->matchesCompilerCommand(tcd.compilerPath);
     });
-    for (const ToolChain *tc : std::as_const(result.tcs)) {
+    for (const Toolchain *tc : std::as_const(result.tcs)) {
         const QByteArray tcId = tc->id();
         result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolChainKitAspect::id(), tcId);
     }

src/plugins/projectexplorer/projectimporter.h

@@ -15,7 +15,7 @@ class BuildInfo;
 class Kit;
 class Project;
 class Target;
-class ToolChain;
+class Toolchain;
 
 // Documentation inside.
 class PROJECTEXPLORER_EXPORT ProjectImporter : public QObject
@@ -23,7 +23,7 @@ class PROJECTEXPLORER_EXPORT ProjectImporter : public QObject
     Q_OBJECT
 public:
     struct ToolChainData {
-        QList<ToolChain *> tcs;
+        QList<Toolchain *> tcs;
         bool areTemporary = false;
     };
 

src/plugins/projectexplorer/rawprojectpart.cpp

@@ -16,7 +16,7 @@
 
 namespace ProjectExplorer {
 
-RawProjectPartFlags::RawProjectPartFlags(const ToolChain *toolChain,
+RawProjectPartFlags::RawProjectPartFlags(const Toolchain *toolChain,
                                          const QStringList &commandLineFlags,
                                          const Utils::FilePath &includeFileBaseDir)
 {
@@ -155,7 +155,7 @@ bool KitInfo::isValid() const
     return kit;
 }
 
-ToolChainInfo::ToolChainInfo(const ToolChain *toolChain,
+ToolChainInfo::ToolChainInfo(const Toolchain *toolChain,
                              const Utils::FilePath &sysRootPath,
                              const Utils::Environment &env)
 {

src/plugins/projectexplorer/rawprojectpart.h

@@ -36,7 +36,7 @@ class PROJECTEXPLORER_EXPORT RawProjectPartFlags
 {
 public:
     RawProjectPartFlags() = default;
-    RawProjectPartFlags(const ToolChain *toolChain, const QStringList &commandLineFlags,
+    RawProjectPartFlags(const Toolchain *toolChain, const QStringList &commandLineFlags,
                         const Utils::FilePath &includeFileBaseDir);
 
 public:
@@ -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;
 
@@ -131,7 +131,7 @@ class PROJECTEXPLORER_EXPORT ToolChainInfo
 {
 public:
     ToolChainInfo() = default;
-    ToolChainInfo(const ProjectExplorer::ToolChain *toolChain,
+    ToolChainInfo(const ProjectExplorer::Toolchain *toolChain,
                   const Utils::FilePath &sysRootPath,
                   const Utils::Environment &env);
 
@@ -148,8 +148,8 @@ public:
     QStringList extraCodeModelFlags;
 
     Utils::FilePath sysRootPath; // For headerPathsRunner.
-    ProjectExplorer::ToolChain::BuiltInHeaderPathsRunner headerPathsRunner;
+    ProjectExplorer::Toolchain::BuiltInHeaderPathsRunner headerPathsRunner;
-    ProjectExplorer::ToolChain::MacroInspectionRunner macroInspectionRunner;
+    ProjectExplorer::Toolchain::MacroInspectionRunner macroInspectionRunner;
 };
 
 class PROJECTEXPLORER_EXPORT ProjectUpdateInfo

src/plugins/projectexplorer/toolchain.cpp

@@ -41,13 +41,13 @@ QList<ToolchainFactory *> &toolchainFactories()
 class ToolChainPrivate
 {
 public:
-    using Detection = ToolChain::Detection;
+    using Detection = Toolchain::Detection;
 
     explicit ToolChainPrivate(Id typeId) :
         m_id(QUuid::createUuid().toByteArray()),
         m_typeId(typeId),
-        m_predefinedMacrosCache(new ToolChain::MacrosCache::element_type()),
+        m_predefinedMacrosCache(new Toolchain::MacrosCache::element_type()),
-        m_headerPathsCache(new ToolChain::HeaderPathsCache::element_type())
+        m_headerPathsCache(new Toolchain::HeaderPathsCache::element_type())
     {
         QTC_ASSERT(m_typeId.isValid(), return);
         QTC_ASSERT(!m_typeId.name().contains(':'), return);
@@ -63,12 +63,12 @@ public:
     QString m_typeDisplayName;
     Id m_typeId;
     Id m_language;
-    Detection m_detection = ToolChain::UninitializedDetection;
+    Detection m_detection = Toolchain::UninitializedDetection;
     QString m_detectionSource;
     QString m_explicitCodeModelTargetTriple;
 
-    ToolChain::MacrosCache m_predefinedMacrosCache;
+    Toolchain::MacrosCache m_predefinedMacrosCache;
-    ToolChain::HeaderPathsCache m_headerPathsCache;
+    Toolchain::HeaderPathsCache m_headerPathsCache;
     std::optional<bool> m_isValid;
     bool m_hasError = false;
 };
@@ -119,12 +119,12 @@ using namespace Internal;
 
 // --------------------------------------------------------------------------
 
-ToolChain::ToolChain(Id typeId) :
+Toolchain::Toolchain(Id typeId) :
     d(std::make_unique<ToolChainPrivate>(typeId))
 {
 }
 
-void ToolChain::setLanguage(Id language)
+void Toolchain::setLanguage(Id language)
 {
     QTC_ASSERT(!d->m_language.isValid() || isAutoDetected(), return);
     QTC_ASSERT(language.isValid(), return);
@@ -133,16 +133,16 @@ void ToolChain::setLanguage(Id language)
     d->m_language = language;
 }
 
-ToolChain::~ToolChain() = default;
+Toolchain::~Toolchain() = default;
 
-QString ToolChain::displayName() const
+QString Toolchain::displayName() const
 {
     if (d->m_displayName.isEmpty())
         return typeDisplayName();
     return d->m_displayName;
 }
 
-void ToolChain::setDisplayName(const QString &name)
+void Toolchain::setDisplayName(const QString &name)
 {
     if (d->m_displayName == name)
         return;
@@ -151,42 +151,42 @@ void ToolChain::setDisplayName(const QString &name)
     toolChainUpdated();
 }
 
-bool ToolChain::isAutoDetected() const
+bool Toolchain::isAutoDetected() const
 {
     return detection() == AutoDetection || detection() == AutoDetectionFromSdk;
 }
 
-ToolChain::Detection ToolChain::detection() const
+Toolchain::Detection Toolchain::detection() const
 {
     return d->m_detection;
 }
 
-QString ToolChain::detectionSource() const
+QString Toolchain::detectionSource() const
 {
     return d->m_detectionSource;
 }
 
-QByteArray ToolChain::id() const
+QByteArray Toolchain::id() const
 {
     return d->m_id;
 }
 
-QStringList ToolChain::suggestedMkspecList() const
+QStringList Toolchain::suggestedMkspecList() const
 {
     return {};
 }
 
-Id ToolChain::typeId() const
+Id Toolchain::typeId() const
 {
     return d->m_typeId;
 }
 
-Abis ToolChain::supportedAbis() const
+Abis Toolchain::supportedAbis() const
 {
     return {targetAbi()};
 }
 
-bool ToolChain::isValid() const
+bool Toolchain::isValid() const
 {
     if (!d->m_isValid.has_value())
         d->m_isValid = !compilerCommand().isEmpty() && compilerCommand().isExecutableFile();
@@ -194,19 +194,19 @@ bool ToolChain::isValid() const
     return d->m_isValid.value_or(false);
 }
 
-FilePaths ToolChain::includedFiles(const QStringList &flags, const FilePath &directory) const
+FilePaths Toolchain::includedFiles(const QStringList &flags, const FilePath &directory) const
 {
     Q_UNUSED(flags)
     Q_UNUSED(directory)
     return {};
 }
 
-Id ToolChain::language() const
+Id Toolchain::language() const
 {
     return d->m_language;
 }
 
-bool ToolChain::operator == (const ToolChain &tc) const
+bool Toolchain::operator == (const Toolchain &tc) const
 {
     if (this == &tc)
         return true;
@@ -217,11 +217,11 @@ bool ToolChain::operator == (const ToolChain &tc) const
             && language() == tc.language();
 }
 
-ToolChain *ToolChain::clone() const
+Toolchain *Toolchain::clone() const
 {
     for (ToolchainFactory *f : std::as_const(toolchainFactories())) {
         if (f->supportedToolChainType() == d->m_typeId) {
-            ToolChain *tc = f->create();
+            Toolchain *tc = f->create();
             QTC_ASSERT(tc, return nullptr);
             Store data;
             toMap(data);
@@ -241,7 +241,7 @@ ToolChain *ToolChain::clone() const
     Make sure to call this function when deriving.
 */
 
-void ToolChain::toMap(Store &result) const
+void Toolchain::toMap(Store &result) const
 {
     AspectContainer::toMap(result);
 
@@ -267,7 +267,7 @@ void ToolChain::toMap(Store &result) const
         result.insert(d->m_compilerCommandKey, d->m_compilerCommand.toSettings());
 }
 
-void ToolChain::toolChainUpdated()
+void Toolchain::toolChainUpdated()
 {
     d->m_predefinedMacrosCache->invalidate();
     d->m_headerPathsCache->invalidate();
@@ -275,27 +275,27 @@ void ToolChain::toolChainUpdated()
     ToolChainManager::notifyAboutUpdate(this);
 }
 
-void ToolChain::setDetection(ToolChain::Detection de)
+void Toolchain::setDetection(Toolchain::Detection de)
 {
     d->m_detection = de;
 }
 
-void ToolChain::setDetectionSource(const QString &source)
+void Toolchain::setDetectionSource(const QString &source)
 {
     d->m_detectionSource = source;
 }
 
-QString ToolChain::typeDisplayName() const
+QString Toolchain::typeDisplayName() const
 {
     return d->m_typeDisplayName;
 }
 
-Abi ToolChain::targetAbi() const
+Abi Toolchain::targetAbi() const
 {
     return d->m_targetAbi;
 }
 
-void ToolChain::setTargetAbi(const Abi &abi)
+void Toolchain::setTargetAbi(const Abi &abi)
 {
     if (abi == d->m_targetAbi)
         return;
@@ -304,22 +304,22 @@ void ToolChain::setTargetAbi(const Abi &abi)
     toolChainUpdated();
 }
 
-void ToolChain::setTargetAbiNoSignal(const Abi &abi)
+void Toolchain::setTargetAbiNoSignal(const Abi &abi)
 {
     d->m_targetAbi = abi;
 }
 
-void ToolChain::setTargetAbiKey(const Key &abiKey)
+void Toolchain::setTargetAbiKey(const Key &abiKey)
 {
     d->m_targetAbiKey = abiKey;
 }
 
-FilePath ToolChain::compilerCommand() const
+FilePath Toolchain::compilerCommand() const
 {
     return d->m_compilerCommand;
 }
 
-void ToolChain::setCompilerCommand(const FilePath &command)
+void Toolchain::setCompilerCommand(const FilePath &command)
 {
     d->m_isValid.reset();
 
@@ -329,17 +329,17 @@ void ToolChain::setCompilerCommand(const FilePath &command)
     toolChainUpdated();
 }
 
-bool ToolChain::matchesCompilerCommand(const FilePath &command) const
+bool Toolchain::matchesCompilerCommand(const FilePath &command) const
 {
     return compilerCommand().isSameExecutable(command);
 }
 
-void ToolChain::setCompilerCommandKey(const Key &commandKey)
+void Toolchain::setCompilerCommandKey(const Key &commandKey)
 {
     d->m_compilerCommandKey = commandKey;
 }
 
-void ToolChain::setTypeDisplayName(const QString &typeName)
+void Toolchain::setTypeDisplayName(const QString &typeName)
 {
     d->m_typeDisplayName = typeName;
 }
@@ -350,7 +350,7 @@ void ToolChain::setTypeDisplayName(const QString &typeName)
     Make sure to call this function when deriving.
 */
 
-void ToolChain::fromMap(const Store &data)
+void Toolchain::fromMap(const Store &data)
 {
     AspectContainer::fromMap(data);
 
@@ -392,22 +392,22 @@ void ToolChain::fromMap(const Store &data)
     d->m_isValid.reset();
 }
 
-void ToolChain::reportError()
+void Toolchain::reportError()
 {
     d->m_hasError = true;
 }
 
-bool ToolChain::hasError() const
+bool Toolchain::hasError() const
 {
     return d->m_hasError;
 }
 
-const ToolChain::HeaderPathsCache &ToolChain::headerPathsCache() const
+const Toolchain::HeaderPathsCache &Toolchain::headerPathsCache() const
 {
     return d->m_headerPathsCache;
 }
 
-const ToolChain::MacrosCache &ToolChain::predefinedMacrosCache() const
+const Toolchain::MacrosCache &Toolchain::predefinedMacrosCache() const
 {
     return d->m_predefinedMacrosCache;
 }
@@ -424,7 +424,7 @@ static long toLanguageVersionAsLong(QByteArray dateAsByteArray)
     return result;
 }
 
-LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplusplusMacroValue)
+LanguageVersion Toolchain::cxxLanguageVersion(const QByteArray &cplusplusMacroValue)
 {
     const long version = toLanguageVersionAsLong(cplusplusMacroValue);
 
@@ -440,7 +440,7 @@ LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplusplusMacroVa
     return LanguageVersion::CXX03;
 }
 
-LanguageVersion ToolChain::languageVersion(const Id &language, const Macros &macros)
+LanguageVersion Toolchain::languageVersion(const Id &language, const Macros &macros)
 {
     if (language == Constants::CXX_LANGUAGE_ID) {
         for (const ProjectExplorer::Macro &macro : macros) {
@@ -477,7 +477,7 @@ LanguageVersion ToolChain::languageVersion(const Id &language, const Macros &mac
     }
 }
 
-FilePaths ToolChain::includedFiles(const QString &option,
+FilePaths Toolchain::includedFiles(const QString &option,
                                    const QStringList &flags,
                                    const FilePath &directoryPath,
                                    PossiblyConcatenatedFlag possiblyConcatenated)
@@ -506,22 +506,22 @@ FilePaths ToolChain::includedFiles(const QString &option,
     Used by the tool chain kit information to validate the kit.
 */
 
-Tasks ToolChain::validateKit(const Kit *) const
+Tasks Toolchain::validateKit(const Kit *) const
 {
     return {};
 }
 
-QString ToolChain::sysRoot() const
+QString Toolchain::sysRoot() const
 {
     return {};
 }
 
-QString ToolChain::explicitCodeModelTargetTriple() const
+QString Toolchain::explicitCodeModelTargetTriple() const
 {
     return d->m_explicitCodeModelTargetTriple;
 }
 
-QString ToolChain::effectiveCodeModelTargetTriple() const
+QString Toolchain::effectiveCodeModelTargetTriple() const
 {
     const QString overridden = explicitCodeModelTargetTriple();
     if (!overridden.isEmpty())
@@ -529,7 +529,7 @@ QString ToolChain::effectiveCodeModelTargetTriple() const
     return originalTargetTriple();
 }
 
-void ToolChain::setExplicitCodeModelTargetTriple(const QString &triple)
+void Toolchain::setExplicitCodeModelTargetTriple(const QString &triple)
 {
     d->m_explicitCodeModelTargetTriple = triple;
 }
@@ -589,17 +589,17 @@ bool ToolchainFactory::canCreate() const
     return m_userCreatable;
 }
 
-ToolChain *ToolchainFactory::create() const
+Toolchain *ToolchainFactory::create() const
 {
     return m_toolchainConstructor ? m_toolchainConstructor() : nullptr;
 }
 
-ToolChain *ToolchainFactory::restore(const Store &data)
+Toolchain *ToolchainFactory::restore(const Store &data)
 {
     if (!m_toolchainConstructor)
         return nullptr;
 
-    ToolChain *tc = m_toolchainConstructor();
+    Toolchain *tc = m_toolchainConstructor();
     QTC_ASSERT(tc, return nullptr);
 
     tc->fromMap(data);
@@ -633,11 +633,11 @@ void ToolchainFactory::autoDetectionToMap(Store &data, bool detected)
     data.insert(AUTODETECT_KEY, detected);
 }
 
-ToolChain *ToolchainFactory::createToolChain(Id toolChainType)
+Toolchain *ToolchainFactory::createToolChain(Id toolChainType)
 {
     for (ToolchainFactory *factory : std::as_const(toolchainFactories())) {
         if (factory->m_supportedToolChainType == toolChainType) {
-            if (ToolChain *tc = factory->create()) {
+            if (Toolchain *tc = factory->create()) {
                 tc->d->m_typeId = toolChainType;
                 return tc;
             }

src/plugins/projectexplorer/toolchain.h

@@ -57,7 +57,7 @@ public:
 // ToolChain (documentation inside)
 // --------------------------------------------------------------------------
 
-class PROJECTEXPLORER_EXPORT ToolChain : public Utils::AspectContainer
+class PROJECTEXPLORER_EXPORT Toolchain : public Utils::AspectContainer
 {
 public:
     enum Detection {
@@ -67,9 +67,9 @@ public:
         UninitializedDetection,
     };
 
-    using Predicate = std::function<bool(const ToolChain *)>;
+    using Predicate = std::function<bool(const Toolchain *)>;
 
-    virtual ~ToolChain();
+    virtual ~Toolchain();
 
     QString displayName() const;
     void setDisplayName(const QString &name);
@@ -113,7 +113,7 @@ public:
         Utils::LanguageVersion languageVersion;
     };
 
-    using MacrosCache = std::shared_ptr<Cache<QStringList, ToolChain::MacroInspectionReport, 64>>;
+    using MacrosCache = std::shared_ptr<Cache<QStringList, Toolchain::MacroInspectionReport, 64>>;
     using HeaderPathsCache = std::shared_ptr<Cache<QPair<Utils::Environment, QStringList>, HeaderPaths>>;
 
     // A MacroInspectionRunner is created in the ui thread and runs in another thread.
@@ -135,10 +135,10 @@ public:
 
     virtual QList<Utils::OutputLineParser *> createOutputParsers() const = 0;
 
-    virtual bool operator ==(const ToolChain &) const;
+    virtual bool operator ==(const Toolchain &) const;
 
     virtual std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() = 0;
-    ToolChain *clone() const;
+    Toolchain *clone() const;
 
     // Used by the toolchainmanager to save user-generated tool chains.
     // Make sure to call this function when deriving!
@@ -164,7 +164,7 @@ public:
     virtual GccToolChain *asGccToolChain() { return nullptr; }
 
 protected:
-    explicit ToolChain(Utils::Id typeId);
+    explicit Toolchain(Utils::Id typeId);
 
     void setTypeDisplayName(const QString &typeName);
 
@@ -191,8 +191,8 @@ protected:
                                           PossiblyConcatenatedFlag possiblyConcatenated);
 
 private:
-    ToolChain(const ToolChain &) = delete;
+    Toolchain(const Toolchain &) = delete;
-    ToolChain &operator=(const ToolChain &) = delete;
+    Toolchain &operator=(const Toolchain &) = delete;
 
     const std::unique_ptr<Internal::ToolChainPrivate> d;
 
@@ -200,7 +200,7 @@ private:
     friend class ToolchainFactory;
 };
 
-using Toolchains = QList<ToolChain *>;
+using Toolchains = QList<Toolchain *>;
 
 class PROJECTEXPLORER_EXPORT BadToolchain
 {
@@ -259,15 +259,15 @@ public:
     virtual Toolchains detectForImport(const ToolChainDescription &tcd) const;
 
     virtual bool canCreate() const;
-    ToolChain *create() const;
+    Toolchain *create() const;
 
-    ToolChain *restore(const Utils::Store &data);
+    Toolchain *restore(const Utils::Store &data);
 
     static QByteArray idFromMap(const Utils::Store &data);
     static Utils::Id typeIdFromMap(const Utils::Store &data);
     static void autoDetectionToMap(Utils::Store &data, bool detected);
 
-    static ToolChain *createToolChain(Utils::Id toolChainType);
+    static Toolchain *createToolChain(Utils::Id toolChainType);
 
     QList<Utils::Id> supportedLanguages() const;
 
@@ -278,7 +278,7 @@ protected:
     void setSupportedToolChainType(const Utils::Id &supportedToolChainType);
     void setSupportedLanguages(const QList<Utils::Id> &supportedLanguages);
     void setSupportsAllLanguages(bool supportsAllLanguages);
-    using ToolChainConstructor = std::function<ToolChain *()>;
+    using ToolChainConstructor = std::function<Toolchain *()>;
     void setToolchainConstructor(const ToolChainConstructor &constructor);
     ToolChainConstructor toolchainConstructor() const;
 

src/plugins/projectexplorer/toolchainconfigwidget.cpp

@@ -20,7 +20,7 @@ using namespace Utils;
 
 namespace ProjectExplorer {
 
-ToolchainConfigWidget::ToolchainConfigWidget(ToolChain *tc) :
+ToolchainConfigWidget::ToolchainConfigWidget(Toolchain *tc) :
     m_toolChain(tc)
 {
     Q_ASSERT(tc);
@@ -66,7 +66,7 @@ bool ToolchainConfigWidget::isDirty() const
     return m_nameLineEdit->text() != m_toolChain->displayName() || isDirtyImpl();
 }
 
-ToolChain *ToolchainConfigWidget::toolChain() const
+Toolchain *ToolchainConfigWidget::toolChain() const
 {
     return m_toolChain;
 }

src/plugins/projectexplorer/toolchainconfigwidget.h

@@ -15,7 +15,7 @@ QT_END_NAMESPACE
 
 namespace ProjectExplorer {
 
-class ToolChain;
+class Toolchain;
 
 // --------------------------------------------------------------------------
 // ToolChainConfigWidget
@@ -26,9 +26,9 @@ class PROJECTEXPLORER_EXPORT ToolchainConfigWidget : public QScrollArea
     Q_OBJECT
 
 public:
-    explicit ToolchainConfigWidget(ToolChain *tc);
+    explicit ToolchainConfigWidget(Toolchain *tc);
 
-    ToolChain *toolChain() const;
+    Toolchain *toolChain() const;
 
     void apply();
     void discard();
@@ -53,7 +53,7 @@ protected:
     QLineEdit *m_nameLineEdit;
 
 private:
-    ToolChain *m_toolChain;
+    Toolchain *m_toolChain;
     QLabel *m_errorLabel = nullptr;
 };
 

src/plugins/projectexplorer/toolchainmanager.cpp

@@ -106,7 +106,7 @@ void ToolChainManager::restoreToolChains()
     QTC_ASSERT(!d->m_accessor, return);
     d->m_accessor = std::make_unique<Internal::ToolChainSettingsAccessor>();
 
-    for (ToolChain *tc : d->m_accessor->restoreToolChains(Core::ICore::dialogParent()))
+    for (Toolchain *tc : d->m_accessor->restoreToolChains(Core::ICore::dialogParent()))
         registerToolChain(tc);
 
     d->m_loaded = true;
@@ -131,13 +131,13 @@ const Toolchains &ToolChainManager::toolchains()
     return d->m_toolChains;
 }
 
-Toolchains ToolChainManager::toolchains(const ToolChain::Predicate &predicate)
+Toolchains ToolChainManager::toolchains(const Toolchain::Predicate &predicate)
 {
     QTC_ASSERT(predicate, return {});
     return Utils::filtered(d->m_toolChains, predicate);
 }
 
-ToolChain *ToolChainManager::toolChain(const ToolChain::Predicate &predicate)
+Toolchain *ToolChainManager::toolChain(const Toolchain::Predicate &predicate)
 {
     QTC_CHECK(d->m_loaded);
     return Utils::findOrDefault(d->m_toolChains, predicate);
@@ -147,7 +147,7 @@ Toolchains ToolChainManager::findToolChains(const Abi &abi)
 {
     QTC_CHECK(d->m_loaded);
     Toolchains result;
-    for (ToolChain *tc : std::as_const(d->m_toolChains)) {
+    for (Toolchain *tc : std::as_const(d->m_toolChains)) {
         bool isCompatible = Utils::anyOf(tc->supportedAbis(), [abi](const Abi &supportedAbi) {
             return supportedAbi.isCompatibleWith(abi);
         });
@@ -158,13 +158,13 @@ Toolchains ToolChainManager::findToolChains(const Abi &abi)
     return result;
 }
 
-ToolChain *ToolChainManager::findToolChain(const QByteArray &id)
+Toolchain *ToolChainManager::findToolChain(const QByteArray &id)
 {
     QTC_CHECK(d->m_loaded);
     if (id.isEmpty())
         return nullptr;
 
-    ToolChain *tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&ToolChain::id, id));
+    Toolchain *tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&Toolchain::id, id));
 
     // Compatibility with versions 3.5 and earlier:
     if (!tc) {
@@ -174,7 +174,7 @@ ToolChain *ToolChainManager::findToolChain(const QByteArray &id)
 
         const QByteArray shortId = id.mid(pos + 1);
 
-        tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&ToolChain::id, shortId));
+        tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&Toolchain::id, shortId));
     }
     return tc;
 }
@@ -184,14 +184,14 @@ bool ToolChainManager::isLoaded()
     return d->m_loaded;
 }
 
-void ToolChainManager::notifyAboutUpdate(ToolChain *tc)
+void ToolChainManager::notifyAboutUpdate(Toolchain *tc)
 {
     if (!tc || !d->m_toolChains.contains(tc))
         return;
     emit m_instance->toolChainUpdated(tc);
 }
 
-bool ToolChainManager::registerToolChain(ToolChain *tc)
+bool ToolChainManager::registerToolChain(Toolchain *tc)
 {
     QTC_ASSERT(tc, return false);
     QTC_ASSERT(isLanguageSupported(tc->language()),
@@ -203,7 +203,7 @@ bool ToolChainManager::registerToolChain(ToolChain *tc)
 
     if (d->m_toolChains.contains(tc))
         return true;
-    for (const ToolChain *current : std::as_const(d->m_toolChains)) {
+    for (const Toolchain *current : std::as_const(d->m_toolChains)) {
         if (*tc == *current && !tc->isAutoDetected())
             return false;
         QTC_ASSERT(current->id() != tc->id(), return false);
@@ -214,7 +214,7 @@ bool ToolChainManager::registerToolChain(ToolChain *tc)
     return true;
 }
 
-void ToolChainManager::deregisterToolChain(ToolChain *tc)
+void ToolChainManager::deregisterToolChain(Toolchain *tc)
 {
     QTC_CHECK(d->m_loaded);
     if (!tc || !d->m_toolChains.contains(tc))

src/plugins/projectexplorer/toolchainmanager.h

@@ -40,16 +40,16 @@ public:
     ~ToolChainManager() override;
 
     static const Toolchains &toolchains();
-    static Toolchains toolchains(const ToolChain::Predicate &predicate);
+    static Toolchains toolchains(const Toolchain::Predicate &predicate);
 
-    static ToolChain *toolChain(const ToolChain::Predicate &predicate);
+    static Toolchain *toolChain(const Toolchain::Predicate &predicate);
-    static QList<ToolChain *> findToolChains(const Abi &abi);
+    static QList<Toolchain *> findToolChains(const Abi &abi);
-    static ToolChain *findToolChain(const QByteArray &id);
+    static Toolchain *findToolChain(const QByteArray &id);
 
     static bool isLoaded();
 
-    static bool registerToolChain(ToolChain *tc);
+    static bool registerToolChain(Toolchain *tc);
-    static void deregisterToolChain(ToolChain *tc);
+    static void deregisterToolChain(Toolchain *tc);
 
     static QList<Utils::Id> allLanguages();
     static bool registerLanguage(const Utils::Id &language, const QString &displayName);
@@ -68,11 +68,11 @@ public:
     void saveToolChains();
 
 signals:
-    void toolChainAdded(ProjectExplorer::ToolChain *);
+    void toolChainAdded(ProjectExplorer::Toolchain *);
     // Tool chain is still valid when this call happens!
-    void toolChainRemoved(ProjectExplorer::ToolChain *);
+    void toolChainRemoved(ProjectExplorer::Toolchain *);
     // Tool chain was updated.
-    void toolChainUpdated(ProjectExplorer::ToolChain *);
+    void toolChainUpdated(ProjectExplorer::Toolchain *);
     // Something changed.
     void toolChainsChanged();
     //
@@ -84,10 +84,10 @@ private:
     // Make sure the this is only called after all toolchain factories are registered!
     static void restoreToolChains();
 
-    static void notifyAboutUpdate(ToolChain *);
+    static void notifyAboutUpdate(Toolchain *);
 
     friend class ProjectExplorerPlugin; // for constructor
-    friend class ToolChain;
+    friend class Toolchain;
 };
 
 } // namespace ProjectExplorer

src/plugins/projectexplorer/toolchainoptionspage.cpp

@@ -48,7 +48,7 @@ namespace Internal {
 class ToolChainTreeItem : public TreeItem
 {
 public:
-    ToolChainTreeItem(QStackedWidget *parentWidget, ToolChain *tc, bool c) :
+    ToolChainTreeItem(QStackedWidget *parentWidget, Toolchain *tc, bool c) :
         toolChain(tc), changed(c), m_parentWidget(parentWidget)
     {}
 
@@ -100,7 +100,7 @@ public:
         return m_widget;
     }
 
-    ToolChain *toolChain;
+    Toolchain *toolChain;
     bool changed;
 
 private:
@@ -253,7 +253,7 @@ public:
         m_widgetStack = new QStackedWidget;
         m_container->setWidget(m_widgetStack);
 
-        for (ToolChain *tc : ToolChainManager::toolchains())
+        for (Toolchain *tc : ToolChainManager::toolchains())
             insertToolChain(tc);
 
         auto buttonLayout = new QVBoxLayout;
@@ -300,11 +300,11 @@ public:
     ToolChainTreeItem *currentTreeItem();
 
     void markForRemoval(ToolChainTreeItem *item);
-    ToolChainTreeItem *insertToolChain(ProjectExplorer::ToolChain *tc, bool changed = false); // Insert directly into model
+    ToolChainTreeItem *insertToolChain(ProjectExplorer::Toolchain *tc, bool changed = false); // Insert directly into model
-    void addToolChain(ProjectExplorer::ToolChain *);
+    void addToolChain(ProjectExplorer::Toolchain *);
-    void removeToolChain(ProjectExplorer::ToolChain *);
+    void removeToolChain(ProjectExplorer::Toolchain *);
 
-    StaticTreeItem *parentForToolChain(ToolChain *tc);
+    StaticTreeItem *parentForToolChain(Toolchain *tc);
     QAction *createAction(const QString &name, ToolchainFactory *factory, Utils::Id language)
     {
         auto action = new QAction(name, nullptr);
@@ -352,7 +352,7 @@ void ToolChainOptionsWidget::markForRemoval(ToolChainTreeItem *item)
     }
 }
 
-ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(ToolChain *tc, bool changed)
+ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(Toolchain *tc, bool changed)
 {
     StaticTreeItem *parent = parentForToolChain(tc);
     auto item = new ToolChainTreeItem(m_widgetStack, tc, changed);
@@ -361,7 +361,7 @@ ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(ToolChain *tc, bool c
     return item;
 }
 
-void ToolChainOptionsWidget::addToolChain(ToolChain *tc)
+void ToolChainOptionsWidget::addToolChain(Toolchain *tc)
 {
     if (Utils::eraseOne(m_toAddList, [tc](const ToolChainTreeItem *item) {
                         return item->toolChain == tc; })) {
@@ -373,7 +373,7 @@ void ToolChainOptionsWidget::addToolChain(ToolChain *tc)
     updateState();
 }
 
-void ToolChainOptionsWidget::removeToolChain(ToolChain *tc)
+void ToolChainOptionsWidget::removeToolChain(Toolchain *tc)
 {
     if (auto it = std::find_if(m_toRemoveList.begin(), m_toRemoveList.end(),
             [tc](const ToolChainTreeItem *item) { return item->toolChain == tc; });
@@ -392,7 +392,7 @@ void ToolChainOptionsWidget::removeToolChain(ToolChain *tc)
     updateState();
 }
 
-StaticTreeItem *ToolChainOptionsWidget::parentForToolChain(ToolChain *tc)
+StaticTreeItem *ToolChainOptionsWidget::parentForToolChain(Toolchain *tc)
 {
     QPair<StaticTreeItem *, StaticTreeItem *> nodes = m_languageMap.value(tc->language());
     return tc->isAutoDetected() ? nodes.first : nodes.second;
@@ -412,11 +412,11 @@ void ToolChainOptionsWidget::redetectToolchains()
             knownTcs << tcItem->toolChain;
     });
     Toolchains toAdd;
-    QSet<ToolChain *> toDelete;
+    QSet<Toolchain *> toDelete;
     ToolChainManager::resetBadToolchains();
     for (ToolchainFactory *f : ToolchainFactory::allToolchainFactories()) {
         const ToolchainDetector detector(knownTcs, DeviceManager::defaultDesktopDevice(), {});  // FIXME: Pass search paths
-        for (ToolChain * const tc : f->autoDetect(detector)) {
+        for (Toolchain * const tc : f->autoDetect(detector)) {
             if (knownTcs.contains(tc) || toDelete.contains(tc))
                 continue;
             const auto matchItem = [tc](const ToolChainTreeItem *item) {
@@ -434,7 +434,7 @@ void ToolChainOptionsWidget::redetectToolchains()
     }
     for (ToolChainTreeItem * const tcItem : std::as_const(itemsToRemove))
         markForRemoval(tcItem);
-    for (ToolChain * const newTc : std::as_const(toAdd))
+    for (Toolchain * const newTc : std::as_const(toAdd))
         m_toAddList.append(insertToolChain(newTc, true));
     qDeleteAll(toDelete);
 }
@@ -514,11 +514,11 @@ void ToolChainOptionsWidget::createToolChain(ToolchainFactory *factory, const Ut
     QTC_ASSERT(factory->canCreate(), return);
     QTC_ASSERT(language.isValid(), return);
 
-    ToolChain *tc = factory->create();
+    Toolchain *tc = factory->create();
     if (!tc)
         return;
 
-    tc->setDetection(ToolChain::ManualDetection);
+    tc->setDetection(Toolchain::ManualDetection);
     tc->setLanguage(language);
 
     auto item = insertToolChain(tc, true);
@@ -533,11 +533,11 @@ void ToolChainOptionsWidget::cloneToolChain()
     if (!current)
         return;
 
-    ToolChain *tc = current->toolChain->clone();
+    Toolchain *tc = current->toolChain->clone();
     if (!tc)
         return;
 
-    tc->setDetection(ToolChain::ManualDetection);
+    tc->setDetection(Toolchain::ManualDetection);
     tc->setDisplayName(Tr::tr("Clone of %1").arg(current->toolChain->displayName()));
 
     auto item = insertToolChain(tc, true);
@@ -551,7 +551,7 @@ void ToolChainOptionsWidget::updateState()
     bool canCopy = false;
     bool canDelete = false;
     if (ToolChainTreeItem *item = currentTreeItem()) {
-        ToolChain *tc = item->toolChain;
+        Toolchain *tc = item->toolChain;
         canCopy = tc->isValid();
         canDelete = !tc->isSdkProvided();
     }

src/plugins/projectexplorer/toolchainsettingsaccessor.cpp

@@ -68,14 +68,14 @@ static Toolchains autoDetectToolChains(const ToolchainDetector &detector)
     }
 
     // Remove invalid toolchains that might have sneaked in.
-    return Utils::filtered(result, [](const ToolChain *tc) { return tc->isValid(); });
+    return Utils::filtered(result, [](const Toolchain *tc) { return tc->isValid(); });
 }
 
 static Toolchains makeUniqueByEqual(const Toolchains &a)
 {
     Toolchains result;
-    for (ToolChain *tc : a) {
+    for (Toolchain *tc : a) {
-        if (!Utils::contains(result, [tc](ToolChain *rtc) { return *tc == *rtc; }))
+        if (!Utils::contains(result, [tc](Toolchain *rtc) { return *tc == *rtc; }))
             result.append(tc);
     }
     return result;
@@ -88,26 +88,26 @@ static Toolchains makeUniqueByPointerEqual(const Toolchains &a)
 
 static Toolchains subtractById(const Toolchains &a, const Toolchains &b)
 {
-    return Utils::filtered(a, [&b](ToolChain *atc) {
+    return Utils::filtered(a, [&b](Toolchain *atc) {
-                                  return !Utils::anyOf(b, Utils::equal(&ToolChain::id, atc->id()));
+                                  return !Utils::anyOf(b, Utils::equal(&Toolchain::id, atc->id()));
                               });
 }
 
-static bool containsByEqual(const Toolchains &a, const ToolChain *atc)
+static bool containsByEqual(const Toolchains &a, const Toolchain *atc)
 {
-    return Utils::anyOf(a, [atc](ToolChain *btc) { return *atc == *btc; });
+    return Utils::anyOf(a, [atc](Toolchain *btc) { return *atc == *btc; });
 }
 
 static Toolchains subtractByEqual(const Toolchains &a, const Toolchains &b)
 {
-    return Utils::filtered(a, [&b](ToolChain *atc) {
+    return Utils::filtered(a, [&b](Toolchain *atc) {
-                                  return !Utils::anyOf(b, [atc](ToolChain *btc) { return *atc == *btc; });
+                                  return !Utils::anyOf(b, [atc](Toolchain *btc) { return *atc == *btc; });
                               });
 }
 
 static Toolchains subtractByPointerEqual(const Toolchains &a, const Toolchains &b)
 {
-    return Utils::filtered(a, [&b](ToolChain *atc) { return !b.contains(atc); });
+    return Utils::filtered(a, [&b](Toolchain *atc) { return !b.contains(atc); });
 }
 
 static Toolchains stabilizeOrder(const Toolchains &toRegister,
@@ -121,7 +121,7 @@ static Toolchains stabilizeOrder(const Toolchains &toRegister,
     for (int i = 0; i < userFileTcs.count(); ++i) {
         const QByteArray userId = userFileTcs.at(i)->id();
         const int handlePos = Utils::indexOf(toHandle,
-                                             [&userId](const ToolChain *htc) { return htc->id() == userId; });
+                                             [&userId](const Toolchain *htc) { return htc->id() == userId; });
         if (handlePos < 0)
             continue;
 
@@ -140,7 +140,7 @@ static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
     Toolchains manualUserFileTcs;
     Toolchains autodetectedUserFileTcs;
     std::tie(autodetectedUserFileTcs, manualUserFileTcs)
-            = Utils::partition(uniqueUserFileTcs, &ToolChain::isAutoDetected);
+            = Utils::partition(uniqueUserFileTcs, &Toolchain::isAutoDetected);
     const Toolchains autodetectedUserTcs = subtractById(autodetectedUserFileTcs, systemFileTcs);
 
     // Calculate a set of Tcs that were detected before (and saved to userFile) and that
@@ -149,14 +149,14 @@ static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
     Toolchains notRedetectedUserTcs;
     std::tie(redetectedUserTcs, notRedetectedUserTcs)
             = Utils::partition(autodetectedUserTcs,
-                               [&autodetectedTcs](ToolChain *tc) { return containsByEqual(autodetectedTcs, tc); });
+                               [&autodetectedTcs](Toolchain *tc) { return containsByEqual(autodetectedTcs, tc); });
 
     // Remove redetected tcs from autodetectedTcs:
     const Toolchains newlyAutodetectedTcs
             = subtractByEqual(autodetectedTcs, redetectedUserTcs);
 
     const Toolchains notRedetectedButValidUserTcs
-            = Utils::filtered(notRedetectedUserTcs, &ToolChain::isValid);
+            = Utils::filtered(notRedetectedUserTcs, &Toolchain::isValid);
 
     ToolChainOperations result;
     result.toDemote = notRedetectedButValidUserTcs;
@@ -188,15 +188,15 @@ Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
     // read all tool chains from SDK
     const Toolchains systemFileTcs = toolChains(
         restoreSettings(Core::ICore::installerResourcePath(TOOLCHAIN_FILENAME), parent));
-    for (ToolChain * const systemTc : systemFileTcs)
+    for (Toolchain * const systemTc : systemFileTcs)
-        systemTc->setDetection(ToolChain::AutoDetectionFromSdk);
+        systemTc->setDetection(Toolchain::AutoDetectionFromSdk);
 
     // read all tool chains from user file.
     const Toolchains userFileTcs = toolChains(restoreSettings(parent));
 
     // Autodetect: Pass autodetected toolchains from user file so the information can be reused:
     const Toolchains autodetectedUserFileTcs
-            = Utils::filtered(userFileTcs, &ToolChain::isAutoDetected);
+            = Utils::filtered(userFileTcs, &Toolchain::isAutoDetected);
 
     // Autodect from system paths on the desktop device.
     // The restriction is intentional to keep startup and automatic validation a limited effort
@@ -207,10 +207,10 @@ Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
     const ToolChainOperations ops = mergeToolChainLists(systemFileTcs, userFileTcs, autodetectedTcs);
 
     // Process ops:
-    for (ToolChain *tc : ops.toDemote) {
+    for (Toolchain *tc : ops.toDemote) {
         // FIXME: We currently only demote local toolchains, as they are not redetected.
         if (tc->detectionSource().isEmpty())
-            tc->setDetection(ToolChain::ManualDetection);
+            tc->setDetection(Toolchain::ManualDetection);
     }
 
     qDeleteAll(ops.toDelete);
@@ -223,7 +223,7 @@ void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWi
     Store data;
 
     int count = 0;
-    for (const ToolChain *tc : toolchains) {
+    for (const Toolchain *tc : toolchains) {
         if (!tc || (!tc->isValid() && tc->isAutoDetected()))
             continue;
         Store tmp;
@@ -258,7 +258,7 @@ Toolchains ToolChainSettingsAccessor::toolChains(const Store &data) const
         if (tcType.isValid()) {
             for (ToolchainFactory *f : factories) {
                 if (f->supportedToolChainType() == tcType) {
-                    if (ToolChain *tc = f->restore(tcMap)) {
+                    if (Toolchain *tc = f->restore(tcMap)) {
                         result.append(tc);
                         restored = true;
                         break;
@@ -293,11 +293,11 @@ const char TestTokenKey[] = "TestTokenKey";
 const char TestToolChainType[] = "TestToolChainType";
 
 
-class TTC : public ToolChain
+class TTC : public Toolchain
 {
 public:
     TTC(const QByteArray &t = {}, bool v = true) :
-        ToolChain(TestToolChainType),
+        Toolchain(TestToolChainType),
         token(t),
         m_valid(v)
     {
@@ -320,21 +320,21 @@ public:
     FilePath makeCommand(const Environment &) const override { return "make"; }
     QList<OutputLineParser *> createOutputParsers() const override { return {}; }
     std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() override { return nullptr; }
-    bool operator ==(const ToolChain &other) const override {
+    bool operator ==(const Toolchain &other) const override {
-        if (!ToolChain::operator==(other))
+        if (!Toolchain::operator==(other))
             return false;
         return static_cast<const TTC *>(&other)->token == token;
     }
 
     void fromMap(const Store &data) final
     {
-        ToolChain::fromMap(data);
+        Toolchain::fromMap(data);
         token = data.value(TestTokenKey).toByteArray();
     }
 
     void toMap(Store &data) const final
     {
-        ToolChain::toMap(data);
+        Toolchain::toMap(data);
         data[TestTokenKey] = token;
     }
 
@@ -350,7 +350,7 @@ QList<TTC *> TTC::m_toolChains;
 
 } // namespace ProjectExplorer
 
-Q_DECLARE_METATYPE(ProjectExplorer::ToolChain *)
+Q_DECLARE_METATYPE(ProjectExplorer::Toolchain *)
 
 namespace ProjectExplorer {
 
@@ -374,43 +374,43 @@ void ProjectExplorerPlugin::testToolChainMerging_data()
     QTest::addColumn<Toolchains>("toRegister");
 
     TTC *system1 = nullptr;
-    ToolChain *system1c = nullptr;
+    Toolchain *system1c = nullptr;
     TTC *system2 = nullptr;
     TTC *system3i = nullptr;
     TTC *user1 = nullptr;
-    ToolChain *user1c = nullptr;
+    Toolchain *user1c = nullptr;
     TTC *user3i = nullptr;
     TTC *user2 = nullptr;
     TTC *auto1 = nullptr;
-    ToolChain *auto1c = nullptr;
+    Toolchain *auto1c = nullptr;
     TTC *auto1_2 = nullptr;
     TTC *auto2 = nullptr;
     TTC *auto3i = nullptr;
 
     if (!TTC::hasToolChains()) {
         system1 = new TTC("system1");
-        system1->setDetection(ToolChain::AutoDetection);
+        system1->setDetection(Toolchain::AutoDetection);
         system1c = system1->clone(); Q_UNUSED(system1c)
         system2 = new TTC("system2");
-        system2->setDetection(ToolChain::AutoDetection);
+        system2->setDetection(Toolchain::AutoDetection);
         system3i = new TTC("system3", false);
-        system3i->setDetection(ToolChain::AutoDetection);
+        system3i->setDetection(Toolchain::AutoDetection);
         user1 = new TTC("user1");
-        user1->setDetection(ToolChain::ManualDetection);
+        user1->setDetection(Toolchain::ManualDetection);
         user1c = user1->clone(); Q_UNUSED(user1c)
         user2 = new TTC("user2");
-        user2->setDetection(ToolChain::ManualDetection);
+        user2->setDetection(Toolchain::ManualDetection);
         user3i = new TTC("user3", false);
-        user3i->setDetection(ToolChain::ManualDetection);
+        user3i->setDetection(Toolchain::ManualDetection);
         auto1 = new TTC("auto1");
-        auto1->setDetection(ToolChain::AutoDetection);
+        auto1->setDetection(Toolchain::AutoDetection);
         auto1c = auto1->clone();
         auto1_2 = new TTC("auto1");
-        auto1_2->setDetection(ToolChain::AutoDetection);
+        auto1_2->setDetection(Toolchain::AutoDetection);
         auto2 = new TTC("auto2");
-        auto2->setDetection(ToolChain::AutoDetection);
+        auto2->setDetection(Toolchain::AutoDetection);
         auto3i = new TTC("auto3", false);
-        auto3i->setDetection(ToolChain::AutoDetection);
+        auto3i->setDetection(Toolchain::AutoDetection);
     }
 
     QTest::newRow("no toolchains")
@@ -468,18 +468,18 @@ void ProjectExplorerPlugin::testToolChainMerging()
 
     Internal::ToolChainOperations ops = Internal::mergeToolChainLists(system, user, autodetect);
 
-    QSet<ToolChain *> expToRegister = Utils::toSet(toRegister);
+    QSet<Toolchain *> expToRegister = Utils::toSet(toRegister);
-    QSet<ToolChain *> expToDemote = Utils::toSet(toDemote);
+    QSet<Toolchain *> expToDemote = Utils::toSet(toDemote);
 
-    QSet<ToolChain *> actToRegister = Utils::toSet(ops.toRegister);
+    QSet<Toolchain *> actToRegister = Utils::toSet(ops.toRegister);
-    QSet<ToolChain *> actToDemote = Utils::toSet(ops.toDemote);
+    QSet<Toolchain *> actToDemote = Utils::toSet(ops.toDemote);
-    QSet<ToolChain *> actToDelete = Utils::toSet(ops.toDelete);
+    QSet<Toolchain *> actToDelete = Utils::toSet(ops.toDelete);
 
     QCOMPARE(actToRegister.count(), ops.toRegister.count()); // no dups!
     QCOMPARE(actToDemote.count(), ops.toDemote.count()); // no dups!
     QCOMPARE(actToDelete.count(), ops.toDelete.count()); // no dups!
 
-    QSet<ToolChain *> tmp = actToRegister;
+    QSet<Toolchain *> tmp = actToRegister;
     tmp.intersect(actToDemote);
     QCOMPARE(tmp, actToDemote); // all toDemote are in toRegister
 

src/plugins/projectexplorer/toolchainsettingsaccessor.h

@@ -9,7 +9,7 @@
 
 namespace ProjectExplorer {
 
-class ToolChain;
+class Toolchain;
 
 namespace Internal {
 
@@ -18,12 +18,12 @@ class ToolChainSettingsAccessor : public Utils::UpgradingSettingsAccessor
 public:
     ToolChainSettingsAccessor();
 
-    QList<ToolChain *> restoreToolChains(QWidget *parent) const;
+    QList<Toolchain *> restoreToolChains(QWidget *parent) const;
 
-    void saveToolChains(const QList<ToolChain *> &toolchains, QWidget *parent);
+    void saveToolChains(const QList<Toolchain *> &toolchains, QWidget *parent);
 
 private:
-    QList<ToolChain *> toolChains(const Utils::Store &data) const;
+    QList<Toolchain *> toolChains(const Utils::Store &data) const;
 };
 
 } // namespace Internal

src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp

@@ -102,7 +102,7 @@ static QString targetPlatform(const ProjectExplorer::Abi &abi, const ProjectExpl
     return QString();
 }
 
-static QStringList toolchainList(const ProjectExplorer::ToolChain *tc)
+static QStringList toolchainList(const ProjectExplorer::Toolchain *tc)
 {
     const Utils::Id type = tc->typeId();
     if (type == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID
@@ -174,14 +174,14 @@ static QString architecture(const ProjectExplorer::Abi &targetAbi)
     return QString();
 }
 
-static bool isMultiTargetingToolchain(const ProjectExplorer::ToolChain *tc)
+static bool isMultiTargetingToolchain(const ProjectExplorer::Toolchain *tc)
 {
     // Clang and QCC are multi-targeting compilers; others (GCC/MinGW, MSVC, ICC) are not
     return tc->targetAbi().os() == ProjectExplorer::Abi::QnxOS
             || tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
 }
 
-static QStringList architectures(const ProjectExplorer::ToolChain *tc)
+static QStringList architectures(const ProjectExplorer::Toolchain *tc)
 {
     // For platforms which can have builds for multiple architectures in a single configuration
     // (Darwin, Android), regardless of whether the toolchain is multi-targeting or not (Clang
@@ -238,12 +238,12 @@ 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;
 
-    ToolChain *mainTc = tcCxx ? tcCxx : tcC;
+    Toolchain *mainTc = tcCxx ? tcCxx : tcC;
 
     Abi targetAbi = mainTc->targetAbi();
 

src/plugins/qbsprojectmanager/qbsproject.cpp

@@ -827,8 +827,8 @@ static void getExpandedCompilerFlags(QStringList &cFlags, QStringList &cxxFlags,
 static RawProjectPart generateProjectPart(
         const QJsonObject &product,
         const QJsonObject &group,
-        const std::shared_ptr<const ToolChain> &cToolChain,
+        const std::shared_ptr<const Toolchain> &cToolChain,
-        const std::shared_ptr<const ToolChain> &cxxToolChain,
+        const std::shared_ptr<const Toolchain> &cxxToolChain,
         QtMajorVersion qtVersion,
         QString cPch,
         QString cxxPch,
@@ -952,8 +952,8 @@ static RawProjectPart generateProjectPart(
 
 static RawProjectParts generateProjectParts(
         const QJsonObject &projectData,
-        const std::shared_ptr<const ToolChain> &cToolChain,
+        const std::shared_ptr<const Toolchain> &cToolChain,
-        const std::shared_ptr<const ToolChain> &cxxToolChain,
+        const std::shared_ptr<const Toolchain> &cxxToolChain,
         QtMajorVersion qtVersion
         )
 {
@@ -1005,9 +1005,9 @@ 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);
-    const auto cxxToolchain = std::shared_ptr<ToolChain>(kitInfo.cxxToolChain
+    const auto cxxToolchain = std::shared_ptr<Toolchain>(kitInfo.cxxToolChain
             ? kitInfo.cxxToolChain->clone() : nullptr);
 
     m_cppCodeModelUpdater->update({project(), kitInfo, activeParseEnvironment(), {},

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;

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/qmakebuildconfiguration.h

@@ -106,7 +106,7 @@ private:
     void restrictNextBuild(const ProjectExplorer::RunConfiguration *rc) override;
 
     void kitChanged();
-    void toolChainUpdated(ProjectExplorer::ToolChain *tc);
+    void toolChainUpdated(ProjectExplorer::Toolchain *tc);
     void qtVersionsChanged(const QList<int> &, const QList<int> &, const QList<int> &changed);
     void updateProblemLabel();
 

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

@@ -237,7 +237,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
             this, &QmakeBuildSystem::scheduleUpdateAllNowOrLater);
 
     connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
-            this, [this](ToolChain *tc) {
+            this, [this](Toolchain *tc) {
         if (ToolChainKitAspect::cxxToolChain(kit()) == tc)
             scheduleUpdateAllNowOrLater();
     });
@@ -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 {};
 
@@ -1423,7 +1423,7 @@ static FilePath getFullPathOf(const QmakeProFile *pro, Variable variable,
     return bc->environment().searchInPath(exe);
 }
 
-void QmakeBuildSystem::testToolChain(ToolChain *tc, const FilePath &path) const
+void QmakeBuildSystem::testToolChain(Toolchain *tc, const FilePath &path) const
 {
     if (!tc || path.isEmpty())
         return;
@@ -1474,7 +1474,7 @@ void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
 
 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/qmakeproject.h

@@ -115,7 +115,7 @@ public:
     void startAsyncTimer(QmakeProFile::AsyncUpdateDelay delay);
 
     void warnOnToolChainMismatch(const QmakeProFile *pro) const;
-    void testToolChain(ProjectExplorer::ToolChain *tc, const Utils::FilePath &path) const;
+    void testToolChain(ProjectExplorer::Toolchain *tc, const Utils::FilePath &path) const;
 
     QString deviceRoot() const;
 

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;
@@ -217,17 +217,17 @@ static const Toolchains preferredToolChains(QtVersion *qtVersion, const QString
 
     const Toolchains toolchains = ToolChainManager::toolchains();
     const Abis qtAbis = qtVersion->qtAbis();
-    const auto matcher = [&](const ToolChain *tc) {
+    const auto matcher = [&](const Toolchain *tc) {
         return qtAbis.contains(tc->targetAbi()) && tc->suggestedMkspecList().contains(spec);
     };
-    ToolChain * const cxxToolchain = findOrDefault(toolchains, [matcher](const ToolChain *tc) {
+    Toolchain * const cxxToolchain = findOrDefault(toolchains, [matcher](const Toolchain *tc) {
         return tc->language() == ProjectExplorer::Constants::CXX_LANGUAGE_ID && matcher(tc);
     });
-    ToolChain * const cToolchain = findOrDefault(toolchains, [matcher](const ToolChain *tc) {
+    Toolchain * const cToolchain = findOrDefault(toolchains, [matcher](const Toolchain *tc) {
         return tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID && matcher(tc);
     });
     Toolchains chosenToolchains;
-    for (ToolChain * const tc : {cxxToolchain, cToolchain}) {
+    for (Toolchain * const tc : {cxxToolchain, cToolchain}) {
         if (tc)
             chosenToolchains << tc;
     };
@@ -240,7 +240,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))
+        for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec))
             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

@@ -99,7 +99,7 @@ public:
 
     bool isActive() const
     {
-        const bool hasToolChain = ToolChainManager::toolChain(Utils::equal(&ToolChain::compilerCommand,
+        const bool hasToolChain = ToolChainManager::toolChain(Utils::equal(&Toolchain::compilerCommand,
                                                                            m_qccCompiler));
         const bool hasDebugger = Utils::contains(DebuggerItemManager::debuggers(), [this](const DebuggerItem &di) {
             return findTargetByDebuggerPath(di.command());
@@ -169,7 +169,7 @@ void QnxConfiguration::deactivate()
     QTC_ASSERT(isActive(), return);
 
     const Toolchains toolChainsToRemove =
-        ToolChainManager::toolchains(Utils::equal(&ToolChain::compilerCommand, m_qccCompiler));
+        ToolChainManager::toolchains(Utils::equal(&Toolchain::compilerCommand, m_qccCompiler));
 
     QList<DebuggerItem> debuggersToRemove;
     const QList<DebuggerItem> debuggerItems = DebuggerItemManager::debuggers();
@@ -187,7 +187,7 @@ void QnxConfiguration::deactivate()
         }
     }
 
-    for (ToolChain *tc : toolChainsToRemove)
+    for (Toolchain *tc : toolChainsToRemove)
         ToolChainManager::deregisterToolChain(tc);
 
     for (const DebuggerItem &debuggerItem : std::as_const(debuggersToRemove))
@@ -232,7 +232,7 @@ Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
     for (const Id language : {ProjectExplorer::Constants::C_LANGUAGE_ID,
                               ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
         auto toolChain = new QnxToolChain;
-        toolChain->setDetection(ToolChain::ManualDetection);
+        toolChain->setDetection(Toolchain::ManualDetection);
         toolChain->setLanguage(language);
         toolChain->setTargetAbi(target.m_abi);
         toolChain->setDisplayName(Tr::tr("QCC for %1 (%2)")
@@ -755,13 +755,13 @@ QnxSettingsPage::QnxSettingsPage(QObject *guard)
             this, &QnxSettingsPage::restoreConfigurations);
 }
 
-QList<ToolChain *> autoDetectHelper(const QList<ToolChain *> &alreadyKnown)
+QList<Toolchain *> autoDetectHelper(const QList<Toolchain *> &alreadyKnown)
 {
-    QList<ToolChain *> result;
+    QList<Toolchain *> result;
     for (const QnxConfiguration &config : std::as_const(m_configurations)) {
         config.ensureContents();
         for (const QnxTarget &target : std::as_const(config.m_targets)) {
-            result +=  Utils::filtered(alreadyKnown, [config, target](ToolChain *tc) {
+            result +=  Utils::filtered(alreadyKnown, [config, target](Toolchain *tc) {
                 return tc->typeId() == Constants::QNX_TOOLCHAIN_ID
                        && tc->targetAbi() == target.m_abi
                        && tc->compilerCommand() == config.m_qccCompiler;

src/plugins/qnx/qnxsettingspage.h

@@ -5,12 +5,12 @@
 
 #include <coreplugin/dialogs/ioptionspage.h>
 
-namespace ProjectExplorer { class ToolChain; }
+namespace ProjectExplorer { class Toolchain; }
 
 namespace Qnx::Internal {
 
-QList<ProjectExplorer::ToolChain *> autoDetectHelper(
+QList<ProjectExplorer::Toolchain *> autoDetectHelper(
-    const QList<ProjectExplorer::ToolChain *> &alreadyKnown);
+    const QList<ProjectExplorer::Toolchain *> &alreadyKnown);
 
 void setupQnxSettingsPage(QObject *guard);
 

src/plugins/qnx/qnxtoolchain.cpp

@@ -152,7 +152,7 @@ GccToolChain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
     return GccToolChain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"};
 }
 
-bool QnxToolChain::operator ==(const ToolChain &other) const
+bool QnxToolChain::operator ==(const Toolchain &other) const
 {
     if (!GccToolChain::operator ==(other))
         return false;

src/plugins/qnx/qnxtoolchain.h

@@ -20,7 +20,7 @@ public:
     Utils::FilePathAspect sdpPath{this};
     Utils::StringAspect cpuDir{this};
 
-    bool operator ==(const ToolChain &) const override;
+    bool operator ==(const Toolchain &) const override;
 
 protected:
     DetectedAbisResult detectSupportedAbis() const override;

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;
@@ -1291,7 +1291,7 @@ QString QtVersion::mkspec() const
     return d->m_mkspec.toFSPathString();
 }
 
-QString QtVersion::mkspecFor(ToolChain *tc) const
+QString QtVersion::mkspecFor(Toolchain *tc) const
 {
     QString versionSpec = mkspec();
     if (!tc)
@@ -1866,10 +1866,10 @@ bool QtVersionPrivate::queryQMakeVariables(const FilePath &binary, const Environ
         // This is required to make non-static qmakes work on windows where every tool chain
         // tries to be incompatible with any other.
         const Abis abiList = Abi::abisOfBinary(binary);
-        const Toolchains tcList = ToolChainManager::toolchains([&abiList](const ToolChain *t) {
+        const Toolchains tcList = ToolChainManager::toolchains([&abiList](const Toolchain *t) {
             return abiList.contains(t->targetAbi());
         });
-        for (ToolChain *tc : tcList) {
+        for (Toolchain *tc : tcList) {
             Environment realEnv = env;
             tc->addToEnvironment(realEnv);
             output = runQmakeQuery(binary, realEnv, error);

src/plugins/qtsupport/baseqtversion.h

@@ -28,7 +28,7 @@ class FileInProjectFinder;
 
 namespace ProjectExplorer {
 class Kit;
-class ToolChain;
+class Toolchain;
 class Target;
 } // ProjectExplorer
 
@@ -114,7 +114,7 @@ public:
 
     /// @returns the name of the mkspec
     QString mkspec() const;
-    QString mkspecFor(ProjectExplorer::ToolChain *tc) const;
+    QString mkspecFor(ProjectExplorer::Toolchain *tc) const;
     /// @returns the full path to the default directory
     /// specifally not the directory the symlink/ORIGINAL_QMAKESPEC points to
     Utils::FilePath mkspecPath() const;

src/plugins/qtsupport/qtkitaspect.cpp

@@ -230,7 +230,7 @@ void QtKitAspectFactory::fix(Kit *k)
         return;
 
     const QString spec = version->mkspec();
-    Toolchains possibleTcs = ToolChainManager::toolchains([version](const ToolChain *t) {
+    Toolchains possibleTcs = ToolChainManager::toolchains([version](const Toolchain *t) {
         if (!t->isValid() || t->language() != ProjectExplorer::Constants::CXX_LANGUAGE_ID)
             return false;
         return Utils::anyOf(version->qtAbis(), [t](const Abi &qtAbi) {
@@ -244,7 +244,7 @@ void QtKitAspectFactory::fix(Kit *k)
         // TODO: We should probably prefer the compiler with the highest version number instead,
         //       but this information is currently not exposed by the ToolChain class.
         const FilePaths envPathVar = Environment::systemEnvironment().path();
-        sort(possibleTcs, [version, &envPathVar](const ToolChain *tc1, const ToolChain *tc2) {
+        sort(possibleTcs, [version, &envPathVar](const Toolchain *tc1, const Toolchain *tc2) {
             const QVector<Abi> &qtAbis = version->qtAbis();
             const bool tc1ExactMatch = qtAbis.contains(tc1->targetAbi());
             const bool tc2ExactMatch = qtAbis.contains(tc2->targetAbi());
@@ -278,11 +278,11 @@ void QtKitAspectFactory::fix(Kit *k)
         });
 
         // TODO: Why is this not done during sorting?
-        const Toolchains goodTcs = Utils::filtered(possibleTcs, [&spec](const ToolChain *t) {
+        const Toolchains goodTcs = Utils::filtered(possibleTcs, [&spec](const Toolchain *t) {
             return t->suggestedMkspecList().contains(spec);
         });
 
-        if (ToolChain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
+        if (Toolchain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
             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))

src/plugins/qtsupport/qtoptionspage.cpp

@@ -190,7 +190,7 @@ private:
         QIcon icon;
     };
     ValidityInfo validInformation(const QtVersion *version);
-    QList<ProjectExplorer::ToolChain*> toolChains(const QtVersion *version);
+    QList<ProjectExplorer::Toolchain*> toolChains(const QtVersion *version);
     QByteArray defaultToolChainId(const QtVersion *version);
 
     bool isNameUnique(const QtVersion *version);
@@ -487,7 +487,7 @@ QtOptionsPageWidget::ValidityInfo QtOptionsPageWidget::validInformation(const Qt
     const Abis qtAbis = version->qtAbis();
 
     for (const Abi &abi : qtAbis) {
-        const auto abiCompatePred = [&abi] (const ToolChain *tc)
+        const auto abiCompatePred = [&abi] (const Toolchain *tc)
         {
             return Utils::contains(tc->supportedAbis(),
                                    [&abi](const Abi &sabi) { return sabi.isCompatibleWith(abi); });
@@ -530,9 +530,9 @@ QtOptionsPageWidget::ValidityInfo QtOptionsPageWidget::validInformation(const Qt
     return info;
 }
 
-QList<ToolChain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
+QList<Toolchain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
 {
-    QList<ToolChain*> toolChains;
+    QList<Toolchain*> toolChains;
     if (!version)
         return toolChains;
 
@@ -540,7 +540,7 @@ QList<ToolChain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
     const Abis abis = version->qtAbis();
     for (const Abi &a : abis) {
         const Toolchains tcList = ToolChainManager::findToolChains(a);
-        for (ToolChain *tc : tcList) {
+        for (Toolchain *tc : tcList) {
             if (Utils::insert(ids, tc->id()))
                 toolChains.append(tc);
         }
@@ -551,7 +551,7 @@ QList<ToolChain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
 
 QByteArray QtOptionsPageWidget::defaultToolChainId(const QtVersion *version)
 {
-    QList<ToolChain*> possibleToolChains = toolChains(version);
+    QList<Toolchain*> possibleToolChains = toolChains(version);
     if (!possibleToolChains.isEmpty())
         return possibleToolChains.first()->id();
     return QByteArray();

src/plugins/webassembly/webassemblytoolchain.cpp

@@ -48,7 +48,7 @@ static void addRegisteredMinGWToEnvironment(Environment &env)
         return;
     }
 
-    const ToolChain *toolChain = ToolChainManager::toolChain([](const ToolChain *t){
+    const Toolchain *toolChain = ToolChainManager::toolChain([](const Toolchain *t){
         return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID;
     });
     if (toolChain)
@@ -121,7 +121,7 @@ static Toolchains doAutoDetect(const ToolchainDetector &detector)
                             ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
         auto toolChain = new WebAssemblyToolChain;
         toolChain->setLanguage(languageId);
-        toolChain->setDetection(ToolChain::AutoDetection);
+        toolChain->setDetection(Toolchain::AutoDetection);
         const bool cLanguage = languageId == ProjectExplorer::Constants::C_LANGUAGE_ID;
         const QString script = QLatin1String(cLanguage ? "emcc" : "em++")
                 + QLatin1String(sdk.osType() == OsTypeWindows ? ".bat" : "");
@@ -140,8 +140,8 @@ static Toolchains doAutoDetect(const ToolchainDetector &detector)
 void WebAssemblyToolChain::registerToolChains()
 {
     // Remove old toolchains
-    for (ToolChain *tc : ToolChainManager::findToolChains(toolChainAbi())) {
+    for (Toolchain *tc : ToolChainManager::findToolChains(toolChainAbi())) {
-         if (tc->detection() != ToolChain::AutoDetection)
+         if (tc->detection() != Toolchain::AutoDetection)
              continue;
          ToolChainManager::deregisterToolChain(tc);
     };