ProjectExplorer: Rename Tool{C,c}hainKitAspect

Change-Id: I74460b6402ab00f972c208023f03fac617982a11
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>

51 files changed, 167 insertions, 167 deletions

diff --git a/src/plugins/android/androidconfigurations.cpp b/src/plugins/android/androidconfigurations.cpp
index 0016cd3f6b..8cf6d186a1 100644
--- a/src/plugins/android/androidconfigurations.cpp
+++ b/src/plugins/android/androidconfigurations.cpp
@@ -1387,9 +1387,9 @@ void AndroidConfigurations::updateAutomaticKitList()
                 if (qt != QtKitAspect::qtVersion(b))
                     return false;
                 return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
-                                      ToolChainKitAspect::cxxToolChain(b))
+                                      ToolchainKitAspect::cxxToolChain(b))
                         && matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
-                                          ToolChainKitAspect::cToolChain(b));
+                                          ToolchainKitAspect::cToolChain(b));
             });
 
             const auto initializeKit = [allLanguages, tc, qt](Kit *k) {
@@ -1397,7 +1397,7 @@ void AndroidConfigurations::updateAutomaticKitList()
                 k->setAutoDetectionSource("AndroidConfiguration");
                 DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE);
                 for (Toolchain *tc : allLanguages)
-                    ToolChainKitAspect::setToolChain(k, tc);
+                    ToolchainKitAspect::setToolChain(k, tc);
                 QtKitAspect::setQtVersion(k, qt);
                 QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis();
                 Debugger::DebuggerKitAspect::setDebugger(k, findOrRegisterDebugger(tc, abis));
diff --git a/src/plugins/android/androidmanager.cpp b/src/plugins/android/androidmanager.cpp
index aa8e3fe43a..cf665d2d15 100644
--- a/src/plugins/android/androidmanager.cpp
+++ b/src/plugins/android/androidmanager.cpp
@@ -183,7 +183,7 @@ QJsonObject deploymentSettings(const Target *target)
     if (!qt)
         return {};
 
-    auto tc = ToolChainKitAspect::cxxToolChain(target->kit());
+    auto tc = ToolchainKitAspect::cxxToolChain(target->kit());
     if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_TYPEID)
         return {};
     QJsonObject settings;
diff --git a/src/plugins/android/androidpackageinstallationstep.cpp b/src/plugins/android/androidpackageinstallationstep.cpp
index a67c4c425f..fecc3db998 100644
--- a/src/plugins/android/androidpackageinstallationstep.cpp
+++ b/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);
diff --git a/src/plugins/autotest/autotestunittests.cpp b/src/plugins/autotest/autotestunittests.cpp
index 7f3a55d577..e016afbbb8 100644
--- a/src/plugins/autotest/autotestunittests.cpp
+++ b/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.");
 
diff --git a/src/plugins/autotest/loadprojectscenario.cpp b/src/plugins/autotest/loadprojectscenario.cpp
index 0b18eaab51..50d62d22b0 100644
--- a/src/plugins/autotest/loadprojectscenario.cpp
+++ b/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;
diff --git a/src/plugins/clangtools/clangtool.cpp b/src/plugins/clangtools/clangtool.cpp
index 7d9d13b4c6..27cc59bb60 100644
--- a/src/plugins/clangtools/clangtool.cpp
+++ b/src/plugins/clangtools/clangtool.cpp
@@ -1034,7 +1034,7 @@ static bool canAnalyzeProject(Project *project)
                                              || project->projectLanguages().contains(cxx);
         return projectSupportsLanguage
                && CppModelManager::projectInfo(project)
-               && ToolChainKitAspect::cxxToolChain(target->kit());
+               && ToolchainKitAspect::cxxToolChain(target->kit());
     }
     return false;
 }
diff --git a/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp b/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
index d08a68633b..fdadc30451 100644
--- a/src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
+++ b/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()) {
diff --git a/src/plugins/clangtools/clangtoolsunittests.cpp b/src/plugins/clangtools/clangtoolsunittests.cpp
index 086afe118f..b985f0503a 100644
--- a/src/plugins/clangtools/clangtoolsunittests.cpp
+++ b/src/plugins/clangtools/clangtoolsunittests.cpp
@@ -50,7 +50,7 @@ void ClangToolsUnitTests::initTestCase()
     if (!m_kit)
         QSKIP("This test requires at least one valid kit with a valid Qt");
 
-    const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
+    const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 
@@ -87,7 +87,7 @@ void ClangToolsUnitTests::testProject()
     QFETCH(int, expectedDiagCountClazy);
     QFETCH(ClangDiagnosticConfig, diagnosticConfig);
     if (projectFilePath.contains("mingw")) {
-        const auto toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
+        const auto toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
         if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID)
             QSKIP("This test is mingw specific, does not run for other toolchains");
     }
diff --git a/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp b/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
index 27b9c6348d..a9634eccf0 100644
--- a/src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
+++ b/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);
diff --git a/src/plugins/cmakeprojectmanager/cmakebuildstep.cpp b/src/plugins/cmakeprojectmanager/cmakebuildstep.cpp
index e2c3e963f6..8bd3b37849 100644
--- a/src/plugins/cmakeprojectmanager/cmakebuildstep.cpp
+++ b/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;
diff --git a/src/plugins/cmakeprojectmanager/cmakekitaspect.cpp b/src/plugins/cmakeprojectmanager/cmakekitaspect.cpp
index bca89be9b1..9a9e09c65c 100644
--- a/src/plugins/cmakeprojectmanager/cmakekitaspect.cpp
+++ b/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 tcCxx = ToolChainKitAspect::cxxToolChain(k);
+    const Toolchain *const tcC = ToolchainKitAspect::cToolChain(k);
+    const Toolchain *const tcCxx = ToolchainKitAspect::cxxToolChain(k);
     const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
 
     const bool isQt4 = version && version->qtVersion() < QVersionNumber(5, 0, 0);
diff --git a/src/plugins/cmakeprojectmanager/cmakeproject.cpp b/src/plugins/cmakeprojectmanager/cmakeproject.cpp
index 084925c8fc..3a79e4a376 100644
--- a/src/plugins/cmakeprojectmanager/cmakeproject.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeproject.cpp
@@ -58,7 +58,7 @@ Tasks CMakeProject::projectIssues(const Kit *k) const
 
     if (!CMakeKitAspect::cmakeTool(k))
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No cmake tool set.")));
-    if (ToolChainKitAspect::toolChains(k).isEmpty())
+    if (ToolchainKitAspect::toolChains(k).isEmpty())
         result.append(createProjectTask(Task::TaskType::Warning, Tr::tr("No compilers set in kit.")));
 
     result.append(m_issues);
diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
index de05b51d2a..c38dc44054 100644
--- a/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
@@ -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;
             }
@@ -1001,10 +1001,10 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
 
             if (tcd.areTemporary) {
                 for (Toolchain *tc : tcd.tcs)
-                    addTemporaryData(ToolChainKitAspect::id(), tc->id(), k);
+                    addTemporaryData(ToolchainKitAspect::id(), tc->id(), k);
             }
 
-            ToolChainKitAspect::setToolChain(k, tcd.tcs.at(0));
+            ToolchainKitAspect::setToolChain(k, tcd.tcs.at(0));
         }
 
         if (!data->cmakePresetDisplayname.isEmpty()) {
diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp
index 886caa47f5..2637d05d63 100644
--- a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp
@@ -407,8 +407,8 @@ void CMakeManager::buildFile(Node *node)
             return extension;
 
         const auto toolchain = ProjectFile::isCxx(sourceKind)
-                                   ? ToolChainKitAspect::cxxToolChain(target->kit())
-                                   : ToolChainKitAspect::cToolChain(target->kit());
+                                   ? ToolchainKitAspect::cxxToolChain(target->kit())
+                                   : ToolchainKitAspect::cToolChain(target->kit());
         using namespace ProjectExplorer::Constants;
         static QSet<Id> objIds{
             CLANG_CL_TOOLCHAIN_TYPEID,
diff --git a/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp b/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp
index f1cda0f941..67fcd19d2c 100644
--- a/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp
+++ b/src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp
@@ -108,7 +108,7 @@ QString compilerPath(QString pathFlag)
 Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
 {
     if (flags.empty())
-        return ToolChainKitAspect::toolChain(kit, language);
+        return ToolchainKitAspect::toolChain(kit, language);
 
     // Try exact compiler match.
     const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front()));
@@ -131,7 +131,7 @@ Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Ut
             return toolchain;
     }
 
-    toolchain = ToolChainKitAspect::toolChain(kit, language);
+    toolchain = ToolchainKitAspect::toolChain(kit, language);
     qWarning() << "No matching toolchain found, use the default.";
     return toolchain;
 }
diff --git a/src/plugins/conan/conaninstallstep.cpp b/src/plugins/conan/conaninstallstep.cpp
index ae28bfb1b4..30d4f09697 100644
--- a/src/plugins/conan/conaninstallstep.cpp
+++ b/src/plugins/conan/conaninstallstep.cpp
@@ -104,9 +104,9 @@ 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>";
+            return "<b>" + ToolchainKitAspect::msgNoToolChainInTarget() + "</b>";
         ProcessParameters param;
         setupProcessParameters(&param);
         return param.summary(displayName());
@@ -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();
diff --git a/src/plugins/cppcheck/cppcheckplugin.cpp b/src/plugins/cppcheck/cppcheckplugin.cpp
index 44381c235e..4ec26eb73a 100644
--- a/src/plugins/cppcheck/cppcheckplugin.cpp
+++ b/src/plugins/cppcheck/cppcheckplugin.cpp
@@ -135,7 +135,7 @@ void CppcheckPluginPrivate::updateManualRunAction()
     const Target *target = ProjectManager::startupTarget();
     const Utils::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
     const bool canRun = target && project->projectLanguages().contains(cxx)
-                  && ToolChainKitAspect::cxxToolChain(target->kit());
+                  && ToolchainKitAspect::cxxToolChain(target->kit());
     manualRunAction->setEnabled(canRun);
 }
 
diff --git a/src/plugins/cppeditor/cppmodelmanager.cpp b/src/plugins/cppeditor/cppmodelmanager.cpp
index ee94f84ee5..ac5c76ba0a 100644
--- a/src/plugins/cppeditor/cppmodelmanager.cpp
+++ b/src/plugins/cppeditor/cppmodelmanager.cpp
@@ -412,9 +412,9 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
     const Toolchain * tc = nullptr;
     const ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString()));
     if (classifier.isC()) {
-        tc = ToolChainKitAspect::cToolChain(project->activeTarget()->kit());
+        tc = ToolchainKitAspect::cToolChain(project->activeTarget()->kit());
     } else if (classifier.isCxx() || classifier.isHeader()) {
-        tc = ToolChainKitAspect::cxxToolChain(project->activeTarget()->kit());
+        tc = ToolchainKitAspect::cxxToolChain(project->activeTarget()->kit());
     } else {
         showFallbackWarning(Tr::tr("Could not determine which compiler to invoke."));
         useBuiltinPreprocessor();
@@ -1965,7 +1965,7 @@ void CppModelManager::setupFallbackProjectPart()
     // TODO: Use different fallback toolchain for different kinds of files?
     const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr;
     const Toolchain * const defaultTc = defaultKit
-            ? ToolChainKitAspect::cxxToolChain(defaultKit) : nullptr;
+            ? ToolchainKitAspect::cxxToolChain(defaultKit) : nullptr;
     if (defaultKit && defaultTc) {
         FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
         if (sysroot.isEmpty())
diff --git a/src/plugins/debugger/debuggerkitaspect.cpp b/src/plugins/debugger/debuggerkitaspect.cpp
index fdc6f77690..02f21c582a 100644
--- a/src/plugins/debugger/debuggerkitaspect.cpp
+++ b/src/plugins/debugger/debuggerkitaspect.cpp
@@ -148,7 +148,7 @@ DebuggerKitAspect::ConfigurationErrors DebuggerKitAspect::configurationErrors(co
     if (!debugger.isExecutableFile())
         result |= DebuggerNotExecutable;
 
-    const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
+    const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
     if (item->matchTarget(tcAbi) == DebuggerItem::DoesNotMatch) {
         // currently restricting the check to desktop devices, may be extended to all device types
         const IDevice::ConstPtr device = DeviceKitAspect::device(k);
@@ -303,7 +303,7 @@ public:
         //  </valuemap>
         const QVariant rawId = k->value(DebuggerKitAspectFactory::id());
 
-        const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
+        const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
 
         // Get the best of the available debugger matching the kit's toolchain.
         // The general idea is to find an item that exactly matches what
diff --git a/src/plugins/debugger/debuggerplugin.cpp b/src/plugins/debugger/debuggerplugin.cpp
index ecb655f6c0..cbfe4b7b2b 100644
--- a/src/plugins/debugger/debuggerplugin.cpp
+++ b/src/plugins/debugger/debuggerplugin.cpp
@@ -533,7 +533,7 @@ static Kit::Predicate cdbPredicate(char wordWidth = 0)
             return false;
         }
         if (wordWidth)
-            return ToolChainKitAspect::targetAbi(k).wordWidth() == wordWidth;
+            return ToolchainKitAspect::targetAbi(k).wordWidth() == wordWidth;
         return true;
     };
 }
@@ -1308,13 +1308,13 @@ static Kit *guessKitFromAbis(const Abis &abis)
     if (!abis.isEmpty()) {
         // Try exact abis.
         kit = KitManager::kit([abis](const Kit *k) {
-            const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
+            const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
             return abis.contains(tcAbi) && !DebuggerKitAspect::configurationErrors(k);
         });
         if (!kit) {
             // Or something compatible.
             kit = KitManager::kit([abis](const Kit *k) {
-                const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
+                const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
                 return !DebuggerKitAspect::configurationErrors(k)
                         && Utils::contains(abis, [tcAbi](const Abi &a) { return a.isCompatibleWith(tcAbi); });
             });
@@ -1764,7 +1764,7 @@ RunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
         return nullptr;
     }
 
-    const Abi tcAbi = ToolChainKitAspect::targetAbi(kit);
+    const Abi tcAbi = ToolchainKitAspect::targetAbi(kit);
     const bool isWindows = (tcAbi.os() == Abi::WindowsOS);
     if (isWindows && isWinProcessBeingDebugged(processInfo.processId)) {
         AsynchronousMessageBox::warning(
diff --git a/src/plugins/debugger/debuggerruncontrol.cpp b/src/plugins/debugger/debuggerruncontrol.cpp
index a12c8cec40..ed4968cdd9 100644
--- a/src/plugins/debugger/debuggerruncontrol.cpp
+++ b/src/plugins/debugger/debuggerruncontrol.cpp
@@ -900,7 +900,7 @@ DebuggerRunTool::DebuggerRunTool(RunControl *runControl, AllowTerminal allowTerm
         m_runParameters.projectSourceFiles.clear();
     }
 
-    m_runParameters.toolChainAbi = ToolChainKitAspect::targetAbi(kit);
+    m_runParameters.toolChainAbi = ToolchainKitAspect::targetAbi(kit);
 
     bool ok = false;
     const int nativeMixedOverride = qtcEnvironmentVariableIntValue("QTC_DEBUGGER_NATIVE_MIXED", &ok);
diff --git a/src/plugins/debugger/unstartedappwatcherdialog.cpp b/src/plugins/debugger/unstartedappwatcherdialog.cpp
index e120571839..9a657c4fad 100644
--- a/src/plugins/debugger/unstartedappwatcherdialog.cpp
+++ b/src/plugins/debugger/unstartedappwatcherdialog.cpp
@@ -72,7 +72,7 @@ UnstartedAppWatcherDialog::UnstartedAppWatcherDialog(QWidget *parent)
 
     m_kitChooser = new KitChooser(this);
     m_kitChooser->setKitPredicate([](const Kit *k) {
-        return ToolChainKitAspect::targetAbi(k).os() == Abi::hostAbi().os();
+        return ToolchainKitAspect::targetAbi(k).os() == Abi::hostAbi().os();
     });
     m_kitChooser->setShowIcons(true);
     m_kitChooser->populate();
diff --git a/src/plugins/docker/kitdetector.cpp b/src/plugins/docker/kitdetector.cpp
index 405ea76032..d2176760fa 100644
--- a/src/plugins/docker/kitdetector.cpp
+++ b/src/plugins/docker/kitdetector.cpp
@@ -364,12 +364,12 @@ void KitDetectorPrivate::autoDetect()
                    && (!qt || qt->qtAbis().contains(tc->targetAbi()));
         });
         for (Toolchain *toolChain : toolchainsToSet)
-            ToolChainKitAspect::setToolChain(k, toolChain);
+            ToolchainKitAspect::setToolChain(k, toolChain);
 
         if (cmakeId.isValid())
             k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true);
 
-        k->setSticky(ToolChainKitAspect::id(), true);
+        k->setSticky(ToolchainKitAspect::id(), true);
         k->setSticky(QtSupport::QtKitAspect::id(), true);
         k->setSticky(DeviceKitAspect::id(), true);
         k->setSticky(DeviceTypeKitAspect::id(), true);
diff --git a/src/plugins/incredibuild/makecommandbuilder.cpp b/src/plugins/incredibuild/makecommandbuilder.cpp
index 9e16c7fe1f..60b88f981f 100644
--- a/src/plugins/incredibuild/makecommandbuilder.cpp
+++ b/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());
         }
     }
diff --git a/src/plugins/ios/iosbuildstep.cpp b/src/plugins/ios/iosbuildstep.cpp
index 02ab577216..8b692d493f 100644
--- a/src/plugins/ios/iosbuildstep.cpp
+++ b/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";
diff --git a/src/plugins/ios/iosconfigurations.cpp b/src/plugins/ios/iosconfigurations.cpp
index b59aae15f8..c205f3a6d5 100644
--- a/src/plugins/ios/iosconfigurations.cpp
+++ b/src/plugins/ios/iosconfigurations.cpp
@@ -171,13 +171,13 @@ static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains,
 {
     DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
     if (toolChains.first)
-        ToolChainKitAspect::setToolChain(kit, toolChains.first);
+        ToolchainKitAspect::setToolChain(kit, toolChains.first);
     else
-        ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
+        ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
     if (toolChains.second)
-        ToolChainKitAspect::setToolChain(kit, toolChains.second);
+        ToolchainKitAspect::setToolChain(kit, toolChains.second);
     else
-        ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+        ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     QtKitAspect::setQtVersion(kit, qtVersion);
     // only replace debugger with the default one if we find an unusable one here
@@ -190,7 +190,7 @@ static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains,
 
     kit->setMutable(DeviceKitAspect::id(), true);
     kit->setSticky(QtKitAspect::id(), true);
-    kit->setSticky(ToolChainKitAspect::id(), true);
+    kit->setSticky(ToolchainKitAspect::id(), true);
     kit->setSticky(DeviceTypeKitAspect::id(), true);
     kit->setSticky(SysRootKitAspect::id(), true);
     kit->setSticky(DebuggerKitAspect::id(), false);
@@ -274,8 +274,8 @@ void IosConfigurations::updateAutomaticKitList()
                     // we do not compare the sdk (thus automatically upgrading it in place if a
                     // new Xcode is used). Change?
                     return DeviceTypeKitAspect::deviceTypeId(kit) == pDeviceType
-                            && ToolChainKitAspect::cxxToolChain(kit) == platformToolchains.second
-                            && ToolChainKitAspect::cToolChain(kit) == platformToolchains.first
+                            && ToolchainKitAspect::cxxToolChain(kit) == platformToolchains.second
+                            && ToolchainKitAspect::cToolChain(kit) == platformToolchains.first
                             && QtKitAspect::qtVersion(kit) == qtVersion;
                 });
                 QTC_ASSERT(!resultingKits.contains(kit), continue);
diff --git a/src/plugins/mcusupport/mcukitmanager.cpp b/src/plugins/mcusupport/mcukitmanager.cpp
index 2cc2311e69..f777b77f8e 100644
--- a/src/plugins/mcusupport/mcukitmanager.cpp
+++ b/src/plugins/mcusupport/mcukitmanager.cpp
@@ -86,10 +86,10 @@ public:
         case McuToolChainPackage::ToolChainType::GCC:
         case McuToolChainPackage::ToolChainType::MinGW:
         case McuToolChainPackage::ToolChainType::ArmGcc:
-            ToolChainKitAspect::setToolChain(k,
+            ToolchainKitAspect::setToolChain(k,
                                              tcPackage->toolChain(
                                                  ProjectExplorer::Constants::C_LANGUAGE_ID));
-            ToolChainKitAspect::setToolChain(k,
+            ToolchainKitAspect::setToolChain(k,
                                              tcPackage->toolChain(
                                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID));
             return;
diff --git a/src/plugins/mesonprojectmanager/mesonproject.cpp b/src/plugins/mesonprojectmanager/mesonproject.cpp
index 1566aa2553..5c3b77e54d 100644
--- a/src/plugins/mesonprojectmanager/mesonproject.cpp
+++ b/src/plugins/mesonprojectmanager/mesonproject.cpp
@@ -39,7 +39,7 @@ Tasks MesonProject::projectIssues(const Kit *k) const
     if (!NinjaToolKitAspect::isValid(k))
         result.append(
             createProjectTask(Task::TaskType::Error, Tr::tr("No Ninja tool set.")));
-    if (ToolChainKitAspect::toolChains(k).isEmpty())
+    if (ToolchainKitAspect::toolChains(k).isEmpty())
         result.append(createProjectTask(Task::TaskType::Warning,
                                         Tr::tr("No compilers set in kit.")));
     return result;
diff --git a/src/plugins/nim/project/nimbuildsystem.cpp b/src/plugins/nim/project/nimbuildsystem.cpp
index f07d8f607f..ebfce4b9ad 100644
--- a/src/plugins/nim/project/nimbuildsystem.cpp
+++ b/src/plugins/nim/project/nimbuildsystem.cpp
@@ -169,7 +169,7 @@ void NimBuildSystem::triggerParsing()
 
 FilePath nimPathFromKit(Kit *kit)
 {
-    auto tc = ToolChainKitAspect::toolChain(kit, Constants::C_NIMLANGUAGE_ID);
+    auto tc = ToolchainKitAspect::toolChain(kit, Constants::C_NIMLANGUAGE_ID);
     QTC_ASSERT(tc, return {});
     const FilePath command = tc->compilerCommand();
     return command.isEmpty() ? FilePath() : command.absolutePath();
diff --git a/src/plugins/nim/project/nimcompilerbuildstep.cpp b/src/plugins/nim/project/nimcompilerbuildstep.cpp
index eecd7d442c..aa0eb6f298 100644
--- a/src/plugins/nim/project/nimcompilerbuildstep.cpp
+++ b/src/plugins/nim/project/nimcompilerbuildstep.cpp
@@ -159,7 +159,7 @@ CommandLine NimCompilerBuildStep::commandLine()
     auto bc = qobject_cast<NimBuildConfiguration *>(buildConfiguration());
     QTC_ASSERT(bc, return {});
 
-    auto tc = ToolChainKitAspect::toolChain(kit(), Constants::C_NIMLANGUAGE_ID);
+    auto tc = ToolchainKitAspect::toolChain(kit(), Constants::C_NIMLANGUAGE_ID);
     QTC_ASSERT(tc, return {});
 
     CommandLine cmd{tc->compilerCommand()};
diff --git a/src/plugins/nim/project/nimproject.cpp b/src/plugins/nim/project/nimproject.cpp
index 215820818b..bfca6a92fa 100644
--- a/src/plugins/nim/project/nimproject.cpp
+++ b/src/plugins/nim/project/nimproject.cpp
@@ -52,7 +52,7 @@ NimProject::NimProject(const FilePath &filePath) : Project(Constants::C_NIM_MIME
 Tasks NimProject::projectIssues(const Kit *k) const
 {
     Tasks result = Project::projectIssues(k);
-    auto tc = ToolChainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID);
+    auto tc = ToolchainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID);
     if (!tc) {
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Nim compiler set.")));
         return result;
diff --git a/src/plugins/perfprofiler/perfdatareader.cpp b/src/plugins/perfprofiler/perfdatareader.cpp
index 222e1c9788..80b53b5cba 100644
--- a/src/plugins/perfprofiler/perfdatareader.cpp
+++ b/src/plugins/perfprofiler/perfdatareader.cpp
@@ -288,7 +288,7 @@ void PerfDataReader::collectArguments(CommandLine *cmd, const QString &exe, cons
                      .arg(cmd->executable().osType() == OsTypeWindows ? u';' : u':'));
     }
 
-    if (auto toolChain = ToolChainKitAspect::cxxToolChain(kit)) {
+    if (auto toolChain = ToolchainKitAspect::cxxToolChain(kit)) {
         Abi::Architecture architecture = toolChain->targetAbi().architecture();
         if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) {
             cmd->addArg("--arch");
diff --git a/src/plugins/projectexplorer/kitaspects.cpp b/src/plugins/projectexplorer/kitaspects.cpp
index 6fd9808ab7..218deea329 100644
--- a/src/plugins/projectexplorer/kitaspects.cpp
+++ b/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())
@@ -188,14 +188,14 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
 const SysRootKitAspectFactory theSyRootKitAspectFactory;
 
 // --------------------------------------------------------------------------
-// ToolChainKitAspect:
+// ToolchainKitAspect:
 // --------------------------------------------------------------------------
 
 namespace Internal {
-class ToolChainKitAspectImpl final : public KitAspect
+class ToolchainKitAspectImpl final : public KitAspect
 {
 public:
-    ToolChainKitAspectImpl(Kit *k, const KitAspectFactory *factory) : KitAspect(k, factory)
+    ToolchainKitAspectImpl(Kit *k, const KitAspectFactory *factory) : KitAspect(k, factory)
     {
         m_mainWidget = createSubWidget<QWidget>();
         m_mainWidget->setContentsMargins(0, 0, 0, 0);
@@ -230,7 +230,7 @@ public:
         setManagingPage(Constants::TOOLCHAIN_SETTINGS_PAGE_ID);
     }
 
-    ~ToolChainKitAspectImpl() override
+    ~ToolchainKitAspectImpl() override
     {
         delete m_mainWidget;
     }
@@ -272,7 +272,7 @@ private:
                 cb->addItem(item->displayName(), item->id());
 
             cb->setEnabled(cb->count() > 1 && !m_isReadOnly);
-            const int index = indexOf(cb, ToolChainKitAspect::toolChain(m_kit, l));
+            const int index = indexOf(cb, ToolchainKitAspect::toolChain(m_kit, l));
             cb->setCurrentIndex(index);
         }
     }
@@ -295,9 +295,9 @@ private:
         Toolchain *tc = ToolChainManager::findToolChain(id);
         QTC_ASSERT(!tc || tc->language() == language, return);
         if (tc)
-            ToolChainKitAspect::setToolChain(m_kit, tc);
+            ToolchainKitAspect::setToolChain(m_kit, tc);
         else
-            ToolChainKitAspect::clearToolChain(m_kit, language);
+            ToolchainKitAspect::clearToolChain(m_kit, language);
     }
 
     int indexOf(QComboBox *cb, const Toolchain *tc)
@@ -317,10 +317,10 @@ private:
 };
 } // namespace Internal
 
-class ToolChainKitAspectFactory : public KitAspectFactory
+class ToolchainKitAspectFactory : public KitAspectFactory
 {
 public:
-    ToolChainKitAspectFactory();
+    ToolchainKitAspectFactory();
 
 private:
     Tasks validate(const Kit *k) const override;
@@ -346,9 +346,9 @@ private:
     void toolChainRemoved(Toolchain *tc);
 };
 
-ToolChainKitAspectFactory::ToolChainKitAspectFactory()
+ToolchainKitAspectFactory::ToolchainKitAspectFactory()
 {
-    setId(ToolChainKitAspect::id());
+    setId(ToolchainKitAspect::id());
     setDisplayName(Tr::tr("Compiler"));
     setDescription(Tr::tr("The compiler to use for building.<br>"
                       "Make sure the compiler will produce binaries compatible "
@@ -380,13 +380,13 @@ static Store defaultToolChainValue()
     return result;
 }
 
-Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
+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());
+        result << BuildSystemTask(Task::Warning, ToolchainKitAspect::msgNoToolChainInTarget());
     } else {
         QSet<Abi> targetAbis;
         for (const Toolchain *tc : tcList) {
@@ -402,17 +402,17 @@ Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
     return result;
 }
 
-void ToolChainKitAspectFactory::fix(Kit *k)
+void ToolchainKitAspectFactory::fix(Kit *k)
 {
     QTC_ASSERT(ToolChainManager::isLoaded(), return);
     const QList<Id> languages = ToolChainManager::allLanguages();
     for (const Id l : languages) {
-        const QByteArray tcId = ToolChainKitAspect::toolChainId(k, l);
+        const QByteArray tcId = ToolchainKitAspect::toolChainId(k, l);
         if (!tcId.isEmpty() && !ToolChainManager::findToolChain(tcId)) {
             qWarning("Tool chain set up in kit \"%s\" for \"%s\" not found.",
                      qPrintable(k->displayName()),
                      qPrintable(ToolChainManager::displayNameOfLanguageId(l)));
-            ToolChainKitAspect::clearToolChain(k, l); // make sure to clear out no longer known tool chains
+            ToolchainKitAspect::clearToolChain(k, l); // make sure to clear out no longer known tool chains
         }
     }
 }
@@ -424,7 +424,7 @@ static Id findLanguage(const QString &ls)
                          [lsUpper](Id l) { return lsUpper == l.toString().toUpper(); });
 }
 
-void ToolChainKitAspectFactory::setup(Kit *k)
+void ToolchainKitAspectFactory::setup(Kit *k)
 {
     QTC_ASSERT(ToolChainManager::isLoaded(), return);
     QTC_ASSERT(k, return);
@@ -459,123 +459,123 @@ void ToolChainKitAspectFactory::setup(Kit *k)
                 bestTc = tc;
         }
         if (bestTc)
-            ToolChainKitAspect::setToolChain(k, bestTc);
+            ToolchainKitAspect::setToolChain(k, bestTc);
         else
-            ToolChainKitAspect::clearToolChain(k, l);
+            ToolchainKitAspect::clearToolChain(k, l);
     }
 
     k->setSticky(id(), lockToolchains);
 }
 
-KitAspect *ToolChainKitAspectFactory::createKitAspect(Kit *k) const
+KitAspect *ToolchainKitAspectFactory::createKitAspect(Kit *k) const
 {
     QTC_ASSERT(k, return nullptr);
-    return new Internal::ToolChainKitAspectImpl(k, this);
+    return new Internal::ToolchainKitAspectImpl(k, this);
 }
 
-QString ToolChainKitAspectFactory::displayNamePostfix(const 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
+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
+void ToolchainKitAspectFactory::addToBuildEnvironment(const Kit *k, Environment &env) const
 {
-    Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
     if (tc)
         tc->addToEnvironment(env);
 }
 
-void ToolChainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expander) const
+void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expander) const
 {
     QTC_ASSERT(kit, return);
 
     // 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();
                              });
 }
 
-QList<OutputLineParser *> ToolChainKitAspectFactory::createOutputParsers(const Kit *k) const
+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 {};
 }
 
-QSet<Id> ToolChainKitAspectFactory::availableFeatures(const Kit *k) const
+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;
 }
 
-Id ToolChainKitAspect::id()
+Id ToolchainKitAspect::id()
 {
     // "PE.Profile.ToolChain" until 4.2
     // "PE.Profile.ToolChains" temporarily before 4.3 (May 2017)
     return "PE.Profile.ToolChainsV3";
 }
 
-QByteArray ToolChainKitAspect::toolChainId(const Kit *k, Id language)
+QByteArray ToolchainKitAspect::toolChainId(const Kit *k, Id language)
 {
     QTC_ASSERT(ToolChainManager::isLoaded(), return nullptr);
     if (!k)
         return {};
-    Store value = storeFromVariant(k->value(ToolChainKitAspect::id()));
+    Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
     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 Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
     const QList<Toolchain *> tcList
             = transform<QList>(ToolChainManager::allLanguages(), [&value](Id l) {
                 return ToolChainManager::findToolChain(value.value(l.toKey()).toByteArray());
@@ -583,11 +583,11 @@ QList<Toolchain *> ToolChainKitAspect::toolChains(const Kit *k)
     return filtered(tcList, [](Toolchain *tc) { return tc; });
 }
 
-void ToolChainKitAspect::setToolChain(Kit *k, Toolchain *tc)
+void ToolchainKitAspect::setToolChain(Kit *k, Toolchain *tc)
 {
     QTC_ASSERT(tc, return);
     QTC_ASSERT(k, return);
-    Store result = storeFromVariant(k->value(ToolChainKitAspect::id()));
+    Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
     result.insert(tc->language().toKey(), tc->id());
 
     k->setValue(id(), variantFromStore(result));
@@ -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);
@@ -611,7 +611,7 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
     const Toolchains allTcList = ToolChainManager::toolchains();
     QTC_ASSERT(allTcList.contains(tc), return);
 
-    Store result = storeFromVariant(k->value(ToolChainKitAspect::id()));
+    Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
     result.insert(tc->language().toKey(), tc->id());
 
     for (const Id l : ToolChainManager::allLanguages()) {
@@ -642,17 +642,17 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
     k->setValue(id(), variantFromStore(result));
 }
 
-void ToolChainKitAspect::clearToolChain(Kit *k, Id language)
+void ToolchainKitAspect::clearToolChain(Kit *k, Id language)
 {
     QTC_ASSERT(language.isValid(), return);
     QTC_ASSERT(k, return);
 
-    Store result = storeFromVariant(k->value(ToolChainKitAspect::id()));
+    Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
     result.insert(language.toKey(), QByteArray());
     k->setValue(id(), variantFromStore(result));
 }
 
-Abi ToolChainKitAspect::targetAbi(const Kit *k)
+Abi ToolchainKitAspect::targetAbi(const Kit *k)
 {
     const QList<Toolchain *> tcList = toolChains(k);
     // Find the best possible ABI for all the tool chains...
@@ -685,38 +685,38 @@ Abi ToolChainKitAspect::targetAbi(const Kit *k)
     return candidates.at(0); // Use basically a random Abi...
 }
 
-QString ToolChainKitAspect::msgNoToolChainInTarget()
+QString ToolchainKitAspect::msgNoToolChainInTarget()
 {
     return Tr::tr("No compiler set in kit.");
 }
 
-void ToolChainKitAspectFactory::onKitsLoaded()
+void ToolchainKitAspectFactory::onKitsLoaded()
 {
     for (Kit *k : KitManager::kits())
         fix(k);
 
     connect(ToolChainManager::instance(), &ToolChainManager::toolChainRemoved,
-            this, &ToolChainKitAspectFactory::toolChainRemoved);
+            this, &ToolchainKitAspectFactory::toolChainRemoved);
     connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
-            this, &ToolChainKitAspectFactory::toolChainUpdated);
+            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)
+        if (ToolchainKitAspect::toolChain(k, tc->language()) == tc)
             notifyAboutUpdate(k);
     }
 }
 
-void ToolChainKitAspectFactory::toolChainRemoved(Toolchain *tc)
+void ToolchainKitAspectFactory::toolChainRemoved(Toolchain *tc)
 {
     Q_UNUSED(tc)
     for (Kit *k : KitManager::kits())
         fix(k);
 }
 
-const ToolChainKitAspectFactory thsToolChainKitAspectFactory;
+const ToolchainKitAspectFactory thsToolChainKitAspectFactory;
 
 // --------------------------------------------------------------------------
 // DeviceTypeKitAspect:
diff --git a/src/plugins/projectexplorer/kitaspects.h b/src/plugins/projectexplorer/kitaspects.h
index 7b8270d7d4..8c303c7d18 100644
--- a/src/plugins/projectexplorer/kitaspects.h
+++ b/src/plugins/projectexplorer/kitaspects.h
@@ -26,7 +26,7 @@ public:
 
 // ToolChainKitAspect
 
-class PROJECTEXPLORER_EXPORT ToolChainKitAspect
+class PROJECTEXPLORER_EXPORT ToolchainKitAspect
 {
 public:
     static Utils::Id id();
diff --git a/src/plugins/projectexplorer/kitmanager.cpp b/src/plugins/projectexplorer/kitmanager.cpp
index 213d53f1b1..b228ea7c69 100644
--- a/src/plugins/projectexplorer/kitmanager.cpp
+++ b/src/plugins/projectexplorer/kitmanager.cpp
@@ -151,7 +151,7 @@ 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) {
         const Abi tcAbi = tc->targetAbi();
         for (const Abi &abi : abis) {
@@ -183,7 +183,7 @@ 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) {
         const Abi tcAbi = tc->targetAbi();
         switch (tcAbi.os()) {
@@ -347,10 +347,10 @@ void KitManager::restoreKits()
             kit->setSdkProvided(false);
             kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here?
             for (Toolchain * const tc : it.value())
-                ToolChainKitAspect::setToolChain(kit.get(), tc);
+                ToolchainKitAspect::setToolChain(kit.get(), tc);
             if (contains(resultList, [&kit](const std::unique_ptr<Kit> &existingKit) {
-                return ToolChainKitAspect::toolChains(kit.get())
-                         == ToolChainKitAspect::toolChains(existingKit.get());
+                return ToolchainKitAspect::toolChains(kit.get())
+                         == ToolchainKitAspect::toolChains(existingKit.get());
             })) {
                 continue;
             }
diff --git a/src/plugins/projectexplorer/makestep.cpp b/src/plugins/projectexplorer/makestep.cpp
index e14f2b8a93..1a1a8fae41 100644
--- a/src/plugins/projectexplorer/makestep.cpp
+++ b/src/plugins/projectexplorer/makestep.cpp
@@ -130,7 +130,7 @@ QString MakeStep::defaultDisplayName()
 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)
diff --git a/src/plugins/projectexplorer/project.cpp b/src/plugins/projectexplorer/project.cpp
index 84c8fb2e10..711a934d5f 100644
--- a/src/plugins/projectexplorer/project.cpp
+++ b/src/plugins/projectexplorer/project.cpp
@@ -1551,12 +1551,12 @@ void ProjectExplorerPlugin::testSourceToBinaryMapping()
 {
     // Find suitable kit.
     Kit * const kit = findOr(KitManager::kits(), nullptr, [](const Kit *k) {
-        return k->isValid() && ToolChainKitAspect::cxxToolChain(k);
+        return k->isValid() && ToolchainKitAspect::cxxToolChain(k);
     });
     if (!kit)
         QSKIP("The test requires at least one kit with a toolchain.");
 
-    const auto toolchain = ToolChainKitAspect::cxxToolChain(kit);
+    const auto toolchain = ToolchainKitAspect::cxxToolChain(kit);
     QVERIFY(toolchain);
     if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) {
         while (!msvcToolchain->environmentInitialized()) {
diff --git a/src/plugins/projectexplorer/projectimporter.cpp b/src/plugins/projectexplorer/projectimporter.cpp
index 31498c1487..b55888159b 100644
--- a/src/plugins/projectexplorer/projectimporter.cpp
+++ b/src/plugins/projectexplorer/projectimporter.cpp
@@ -53,7 +53,7 @@ static bool hasOtherUsers(Utils::Id id, const QVariant &v, Kit *k)
 
 ProjectImporter::ProjectImporter(const Utils::FilePath &path) : m_projectPath(path)
 {
-    useTemporaryKitAspect(ToolChainKitAspect::id(),
+    useTemporaryKitAspect(ToolchainKitAspect::id(),
                                [this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(k, vl); },
                                [this](Kit *k, const QVariantList &vl) { persistTemporaryToolChains(k, vl); });
 }
@@ -322,7 +322,7 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
         Toolchain *tc = toolChainFromVariant(v);
         QTC_ASSERT(tc, continue);
         ToolChainManager::deregisterToolChain(tc);
-        ToolChainKitAspect::setToolChain(k, nullptr);
+        ToolchainKitAspect::setToolChain(k, nullptr);
     }
 }
 
@@ -331,7 +331,7 @@ void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
     for (const QVariant &v : vl) {
         Toolchain *tmpTc = toolChainFromVariant(v);
         QTC_ASSERT(tmpTc, continue);
-        Toolchain *actualTc = ToolChainKitAspect::toolChain(k, tmpTc->language());
+        Toolchain *actualTc = ToolchainKitAspect::toolChain(k, tmpTc->language());
         if (tmpTc && actualTc != tmpTc)
             ToolChainManager::deregisterToolChain(tmpTc);
     }
@@ -394,7 +394,7 @@ ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
     });
     for (const Toolchain *tc : std::as_const(result.tcs)) {
         const QByteArray tcId = tc->id();
-        result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolChainKitAspect::id(), tcId);
+        result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolchainKitAspect::id(), tcId);
     }
     if (!result.tcs.isEmpty())
         return result;
diff --git a/src/plugins/projectexplorer/rawprojectpart.cpp b/src/plugins/projectexplorer/rawprojectpart.cpp
index 53290cef8e..369321cd80 100644
--- a/src/plugins/projectexplorer/rawprojectpart.cpp
+++ b/src/plugins/projectexplorer/rawprojectpart.cpp
@@ -142,8 +142,8 @@ KitInfo::KitInfo(Kit *kit)
 {
     // Toolchains
     if (kit) {
-        cToolChain = ToolChainKitAspect::cToolChain(kit);
-        cxxToolChain = ToolChainKitAspect::cxxToolChain(kit);
+        cToolChain = ToolchainKitAspect::cToolChain(kit);
+        cxxToolChain = ToolchainKitAspect::cxxToolChain(kit);
     }
 
     // Sysroot
diff --git a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp b/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
index 658e6650c1..97b1734655 100644
--- a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
+++ b/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
@@ -238,8 +238,8 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
     if (!sysroot.isEmpty())
         data.insert(QLatin1String(QBS_SYSROOT), sysroot);
 
-    Toolchain *tcC = ToolChainKitAspect::cToolChain(k);
-    Toolchain *tcCxx = ToolChainKitAspect::cxxToolChain(k);
+    Toolchain *tcC = ToolchainKitAspect::cToolChain(k);
+    Toolchain *tcCxx = ToolchainKitAspect::cxxToolChain(k);
     if (!tcC && !tcCxx)
         return data;
 
diff --git a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp b/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
index 0d5afda8f3..a8612d5e71 100644
--- a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
+++ b/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
@@ -141,12 +141,12 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
     const auto * const bgData = static_cast<BuildGraphData *>(directoryData);
     qCDebug(qbsPmLog) << "matching kit" << k->displayName() << "against imported build"
                       << bgData->bgFilePath.toUserOutput();
-    if (ToolChainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
+    if (ToolchainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
             && bgData->cxxCompilerPath.isEmpty()) {
         return true;
     }
-    const Toolchain * const cToolchain = ToolChainKitAspect::cToolChain(k);
-    const Toolchain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k);
+    const Toolchain * const cToolchain = ToolchainKitAspect::cToolChain(k);
+    const Toolchain * const cxxToolchain = ToolchainKitAspect::cxxToolChain(k);
     if (!bgData->cCompilerPath.isEmpty()) {
         if (!cToolchain)
             return false;
@@ -190,7 +190,7 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
             tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
         for (const ToolChainData &tc : std::as_const(tcData)) {
             if (!tc.tcs.isEmpty())
-                ToolChainKitAspect::setToolChain(k, tc.tcs.first());
+                ToolchainKitAspect::setToolChain(k, tc.tcs.first());
         }
         SysRootKitAspect::setSysRoot(k, bgData->sysroot);
     });
diff --git a/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp b/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
index 9bd50ff3c1..2039b0ec21 100644
--- a/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
+++ b/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();
 }
 
diff --git a/src/plugins/qmakeprojectmanager/qmakekitaspect.cpp b/src/plugins/qmakeprojectmanager/qmakekitaspect.cpp
index 18033f9dfc..d0263bf094 100644
--- a/src/plugins/qmakeprojectmanager/qmakekitaspect.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakekitaspect.cpp
@@ -98,7 +98,7 @@ QString QmakeKitAspect::defaultMkspec(const Kit *k)
     if (!version) // No version, so no qmake
         return {};
 
-    return version->mkspecFor(ToolChainKitAspect::cxxToolChain(k));
+    return version->mkspecFor(ToolchainKitAspect::cxxToolChain(k));
 }
 
 // QmakeKitAspectFactory
diff --git a/src/plugins/qmakeprojectmanager/qmakemakestep.cpp b/src/plugins/qmakeprojectmanager/qmakemakestep.cpp
index 0cd032b499..6a22f89eb3 100644
--- a/src/plugins/qmakeprojectmanager/qmakemakestep.cpp
+++ b/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;
diff --git a/src/plugins/qmakeprojectmanager/qmakeproject.cpp b/src/plugins/qmakeprojectmanager/qmakeproject.cpp
index 4ddc7ae410..2daf3c31d4 100644
--- a/src/plugins/qmakeprojectmanager/qmakeproject.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakeproject.cpp
@@ -238,7 +238,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
 
     connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
             this, [this](Toolchain *tc) {
-        if (ToolChainKitAspect::cxxToolChain(kit()) == tc)
+        if (ToolchainKitAspect::cxxToolChain(kit()) == tc)
             scheduleUpdateAllNowOrLater();
     });
 
@@ -757,7 +757,7 @@ Tasks QmakeProject::projectIssues(const Kit *k) const
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Qt version set in kit.")));
     else if (!qtFromKit->isValid())
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("Qt version is invalid.")));
-    if (!ToolChainKitAspect::cxxToolChain(k))
+    if (!ToolchainKitAspect::cxxToolChain(k))
         result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No C++ compiler set in kit.")));
 
     // A project can be considered part of more than one Qt version, for instance if it is an
@@ -1308,7 +1308,7 @@ static FilePath destDirFor(const TargetInformation &ti)
 
 FilePaths QmakeBuildSystem::allLibraryTargetFiles(const QmakeProFile *file) const
 {
-    const Toolchain *const toolchain = ToolChainKitAspect::cxxToolChain(kit());
+    const Toolchain *const toolchain = ToolchainKitAspect::cxxToolChain(kit());
     if (!toolchain)
         return {};
 
@@ -1467,14 +1467,14 @@ QString QmakeBuildSystem::deviceRoot() const
 void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
 {
     const BuildConfiguration *bc = buildConfiguration();
-    testToolChain(ToolChainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
-    testToolChain(ToolChainKitAspect::cxxToolChain(kit()),
+    testToolChain(ToolchainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
+    testToolChain(ToolchainKitAspect::cxxToolChain(kit()),
                   getFullPathOf(pro, Variable::QmakeCxx, bc));
 }
 
 FilePath QmakeBuildSystem::executableFor(const QmakeProFile *file)
 {
-    const Toolchain *const tc = ToolChainKitAspect::cxxToolChain(kit());
+    const Toolchain *const tc = ToolchainKitAspect::cxxToolChain(kit());
     if (!tc)
         return {};
 
diff --git a/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp b/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
index a2f20fe4ee..711b30bcf3 100644
--- a/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
@@ -160,7 +160,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
 
     QtVersion *kitVersion = QtKitAspect::qtVersion(k);
     QString kitSpec = QmakeKitAspect::mkspec(k);
-    Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
+    Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
     if (kitSpec.isEmpty() && kitVersion)
         kitSpec = kitVersion->mkspecFor(tc);
     QMakeStepConfig::OsType kitOsType = QMakeStepConfig::NoOsType;
@@ -241,7 +241,7 @@ Kit *QmakeProjectImporter::createTemporaryKit(const QtProjectImporter::QtVersion
     Q_UNUSED(osType) // TODO use this to select the right toolchain?
     return QtProjectImporter::createTemporaryKit(data, [&data, parsedSpec](Kit *k) -> void {
         for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec))
-            ToolChainKitAspect::setToolChain(k, tc);
+            ToolchainKitAspect::setToolChain(k, tc);
         if (parsedSpec != data.qt->mkspec())
             QmakeKitAspect::setMkspec(k, parsedSpec, QmakeKitAspect::MkspecSource::Code);
     });
diff --git a/src/plugins/qmakeprojectmanager/qmakestep.cpp b/src/plugins/qmakeprojectmanager/qmakestep.cpp
index 019429805a..db2d8da91a 100644
--- a/src/plugins/qmakeprojectmanager/qmakestep.cpp
+++ b/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) {
diff --git a/src/plugins/qnx/qnxsettingspage.cpp b/src/plugins/qnx/qnxsettingspage.cpp
index e3dd7e7acb..86da2f4c17 100644
--- a/src/plugins/qnx/qnxsettingspage.cpp
+++ b/src/plugins/qnx/qnxsettingspage.cpp
@@ -182,7 +182,7 @@ void QnxConfiguration::deactivate()
     for (Kit *kit : kits) {
         if (kit->isAutoDetected()
                 && DeviceTypeKitAspect::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE
-                && toolChainsToRemove.contains(ToolChainKitAspect::cxxToolChain(kit))) {
+                && toolChainsToRemove.contains(ToolchainKitAspect::cxxToolChain(kit))) {
             KitManager::deregisterKit(kit);
         }
     }
@@ -258,8 +258,8 @@ void QnxConfiguration::createKit(const QnxTarget &target)
 
     const auto init = [&](Kit *k) {
         QtKitAspect::setQtVersion(k, qnxQt);
-        ToolChainKitAspect::setToolChain(k, toolChains[0]);
-        ToolChainKitAspect::setToolChain(k, toolChains[1]);
+        ToolchainKitAspect::setToolChain(k, toolChains[0]);
+        ToolchainKitAspect::setToolChain(k, toolChains[1]);
 
         if (debugger.isValid())
             DebuggerKitAspect::setDebugger(k, debugger);
@@ -275,7 +275,7 @@ void QnxConfiguration::createKit(const QnxTarget &target)
         k->setAutoDetectionSource(m_envFile.toString());
         k->setMutable(DeviceKitAspect::id(), true);
 
-        k->setSticky(ToolChainKitAspect::id(), true);
+        k->setSticky(ToolchainKitAspect::id(), true);
         k->setSticky(DeviceTypeKitAspect::id(), true);
         k->setSticky(SysRootKitAspect::id(), true);
         k->setSticky(DebuggerKitAspect::id(), true);
diff --git a/src/plugins/qtsupport/baseqtversion.cpp b/src/plugins/qtsupport/baseqtversion.cpp
index 8f461eed64..b74d9c25b3 100644
--- a/src/plugins/qtsupport/baseqtversion.cpp
+++ b/src/plugins/qtsupport/baseqtversion.cpp
@@ -542,7 +542,7 @@ Tasks QtVersion::validateKit(const Kit *k)
             result << BuildSystemTask(Task::Warning, Tr::tr("Device type is not supported by Qt version."));
     }
 
-    if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) {
+    if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
         Abi targetAbi = tc->targetAbi();
         Abis supportedAbis = tc->supportedAbis();
         bool fuzzyMatch = false;
@@ -576,7 +576,7 @@ Tasks QtVersion::validateKit(const Kit *k)
                                   version->displayName(), qtAbiString);
             result << BuildSystemTask(fuzzyMatch ? Task::Warning : Task::Error, message);
         }
-    } else if (ToolChainKitAspect::cToolChain(k)) {
+    } else if (ToolchainKitAspect::cToolChain(k)) {
         const QString message = Tr::tr("The kit has a Qt version, but no C++ compiler.");
         result << BuildSystemTask(Task::Warning, message);
     }
diff --git a/src/plugins/qtsupport/qtkitaspect.cpp b/src/plugins/qtsupport/qtkitaspect.cpp
index c53cb537c2..e2591d9260 100644
--- a/src/plugins/qtsupport/qtkitaspect.cpp
+++ b/src/plugins/qtsupport/qtkitaspect.cpp
@@ -175,7 +175,7 @@ void QtKitAspectFactory::setup(Kit *k)
 {
     if (!k || k->hasValue(id()))
         return;
-    const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
+    const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
     const Id deviceType = DeviceTypeKitAspect::deviceTypeId(k);
 
     const QtVersions matches
@@ -226,7 +226,7 @@ void QtKitAspectFactory::fix(Kit *k)
     }
 
     // Set a matching toolchain if we don't have one.
-    if (ToolChainKitAspect::cxxToolChain(k))
+    if (ToolchainKitAspect::cxxToolChain(k))
         return;
 
     const QString spec = version->mkspec();
@@ -283,7 +283,7 @@ void QtKitAspectFactory::fix(Kit *k)
         });
 
         if (Toolchain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
-            ToolChainKitAspect::setAllToolChainsToMatch(k, bestTc);
+            ToolchainKitAspect::setAllToolChainsToMatch(k, bestTc);
     }
 }
 
@@ -405,7 +405,7 @@ void QtKitAspect::setQtVersion(Kit *k, const QtVersion *v)
 
 void QtKitAspect::addHostBinariesToPath(const Kit *k, Environment &env)
 {
-    if (const Toolchain *tc = ToolChainKitAspect::cxxToolChain(k))
+    if (const Toolchain *tc = ToolchainKitAspect::cxxToolChain(k))
         env.prependOrSetPath(tc->compilerCommand().parentDir());
 
     if (const QtVersion *qt = qtVersion(k))
@@ -479,7 +479,7 @@ int QtKitAspectFactory::weight(const Kit *k) const
         return 0;
     if (!qt->targetDeviceTypes().contains(DeviceTypeKitAspect::deviceTypeId(k)))
         return 0;
-    const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
+    const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
     if (qt->qtAbis().contains(tcAbi))
         return 2;
     return Utils::contains(qt->qtAbis(), [&tcAbi](const Abi &qtAbi) {
diff --git a/src/plugins/valgrind/memchecktool.cpp b/src/plugins/valgrind/memchecktool.cpp
index 5a23bac90e..3467550886 100644
--- a/src/plugins/valgrind/memchecktool.cpp
+++ b/src/plugins/valgrind/memchecktool.cpp
@@ -714,7 +714,7 @@ void MemcheckToolPrivate::heobAction()
         if (RunConfiguration *rc = target->activeRunConfiguration()) {
             kit = target->kit();
             if (kit) {
-                abi = ToolChainKitAspect::targetAbi(kit);
+                abi = ToolchainKitAspect::targetAbi(kit);
                 sr = rc->runnable();
                 const IDevice::ConstPtr device
                         = DeviceManager::deviceForPath(sr.command.executable());