All: More ToolChain->Toolchain renamings

And removal of one unused function declaration.

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

36 files changed, 180 insertions, 181 deletions

diff --git a/src/plugins/baremetal/iarewtoolchain.cpp b/src/plugins/baremetal/iarewtoolchain.cpp
index 0dac8415f0..66bc82b848 100644
--- a/src/plugins/baremetal/iarewtoolchain.cpp
+++ b/src/plugins/baremetal/iarewtoolchain.cpp
@@ -278,7 +278,7 @@ private:
     Macros m_macros;
 };
 
-// IarToolChain
+// IarToolchain
 
 class IarToolchain final : public Toolchain
 {
@@ -593,10 +593,10 @@ IarToolchainConfigWidget::IarToolchainConfigWidget(IarToolchain *tc) :
 
 void IarToolchainConfigWidget::applyImpl()
 {
-    if (toolChain()->isAutoDetected())
+    if (toolchain()->isAutoDetected())
         return;
 
-    const auto tc = static_cast<IarToolchain *>(toolChain());
+    const auto tc = static_cast<IarToolchain *>(toolchain());
     const QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
 
@@ -616,7 +616,7 @@ void IarToolchainConfigWidget::applyImpl()
 
 bool IarToolchainConfigWidget::isDirtyImpl() const
 {
-    const auto tc = static_cast<IarToolchain *>(toolChain());
+    const auto tc = static_cast<IarToolchain *>(toolchain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
             || m_abiWidget->currentAbi() != tc->targetAbi()
@@ -633,7 +633,7 @@ void IarToolchainConfigWidget::makeReadOnlyImpl()
 void IarToolchainConfigWidget::setFromToolchain()
 {
     const QSignalBlocker blocker(this);
-    const auto tc = static_cast<IarToolchain *>(toolChain());
+    const auto tc = static_cast<IarToolchain *>(toolchain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_abiWidget->setAbis({}, tc->targetAbi());
@@ -648,7 +648,7 @@ void IarToolchainConfigWidget::handleCompilerCommandChange()
     if (haveCompiler) {
         const auto env = Environment::systemEnvironment();
         const QStringList extraArgs = splitString(m_platformCodeGenFlagsLineEdit->text());
-        const Id languageId = toolChain()->language();
+        const Id languageId = toolchain()->language();
         m_macros = dumpPredefinedMacros(compilerPath, extraArgs, languageId, env);
         const Abi guessed = guessAbi(m_macros);
         m_abiWidget->setAbis({}, guessed);
diff --git a/src/plugins/baremetal/keiltoolchain.cpp b/src/plugins/baremetal/keiltoolchain.cpp
index d1b4342650..51cd89a427 100644
--- a/src/plugins/baremetal/keiltoolchain.cpp
+++ b/src/plugins/baremetal/keiltoolchain.cpp
@@ -752,10 +752,10 @@ KeilToolchainConfigWidget::KeilToolchainConfigWidget(KeilToolchain *tc) :
 
 void KeilToolchainConfigWidget::applyImpl()
 {
-    if (toolChain()->isAutoDetected())
+    if (toolchain()->isAutoDetected())
         return;
 
-    const auto tc = static_cast<KeilToolchain *>(toolChain());
+    const auto tc = static_cast<KeilToolchain *>(toolchain());
     const QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
     tc->m_extraCodeModelFlags.setValue(splitString(m_platformCodeGenFlagsLineEdit->text()));
@@ -773,7 +773,7 @@ void KeilToolchainConfigWidget::applyImpl()
 
 bool KeilToolchainConfigWidget::isDirtyImpl() const
 {
-    const auto tc = static_cast<KeilToolchain *>(toolChain());
+    const auto tc = static_cast<KeilToolchain *>(toolchain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
             || m_abiWidget->currentAbi() != tc->targetAbi()
@@ -790,7 +790,7 @@ void KeilToolchainConfigWidget::makeReadOnlyImpl()
 void KeilToolchainConfigWidget::setFromToolchain()
 {
     const QSignalBlocker blocker(this);
-    const auto tc = static_cast<KeilToolchain *>(toolChain());
+    const auto tc = static_cast<KeilToolchain *>(toolchain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_abiWidget->setAbis({}, tc->targetAbi());
diff --git a/src/plugins/baremetal/sdcctoolchain.cpp b/src/plugins/baremetal/sdcctoolchain.cpp
index dd8f10cf1a..cebee379f7 100644
--- a/src/plugins/baremetal/sdcctoolchain.cpp
+++ b/src/plugins/baremetal/sdcctoolchain.cpp
@@ -470,10 +470,10 @@ SdccToolchainConfigWidget::SdccToolchainConfigWidget(SdccToolchain *tc) :
 
 void SdccToolchainConfigWidget::applyImpl()
 {
-    if (toolChain()->isAutoDetected())
+    if (toolchain()->isAutoDetected())
         return;
 
-    const auto tc = static_cast<SdccToolchain *>(toolChain());
+    const auto tc = static_cast<SdccToolchain *>(toolchain());
     const QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
     tc->setTargetAbi(m_abiWidget->currentAbi());
@@ -490,7 +490,7 @@ void SdccToolchainConfigWidget::applyImpl()
 
 bool SdccToolchainConfigWidget::isDirtyImpl() const
 {
-    const auto tc = static_cast<SdccToolchain *>(toolChain());
+    const auto tc = static_cast<SdccToolchain *>(toolchain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_abiWidget->currentAbi() != tc->targetAbi()
             ;
@@ -505,7 +505,7 @@ void SdccToolchainConfigWidget::makeReadOnlyImpl()
 void SdccToolchainConfigWidget::setFromToolchain()
 {
     const QSignalBlocker blocker(this);
-    const auto tc = static_cast<SdccToolchain *>(toolChain());
+    const auto tc = static_cast<SdccToolchain *>(toolchain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_abiWidget->setAbis({}, tc->targetAbi());
     const bool haveCompiler = m_compilerCommand->filePath().isExecutableFile();
diff --git a/src/plugins/clangcodemodel/clangutils.cpp b/src/plugins/clangcodemodel/clangutils.cpp
index ce9f09126a..a9b19fa275 100644
--- a/src/plugins/clangcodemodel/clangutils.cpp
+++ b/src/plugins/clangcodemodel/clangutils.cpp
@@ -79,9 +79,9 @@ static QStringList projectPartArguments(const ProjectPart &projectPart)
     args << projectPart.compilerFilePath.toString();
     args << "-c";
     if (projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) {
-        args << "--target=" + projectPart.toolChainTargetTriple;
-        if (projectPart.toolChainAbi.architecture() == Abi::X86Architecture)
-            args << QLatin1String(projectPart.toolChainAbi.wordWidth() == 64 ? "-m64" : "-m32");
+        args << "--target=" + projectPart.toolchainTargetTriple;
+        if (projectPart.toolchainAbi.architecture() == Abi::X86Architecture)
+            args << QLatin1String(projectPart.toolchainAbi.wordWidth() == 64 ? "-m64" : "-m32");
     }
     args << projectPart.compilerFlags;
     for (const ProjectExplorer::HeaderPath &headerPath : projectPart.headerPaths) {
diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
index 3511f03135..53550adabe 100644
--- a/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
@@ -587,7 +587,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
 
 Toolchain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset)
 {
-    // A compiler path example. Note that the compiler version is not the same version from MsvcToolChain
+    // 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
     //
     // And the CMakePresets.json
@@ -996,7 +996,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
         SysRootKitAspect::setSysRoot(k, data->sysroot);
 
         for (const ToolchainDescription &cmtcd : data->toolchains) {
-            const ToolchainData tcd = findOrCreateToolChains(cmtcd);
+            const ToolchainData tcd = findOrCreateToolchains(cmtcd);
             QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
 
             if (tcd.areTemporary) {
diff --git a/src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp b/src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp
index 06bd741d47..b2a2995f30 100644
--- a/src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp
+++ b/src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp
@@ -68,7 +68,7 @@ void CompilationDatabaseTests::testProject()
     const CppEditor::ProjectPart &projectPart = *projectParts.first();
     QVERIFY(!projectPart.headerPaths.isEmpty());
     QVERIFY(!projectPart.projectMacros.isEmpty());
-    QVERIFY(!projectPart.toolChainMacros.isEmpty());
+    QVERIFY(!projectPart.toolchainMacros.isEmpty());
     QVERIFY(!projectPart.files.isEmpty());
 }
 
diff --git a/src/plugins/cppeditor/builtineditordocumentparser.cpp b/src/plugins/cppeditor/builtineditordocumentparser.cpp
index 7c8444098e..627e36d3b3 100644
--- a/src/plugins/cppeditor/builtineditordocumentparser.cpp
+++ b/src/plugins/cppeditor/builtineditordocumentparser.cpp
@@ -80,7 +80,7 @@ void BuiltinEditorDocumentParser::updateImpl(const QPromise<void> &promise,
     }
 
     if (const ProjectPart::ConstPtr part = baseState.projectPartInfo.projectPart) {
-        configFile += ProjectExplorer::Macro::toByteArray(part->toolChainMacros);
+        configFile += ProjectExplorer::Macro::toByteArray(part->toolchainMacros);
         configFile += overwrittenToolchainDefines(*part.data());
         configFile += ProjectExplorer::Macro::toByteArray(part->projectMacros);
         if (!part->projectConfigFile.isEmpty())
diff --git a/src/plugins/cppeditor/compileroptionsbuilder.cpp b/src/plugins/cppeditor/compileroptionsbuilder.cpp
index 12403bd153..be40b9c914 100644
--- a/src/plugins/cppeditor/compileroptionsbuilder.cpp
+++ b/src/plugins/cppeditor/compileroptionsbuilder.cpp
@@ -234,9 +234,9 @@ QStringList createLanguageOptionGcc(Language language, ProjectFile::Kind fileKin
 
 void CompilerOptionsBuilder::addWordWidth()
 {
-    if (m_projectPart.toolChainAbi.architecture() != Abi::X86Architecture)
+    if (m_projectPart.toolchainAbi.architecture() != Abi::X86Architecture)
         return;
-    const QString argument = m_projectPart.toolChainAbi.wordWidth() == 64
+    const QString argument = m_projectPart.toolchainAbi.wordWidth() == 64
                                  ? QLatin1String("-m64")
                                  : QLatin1String("-m32");
     add(argument);
@@ -250,7 +250,7 @@ void CompilerOptionsBuilder::addTargetTriple()
     }
 
     const QString target = m_explicitTarget.isEmpty() || m_projectPart.targetTripleIsAuthoritative
-            ? m_projectPart.toolChainTargetTriple : m_explicitTarget;
+            ? m_projectPart.toolchainTargetTriple : m_explicitTarget;
 
     // Only "--target=" style is accepted in both g++ and cl driver modes.
     if (!target.isEmpty())
@@ -284,7 +284,7 @@ void CompilerOptionsBuilder::addMsvcExceptions()
 {
     if (!m_clStyle)
         return;
-    if (Utils::anyOf(m_projectPart.toolChainMacros, [](const Macro &macro) {
+    if (Utils::anyOf(m_projectPart.toolchainMacros, [](const Macro &macro) {
         return macro.key == "_CPPUNWIND";
     })) {
         enableExceptions();
@@ -421,7 +421,7 @@ void CompilerOptionsBuilder::addProjectMacros()
     if (m_projectPart.toolchainType == ProjectExplorer::Constants::CUSTOM_TOOLCHAIN_TYPEID
         || m_projectPart.toolchainType == Qnx::Constants::QNX_TOOLCHAIN_ID
         || m_projectPart.toolchainType.name().contains("BareMetal") || useMacros) {
-        addMacros(m_projectPart.toolChainMacros);
+        addMacros(m_projectPart.toolchainMacros);
     }
 
     addMacros(m_projectPart.projectMacros);
@@ -579,7 +579,7 @@ static QByteArray msCompatibilityVersionFromDefines(const Macros &macros)
 
 QByteArray CompilerOptionsBuilder::msvcVersion() const
 {
-    const QByteArray version = msCompatibilityVersionFromDefines(m_projectPart.toolChainMacros);
+    const QByteArray version = msCompatibilityVersionFromDefines(m_projectPart.toolchainMacros);
     return !version.isEmpty() ? version
                               : msCompatibilityVersionFromDefines(m_projectPart.projectMacros);
 }
diff --git a/src/plugins/cppeditor/compileroptionsbuilder.h b/src/plugins/cppeditor/compileroptionsbuilder.h
index 55d775120a..3a8c1446a5 100644
--- a/src/plugins/cppeditor/compileroptionsbuilder.h
+++ b/src/plugins/cppeditor/compileroptionsbuilder.h
@@ -69,7 +69,6 @@ public:
     void prepend(const QString &arg);
     void add(const QStringList &args, bool gccOnlyOptions = false);
 
-    static UseToolchainMacros useToolChainMacros();
     void reset();
 
     void evaluateCompilerFlags();
diff --git a/src/plugins/cppeditor/compileroptionsbuilder_test.cpp b/src/plugins/cppeditor/compileroptionsbuilder_test.cpp
index 9a94ba8651..ed53ef9922 100644
--- a/src/plugins/cppeditor/compileroptionsbuilder_test.cpp
+++ b/src/plugins/cppeditor/compileroptionsbuilder_test.cpp
@@ -43,7 +43,7 @@ public:
             tcInfo.abi = Abi(Abi::X86Architecture, Abi::DarwinOS, Abi::FreeBsdFlavor,
                              Abi::MachOFormat, 64);
         }
-        tcInfo.isMsvc2015ToolChain = isMsvc2015;
+        tcInfo.isMsvc2015Toolchain = isMsvc2015;
         tcInfo.extraCodeModelFlags = extraFlags;
         tcInfo.macroInspectionRunner = [this](const QStringList &) {
             return Toolchain::MacroInspectionReport{toolchainMacros, languageVersion};
diff --git a/src/plugins/cppeditor/cppcodemodelinspectordialog.cpp b/src/plugins/cppeditor/cppcodemodelinspectordialog.cpp
index 0b4c5d9af3..542edbd57a 100644
--- a/src/plugins/cppeditor/cppcodemodelinspectordialog.cpp
+++ b/src/plugins/cppeditor/cppcodemodelinspectordialog.cpp
@@ -1937,9 +1937,9 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Const
         {QString::fromLatin1("Buildsystem Target"), buildSystemTarget},
         {QString::fromLatin1("Build Target Type"), CMI::Utils::toString(part->buildTargetType)},
         {QString::fromLatin1("ToolChain Type"), part->toolchainType.toString()},
-        {QString::fromLatin1("ToolChain Target Triple"), part->toolChainTargetTriple},
-        {QString::fromLatin1("ToolChain Word Width"), CMI::Utils::toString(part->toolChainAbi.wordWidth())},
-        {QString::fromLatin1("ToolChain Install Dir"), part->toolChainInstallDir.toString()},
+        {QString::fromLatin1("ToolChain Target Triple"), part->toolchainTargetTriple},
+        {QString::fromLatin1("ToolChain Word Width"), CMI::Utils::toString(part->toolchainAbi.wordWidth())},
+        {QString::fromLatin1("ToolChain Install Dir"), part->toolchainInstallDir.toString()},
         {QString::fromLatin1("Language Version"), CMI::Utils::toString(part->languageVersion)},
         {QString::fromLatin1("Language Extensions"), CMI::Utils::toString(part->languageExtensions)},
         {QString::fromLatin1("Qt Version"), CMI::Utils::toString(part->qtVersion)}
@@ -1957,9 +1957,9 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Const
     m_projectPartTab->setTabText(ProjectPartFilesTab,
         partTabName(ProjectPartFilesTab, part->files.size()));
 
-    int numberOfDefines = defineCount(part->toolChainMacros) + defineCount(part->projectMacros);
+    int numberOfDefines = defineCount(part->toolchainMacros) + defineCount(part->projectMacros);
 
-    m_partToolchainDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->toolChainMacros)));
+    m_partToolchainDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->toolchainMacros)));
     m_partProjectDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->projectMacros)));
     m_projectPartTab->setTabText(ProjectPartDefinesTab,
         partTabName(ProjectPartDefinesTab, numberOfDefines));
diff --git a/src/plugins/cppeditor/cppcodemodelinspectordumper.cpp b/src/plugins/cppeditor/cppcodemodelinspectordumper.cpp
index 28d96779d6..4a9cff3454 100644
--- a/src/plugins/cppeditor/cppcodemodelinspectordumper.cpp
+++ b/src/plugins/cppeditor/cppcodemodelinspectordumper.cpp
@@ -515,9 +515,9 @@ void Dumper::dumpProjectInfos(const QList<ProjectInfo::ConstPtr> &projectInfos)
             m_out << i3 << "Project Name           : " << projectName << "\n";
             m_out << i3 << "Project File           : " << projectFilePath << "\n";
             m_out << i3 << "ToolChain Type         : " << part->toolchainType.toString() << "\n";
-            m_out << i3 << "ToolChain Target Triple: " << part->toolChainTargetTriple << "\n";
-            m_out << i3 << "ToolChain Word Width   : " << part->toolChainAbi.wordWidth() << "\n";
-            m_out << i3 << "ToolChain Install Dir  : " << part->toolChainInstallDir << "\n";
+            m_out << i3 << "ToolChain Target Triple: " << part->toolchainTargetTriple << "\n";
+            m_out << i3 << "ToolChain Word Width   : " << part->toolchainAbi.wordWidth() << "\n";
+            m_out << i3 << "ToolChain Install Dir  : " << part->toolchainInstallDir << "\n";
             m_out << i3 << "Compiler Flags         : " << part->compilerFlags.join(", ") << "\n";
             m_out << i3 << "Selected For Building  : " << part->selectedForBuilding << "\n";
             m_out << i3 << "Build System Target    : " << part->buildSystemTarget << "\n";
@@ -537,10 +537,10 @@ void Dumper::dumpProjectInfos(const QList<ProjectInfo::ConstPtr> &projectInfos)
                 }
             }
 
-            if (!part->toolChainMacros.isEmpty()) {
+            if (!part->toolchainMacros.isEmpty()) {
                 m_out << i3 << "Toolchain Defines:{{{4\n";
                 const QList<QByteArray> defineLines =
-                        ProjectExplorer::Macro::toByteArray(part->toolChainMacros).split('\n');
+                        ProjectExplorer::Macro::toByteArray(part->toolchainMacros).split('\n');
                 for (const QByteArray &defineLine : defineLines)
                     m_out << i4 << defineLine << "\n";
             }
diff --git a/src/plugins/cppeditor/cppmodelmanager.cpp b/src/plugins/cppeditor/cppmodelmanager.cpp
index 67470745bb..ed2c0419ab 100644
--- a/src/plugins/cppeditor/cppmodelmanager.cpp
+++ b/src/plugins/cppeditor/cppmodelmanager.cpp
@@ -1134,7 +1134,7 @@ Macros CppModelManagerPrivate::internalDefinedMacros(SyncedProjectData &ld)
     QSet<ProjectExplorer::Macro> alreadyIn;
     for (const ProjectData &projectData : std::as_const(ld.m_projectData)) {
         for (const ProjectPart::ConstPtr &part : projectData.projectInfo->projectParts()) {
-            addUnique(part->toolChainMacros, macros, alreadyIn);
+            addUnique(part->toolchainMacros, macros, alreadyIn);
             addUnique(part->projectMacros, macros, alreadyIn);
         }
     }
diff --git a/src/plugins/cppeditor/headerpathfilter.cpp b/src/plugins/cppeditor/headerpathfilter.cpp
index bc1625643f..f1f8addd76 100644
--- a/src/plugins/cppeditor/headerpathfilter.cpp
+++ b/src/plugins/cppeditor/headerpathfilter.cpp
@@ -44,10 +44,10 @@ void HeaderPathFilter::removeGccInternalIncludePaths()
         return;
     }
 
-    if (projectPart.toolChainInstallDir.isEmpty())
+    if (projectPart.toolchainInstallDir.isEmpty())
         return;
 
-    const Utils::FilePath gccInstallDir = projectPart.toolChainInstallDir;
+    const Utils::FilePath gccInstallDir = projectPart.toolchainInstallDir;
     auto isGccInternalInclude = [gccInstallDir](const HeaderPath &headerPath) {
         const auto filePath = Utils::FilePath::fromString(headerPath.path);
         return filePath == gccInstallDir.pathAppended("include")
diff --git a/src/plugins/cppeditor/projectinfo.cpp b/src/plugins/cppeditor/projectinfo.cpp
index d7b0b58a7a..57466d1cd9 100644
--- a/src/plugins/cppeditor/projectinfo.cpp
+++ b/src/plugins/cppeditor/projectinfo.cpp
@@ -64,7 +64,7 @@ static ProjectExplorer::Macros getDefines(const QVector<ProjectPart::ConstPtr> &
 {
     ProjectExplorer::Macros defines;
     for (const ProjectPart::ConstPtr &part : projectParts) {
-        defines.append(part->toolChainMacros);
+        defines.append(part->toolchainMacros);
         defines.append(part->projectMacros);
     }
     return defines;
diff --git a/src/plugins/cppeditor/projectinfo_test.cpp b/src/plugins/cppeditor/projectinfo_test.cpp
index d7bcd99a1f..19c869c148 100644
--- a/src/plugins/cppeditor/projectinfo_test.cpp
+++ b/src/plugins/cppeditor/projectinfo_test.cpp
@@ -355,9 +355,9 @@ class ProjectInfoGeneratorTestHelper
 public:
     ProjectInfoGeneratorTestHelper()
     {
-        TestToolchain aToolChain;
-        projectUpdateInfo.cxxToolchainInfo = {&aToolChain, {}, {}};
-        projectUpdateInfo.cToolchainInfo = {&aToolChain, {}, {}};
+        TestToolchain toolchain;
+        projectUpdateInfo.cxxToolchainInfo = {&toolchain, {}, {}};
+        projectUpdateInfo.cToolchainInfo = {&toolchain, {}, {}};
     }
 
     ProjectInfo::ConstPtr generate()
diff --git a/src/plugins/cppeditor/projectpart.cpp b/src/plugins/cppeditor/projectpart.cpp
index be33d77a9d..680723750f 100644
--- a/src/plugins/cppeditor/projectpart.cpp
+++ b/src/plugins/cppeditor/projectpart.cpp
@@ -142,11 +142,11 @@ ProjectPart::ProjectPart(const Utils::FilePath &topLevelProject,
       buildTargetType(rpp.buildTargetType),
       selectedForBuilding(rpp.selectedForBuilding),
       toolchainType(tcInfo.type),
-      isMsvc2015Toolchain(tcInfo.isMsvc2015ToolChain),
-      toolChainTargetTriple(tcInfo.targetTriple),
+      isMsvc2015Toolchain(tcInfo.isMsvc2015Toolchain),
+      toolchainTargetTriple(tcInfo.targetTriple),
       targetTripleIsAuthoritative(tcInfo.targetTripleIsAuthoritative),
-      toolChainAbi(tcInfo.abi),
-      toolChainInstallDir(tcInfo.installDir),
+      toolchainAbi(tcInfo.abi),
+      toolchainInstallDir(tcInfo.installDir),
       compilerFilePath(tcInfo.compilerFilePath),
       warningFlags(flags.warningFlags),
       extraCodeModelFlags(tcInfo.extraCodeModelFlags),
diff --git a/src/plugins/cppeditor/projectpart.h b/src/plugins/cppeditor/projectpart.h
index 459f8eb1c7..a55adb2a0c 100644
--- a/src/plugins/cppeditor/projectpart.h
+++ b/src/plugins/cppeditor/projectpart.h
@@ -76,7 +76,7 @@ public:
 
     // Macros
     const ProjectExplorer::Macros projectMacros;
-    const ProjectExplorer::Macros &toolChainMacros = m_macroReport.macros;
+    const ProjectExplorer::Macros &toolchainMacros = m_macroReport.macros;
 
     // Build system
     const QString buildSystemTarget;
@@ -84,13 +84,13 @@ public:
         = ProjectExplorer::BuildTargetType::Unknown;
     const bool selectedForBuilding = true;
 
-    // ToolChain
+    // Toolchain
     const Utils::Id toolchainType;
     const bool isMsvc2015Toolchain = false;
-    const QString toolChainTargetTriple;
+    const QString toolchainTargetTriple;
     const bool targetTripleIsAuthoritative;
-    const ProjectExplorer::Abi toolChainAbi = ProjectExplorer::Abi::hostAbi();
-    const Utils::FilePath toolChainInstallDir;
+    const ProjectExplorer::Abi toolchainAbi = ProjectExplorer::Abi::hostAbi();
+    const Utils::FilePath toolchainInstallDir;
     const Utils::FilePath compilerFilePath;
     const Utils::WarningFlags warningFlags = Utils::WarningFlags::Default;
 
diff --git a/src/plugins/debugger/debuggerplugin.cpp b/src/plugins/debugger/debuggerplugin.cpp
index 6496666c9d..66128f2557 100644
--- a/src/plugins/debugger/debuggerplugin.cpp
+++ b/src/plugins/debugger/debuggerplugin.cpp
@@ -2368,7 +2368,7 @@ void DebuggerUnitTests::initTestCase()
 //    const QList<Kit *> allKits = KitManager::kits();
 //    if (allKits.count() != 1)
 //        QSKIP("This test requires exactly one kit to be present");
-//    const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first());
+//    const Toolchain * const toolchain = ToolchainKitAspect::toolchain(allKits.first());
 //    if (!toolchain)
 //        QSKIP("This test requires that there is a kit with a toolchain.");
 //    bool hasClangExecutable;
diff --git a/src/plugins/debugger/gdb/gdbengine.cpp b/src/plugins/debugger/gdb/gdbengine.cpp
index 6359293a67..4e56bc6e0f 100644
--- a/src/plugins/debugger/gdb/gdbengine.cpp
+++ b/src/plugins/debugger/gdb/gdbengine.cpp
@@ -1724,7 +1724,7 @@ void GdbEngine::handleThreadGroupExited(const GdbMi &result)
     }
 }
 
-static QString msgNoGdbBinaryForToolChain(const Abi &tc)
+static QString msgNoGdbBinaryForToolchain(const Abi &tc)
 {
     return Tr::tr("There is no GDB binary available for binaries in format \"%1\".")
         .arg(tc.toString());
@@ -3833,7 +3833,7 @@ void GdbEngine::setupEngine()
     if (rp.debugger.command.isEmpty()) {
         handleGdbStartFailed();
         handleAdapterStartFailed(
-            msgNoGdbBinaryForToolChain(rp.toolChainAbi),
+            msgNoGdbBinaryForToolchain(rp.toolChainAbi),
             Constants::DEBUGGER_COMMON_SETTINGS_ID);
         return;
     }
diff --git a/src/plugins/docker/kitdetector.cpp b/src/plugins/docker/kitdetector.cpp
index 72b7678a93..df1d0f7b8b 100644
--- a/src/plugins/docker/kitdetector.cpp
+++ b/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,10 +107,10 @@ void KitDetectorPrivate::undoAutoDetect() const
 
     emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Removing toolchain entries..."));
     const Toolchains toolchains = ToolchainManager::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);
+    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,9 +164,9 @@ void KitDetectorPrivate::listAutoDetected() const
     }
 
     emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Toolchains:"));
-    for (Toolchain *toolChain : ToolchainManager::toolchains()) {
-        if (toolChain->detectionSource() == m_sharedId)
-            emit q->logOutput(toolChain->displayName());
+    for (Toolchain *toolchain : ToolchainManager::toolchains()) {
+        if (toolchain->detectionSource() == m_sharedId)
+            emit q->logOutput(toolchain->displayName());
     }
 
     if (QObject *cmakeManager = ExtensionSystem::PluginManager::getObjectByName(
@@ -247,29 +247,29 @@ QtVersions KitDetectorPrivate::autoDetectQtVersions() const
     return qtVersions;
 }
 
-Toolchains KitDetectorPrivate::autoDetectToolChains()
+Toolchains KitDetectorPrivate::autoDetectToolchains()
 {
     const QList<ToolchainFactory *> factories = ToolchainFactory::allToolchainFactories();
 
     Toolchains alreadyKnown = ToolchainManager::toolchains();
-    Toolchains allNewToolChains;
+    Toolchains allNewToolchains;
     QApplication::processEvents();
     emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Searching toolchains..."));
     for (ToolchainFactory *factory : factories) {
         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) {
-            emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput()));
-            toolChain->setDetectionSource(m_sharedId);
-            ToolchainManager::registerToolchain(toolChain);
-            alreadyKnown.append(toolChain);
+        const Toolchains newToolchains = factory->autoDetect(detector);
+        for (Toolchain *toolchain : newToolchains) {
+            emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolchain->compilerCommand().toUserOutput()));
+            toolchain->setDetectionSource(m_sharedId);
+            ToolchainManager::registerToolchain(toolchain);
+            alreadyKnown.append(toolchain);
         }
-        allNewToolChains.append(newToolChains);
+        allNewToolchains.append(newToolchains);
     }
-    emit q->logOutput(ProjectExplorer::Tr::tr("%1 new toolchains found.").arg(allNewToolChains.size()));
+    emit q->logOutput(ProjectExplorer::Tr::tr("%1 new toolchains found.").arg(allNewToolchains.size()));
 
-    return allNewToolChains;
+    return allNewToolchains;
 }
 
 void KitDetectorPrivate::autoDetectPython()
@@ -333,7 +333,7 @@ void KitDetectorPrivate::autoDetect()
 
     emit q->logOutput(ProjectExplorer::Tr::tr("Starting auto-detection. This will take a while..."));
 
-    const Toolchains toolchains = autoDetectToolChains();
+    const Toolchains toolchains = autoDetectToolchains();
     const QtVersions qtVersions = autoDetectQtVersions();
 
     const QList<Id> cmakeIds = autoDetectCMake();
@@ -363,8 +363,8 @@ void KitDetectorPrivate::autoDetect()
             return tc->detectionSource() == m_sharedId
                    && (!qt || qt->qtAbis().contains(tc->targetAbi()));
         });
-        for (Toolchain *toolChain : toolchainsToSet)
-            ToolchainKitAspect::setToolchain(k, toolChain);
+        for (Toolchain *toolchain : toolchainsToSet)
+            ToolchainKitAspect::setToolchain(k, toolchain);
 
         if (cmakeId.isValid())
             k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true);
diff --git a/src/plugins/ios/iosconfigurations.cpp b/src/plugins/ios/iosconfigurations.cpp
index 69ccce01de..f098f7f141 100644
--- a/src/plugins/ios/iosconfigurations.cpp
+++ b/src/plugins/ios/iosconfigurations.cpp
@@ -61,7 +61,7 @@ static Q_LOGGING_CATEGORY(kitSetupLog, "qtc.ios.kitSetup", QtWarningMsg)
 static Q_LOGGING_CATEGORY(iosCommonLog, "qtc.ios.common", QtWarningMsg)
 }
 
-using ToolChainPair = std::pair<GccToolchain *, GccToolchain *>;
+using ToolchainPair = std::pair<GccToolchain *, GccToolchain *>;
 namespace Ios {
 namespace Internal {
 
@@ -98,57 +98,57 @@ static bool isSimulatorDeviceId(const Id &id)
     return id == Constants::IOS_SIMULATOR_TYPE;
 }
 
-static QList<GccToolchain *> clangToolChains(const Toolchains &toolChains)
+static QList<GccToolchain *> clangToolchains(const Toolchains &toolchains)
 {
-    QList<GccToolchain *> clangToolChains;
-    for (Toolchain *toolChain : toolChains)
-        if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
-            clangToolChains.append(static_cast<GccToolchain *>(toolChain));
-    return clangToolChains;
+    QList<GccToolchain *> clangToolchains;
+    for (Toolchain *toolchain : toolchains)
+        if (toolchain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
+            clangToolchains.append(static_cast<GccToolchain *>(toolchain));
+    return clangToolchains;
 }
 
-static QList<GccToolchain *> autoDetectedIosToolChains()
+static QList<GccToolchain *> autoDetectedIosToolchains()
 {
-    const QList<GccToolchain *> toolChains = clangToolChains(ToolchainManager::toolchains());
-    return filtered(toolChains, [](GccToolchain *toolChain) {
+    const QList<GccToolchain *> toolchains = clangToolchains(ToolchainManager::toolchains());
+    return filtered(toolchains, [](GccToolchain *toolChain) {
         return toolChain->isAutoDetected()
                && (toolChain->displayName().startsWith("iphone")
                    || toolChain->displayName().startsWith("Apple Clang")); // TODO tool chains should be marked directly
     });
 }
 
-static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform,
+static ToolchainPair findToolchainForPlatform(const XcodePlatform &platform,
                                               const XcodePlatform::ToolchainTarget &target,
-                                              const QList<GccToolchain *> &toolChains)
+                                              const QList<GccToolchain *> &toolchains)
 {
-    ToolChainPair platformToolChains;
+    ToolchainPair platformToolchains;
     auto toolchainMatch = [](GccToolchain *toolChain, const FilePath &compilerPath, const QStringList &flags) {
         return compilerPath == toolChain->compilerCommand()
                 && flags == toolChain->platformCodeGenFlags()
                 && flags == toolChain->platformLinkerFlags();
     };
-    platformToolChains.first = findOrDefault(toolChains, std::bind(toolchainMatch, std::placeholders::_1,
+    platformToolchains.first = findOrDefault(toolchains, std::bind(toolchainMatch, std::placeholders::_1,
                                                                   platform.cCompilerPath,
                                                                   target.backendFlags));
-    platformToolChains.second = findOrDefault(toolChains, std::bind(toolchainMatch, std::placeholders::_1,
+    platformToolchains.second = findOrDefault(toolchains, std::bind(toolchainMatch, std::placeholders::_1,
                                                                    platform.cxxCompilerPath,
                                                                    target.backendFlags));
-    return platformToolChains;
+    return platformToolchains;
 }
 
-static QHash<XcodePlatform::ToolchainTarget, ToolChainPair> findToolChains(const QList<XcodePlatform> &platforms)
+static QHash<XcodePlatform::ToolchainTarget, ToolchainPair> findToolchains(const QList<XcodePlatform> &platforms)
 {
-    QHash<XcodePlatform::ToolchainTarget, ToolChainPair> platformToolChainHash;
-    const QList<GccToolchain *> toolChains = autoDetectedIosToolChains();
+    QHash<XcodePlatform::ToolchainTarget, ToolchainPair> platformToolchainHash;
+    const QList<GccToolchain *> toolchains = autoDetectedIosToolchains();
     for (const XcodePlatform &platform : platforms) {
         for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
-            ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
-                                                                        toolChains);
+            ToolchainPair platformToolchains = findToolchainForPlatform(platform, target,
+                                                                        toolchains);
             if (platformToolchains.first || platformToolchains.second)
-                platformToolChainHash.insert(target, platformToolchains);
+                platformToolchainHash.insert(target, platformToolchains);
         }
     }
-    return platformToolChainHash;
+    return platformToolchainHash;
 }
 
 static QSet<Kit *> existingAutoDetectedIosKits()
@@ -166,16 +166,16 @@ static void printKits(const QSet<Kit *> &kits)
         qCDebug(kitSetupLog) << "  -" << kit->displayName();
 }
 
-static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains,
+static void setupKit(Kit *kit, Id pDeviceType, const ToolchainPair& toolchains,
                      const QVariant &debuggerId, const FilePath &sdkPath, QtVersion *qtVersion)
 {
     DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
-    if (toolChains.first)
-        ToolchainKitAspect::setToolchain(kit, toolChains.first);
+    if (toolchains.first)
+        ToolchainKitAspect::setToolchain(kit, toolchains.first);
     else
         ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
-    if (toolChains.second)
-        ToolchainKitAspect::setToolchain(kit, toolChains.second);
+    if (toolchains.second)
+        ToolchainKitAspect::setToolchain(kit, toolchains.second);
     else
         ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
@@ -232,7 +232,7 @@ void IosConfigurations::updateAutomaticKitList()
     qCDebug(kitSetupLog) << "Developer path:" << developerPath();
 
     // target -> tool chain
-    const auto targetToolChainHash = findToolChains(platforms);
+    const auto targetToolchainHash = findToolchains(platforms);
 
     const auto qtVersions = toSet(QtVersionManager::versions([](const QtVersion *v) {
         return v->isValid() && v->type() == Constants::IOSQT;
@@ -256,7 +256,7 @@ void IosConfigurations::updateAutomaticKitList()
 
             const auto target = targets.front();
 
-            const ToolChainPair &platformToolchains = targetToolChainHash.value(target);
+            const ToolchainPair &platformToolchains = targetToolchainHash.value(target);
             if (!platformToolchains.first && !platformToolchains.second) {
                 qCDebug(kitSetupLog) << "  - No tool chain found";
                 continue;
@@ -586,13 +586,13 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
     if (detector.device->type() != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
         return {};
 
-    QList<GccToolchain *> existingClangToolChains = clangToolChains(detector.alreadyKnown);
+    QList<GccToolchain *> existingClangToolChains = clangToolchains(detector.alreadyKnown);
     const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values();
-    Toolchains toolChains;
-    toolChains.reserve(platforms.size());
+    Toolchains toolchains;
+    toolchains.reserve(platforms.size());
     for (const XcodePlatform &platform : platforms) {
         for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
-            ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
+            ToolchainPair platformToolchains = findToolchainForPlatform(platform, target,
                                                                         existingClangToolChains);
             auto createOrAdd = [&](GccToolchain *toolChain, Id l) {
                 if (!toolChain) {
@@ -608,14 +608,14 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
                                                   platform.cxxCompilerPath : platform.cCompilerPath);
                     existingClangToolChains.append(toolChain);
                 }
-                toolChains.append(toolChain);
+                toolchains.append(toolChain);
             };
 
             createOrAdd(platformToolchains.first, ProjectExplorer::Constants::C_LANGUAGE_ID);
             createOrAdd(platformToolchains.second, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
         }
     }
-    return toolChains;
+    return toolchains;
 }
 
 void setupIosToolchain()
diff --git a/src/plugins/nim/project/nimtoolchain.cpp b/src/plugins/nim/project/nimtoolchain.cpp
index a248a9118f..e0ef172fff 100644
--- a/src/plugins/nim/project/nimtoolchain.cpp
+++ b/src/plugins/nim/project/nimtoolchain.cpp
@@ -120,10 +120,10 @@ bool NimToolChain::parseVersion(const FilePath &path, std::tuple<int, int, int>
 
 // NimToolchainConfigWidget
 
-class NimToolChainConfigWidget : public ToolchainConfigWidget
+class NimToolchainConfigWidget : public ToolchainConfigWidget
 {
 public:
-    explicit NimToolChainConfigWidget(NimToolChain *tc)
+    explicit NimToolchainConfigWidget(NimToolChain *tc)
         : ToolchainConfigWidget(tc)
         , m_compilerCommand(new PathChooser)
         , m_compilerVersion(new QLineEdit)
@@ -142,7 +142,7 @@ public:
         // Connect
         connect(m_compilerCommand, &PathChooser::validChanged, this, [this] {
             const FilePath path = m_compilerCommand->rawFilePath();
-            auto tc = static_cast<NimToolChain *>(toolChain());
+            auto tc = static_cast<NimToolChain *>(toolchain());
             QTC_ASSERT(tc, return);
             tc->setCompilerCommand(path);
             fillUI();
@@ -162,35 +162,35 @@ private:
     QLineEdit *m_compilerVersion;
 };
 
-void NimToolChainConfigWidget::applyImpl()
+void NimToolchainConfigWidget::applyImpl()
 {
-    auto tc = static_cast<NimToolChain *>(toolChain());
+    auto tc = static_cast<NimToolChain *>(toolchain());
     Q_ASSERT(tc);
     if (tc->isAutoDetected())
         return;
     tc->setCompilerCommand(m_compilerCommand->filePath());
 }
 
-void NimToolChainConfigWidget::discardImpl()
+void NimToolchainConfigWidget::discardImpl()
 {
     fillUI();
 }
 
-bool NimToolChainConfigWidget::isDirtyImpl() const
+bool NimToolchainConfigWidget::isDirtyImpl() const
 {
-    auto tc = static_cast<NimToolChain *>(toolChain());
+    auto tc = static_cast<NimToolChain *>(toolchain());
     Q_ASSERT(tc);
     return tc->compilerCommand() != m_compilerCommand->filePath();
 }
 
-void NimToolChainConfigWidget::makeReadOnlyImpl()
+void NimToolchainConfigWidget::makeReadOnlyImpl()
 {
     m_compilerCommand->setReadOnly(true);
 }
 
-void NimToolChainConfigWidget::fillUI()
+void NimToolchainConfigWidget::fillUI()
 {
-    auto tc = static_cast<NimToolChain *>(toolChain());
+    auto tc = static_cast<NimToolChain *>(toolchain());
     Q_ASSERT(tc);
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_compilerVersion->setText(tc->compilerVersion());
@@ -198,7 +198,7 @@ void NimToolChainConfigWidget::fillUI()
 
 std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget()
 {
-    return std::make_unique<NimToolChainConfigWidget>(this);
+    return std::make_unique<NimToolchainConfigWidget>(this);
 }
 
 // NimToolchainFactory
diff --git a/src/plugins/projectexplorer/customtoolchain.cpp b/src/plugins/projectexplorer/customtoolchain.cpp
index c38efd5466..1eda6750c2 100644
--- a/src/plugins/projectexplorer/customtoolchain.cpp
+++ b/src/plugins/projectexplorer/customtoolchain.cpp
@@ -488,10 +488,10 @@ void CustomToolChainConfigWidget::errorParserChanged(int )
 
 void CustomToolChainConfigWidget::applyImpl()
 {
-    if (toolChain()->isAutoDetected())
+    if (toolchain()->isAutoDetected())
         return;
 
-    auto tc = static_cast<CustomToolChain *>(toolChain());
+    auto tc = static_cast<CustomToolChain *>(toolchain());
     Q_ASSERT(tc);
     QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -517,7 +517,7 @@ void CustomToolChainConfigWidget::setFromToolchain()
 {
     // subwidgets are not yet connected!
     QSignalBlocker blocker(this);
-    auto tc = static_cast<CustomToolChain *>(toolChain());
+    auto tc = static_cast<CustomToolChain *>(toolchain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_makeCommand->setFilePath(tc->makeCommand(Environment()));
     m_abiWidget->setAbis(Abis(), tc->targetAbi());
@@ -534,7 +534,7 @@ void CustomToolChainConfigWidget::setFromToolchain()
 
 bool CustomToolChainConfigWidget::isDirtyImpl() const
 {
-    auto tc = static_cast<CustomToolChain *>(toolChain());
+    auto tc = static_cast<CustomToolChain *>(toolchain());
     Q_ASSERT(tc);
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_makeCommand->filePath().toString() != tc->makeCommand(Environment()).toString()
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index 35c0428dba..b89a16a247 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -1770,7 +1770,7 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
             }));
         m_parentToolChainConnections.append(
             connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
-                if (tc->id() == toolChain()->id()) {
+                if (tc->id() == toolchain()->id()) {
                     for (QMetaObject::Connection &connection : m_parentToolChainConnections)
                         QObject::disconnect(connection);
                     return;
@@ -1785,10 +1785,10 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
 
 void GccToolchainConfigWidget::applyImpl()
 {
-    if (toolChain()->isAutoDetected())
+    if (toolchain()->isAutoDetected())
         return;
 
-    auto tc = static_cast<GccToolchain *>(toolChain());
+    auto tc = static_cast<GccToolchain *>(toolchain());
     Q_ASSERT(tc);
     QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -1834,7 +1834,7 @@ void GccToolchainConfigWidget::setFromToolchain()
 {
     // subwidgets are not yet connected!
     QSignalBlocker blocker(this);
-    auto tc = static_cast<GccToolchain *>(toolChain());
+    auto tc = static_cast<GccToolchain *>(toolchain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags(),
                                                                   HostOsInfo::hostOs()));
@@ -1852,7 +1852,7 @@ void GccToolchainConfigWidget::setFromToolchain()
 
 bool GccToolchainConfigWidget::isDirtyImpl() const
 {
-    auto tc = static_cast<GccToolchain *>(toolChain());
+    auto tc = static_cast<GccToolchain *>(toolchain());
 
     if (m_compilerCommand->filePath() != tc->compilerCommand()
            || m_platformCodeGenFlagsLineEdit->text()
@@ -2030,7 +2030,7 @@ void GccToolchainConfigWidget::updateParentToolChainComboBox()
 {
     QTC_ASSERT(m_parentToolchainCombo, return);
 
-    auto *tc = static_cast<GccToolchain *>(toolChain());
+    auto *tc = static_cast<GccToolchain *>(toolchain());
     QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
     if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
         parentId = tc->m_parentToolchainId;
diff --git a/src/plugins/projectexplorer/msvctoolchain.cpp b/src/plugins/projectexplorer/msvctoolchain.cpp
index aadd2d2e51..4bc11180bd 100644
--- a/src/plugins/projectexplorer/msvctoolchain.cpp
+++ b/src/plugins/projectexplorer/msvctoolchain.cpp
@@ -1285,7 +1285,7 @@ protected:
 
     void setFromMsvcToolChain()
     {
-        const auto *tc = static_cast<const MsvcToolChain *>(toolChain());
+        const auto *tc = static_cast<const MsvcToolChain *>(toolchain());
         QTC_ASSERT(tc, return );
         m_nameDisplayLabel->setText(tc->displayName());
         m_varsBatDisplayLabel->setText(msvcVarsToDisplay(*tc));
@@ -1382,7 +1382,7 @@ private:
 
 void MsvcToolChainConfigWidget::applyImpl()
 {
-    auto *tc = static_cast<MsvcToolChain *>(toolChain());
+    auto *tc = static_cast<MsvcToolChain *>(toolchain());
     QTC_ASSERT(tc, return );
     const QString vcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText());
     tc->setupVarsBat(m_abiWidget->currentAbi(), vcVars, vcVarsArguments());
@@ -1396,7 +1396,7 @@ void MsvcToolChainConfigWidget::discardImpl()
 
 bool MsvcToolChainConfigWidget::isDirtyImpl() const
 {
-    auto msvcToolChain = static_cast<MsvcToolChain *>(toolChain());
+    auto msvcToolChain = static_cast<MsvcToolChain *>(toolchain());
 
     return msvcToolChain->varsBat() != QDir::fromNativeSeparators(m_varsBatPathCombo->currentText())
             || msvcToolChain->varsBatArg() != vcVarsArguments()
@@ -1413,7 +1413,7 @@ void MsvcToolChainConfigWidget::makeReadOnlyImpl()
 
 void MsvcToolChainConfigWidget::setFromMsvcToolChain()
 {
-    const auto *tc = static_cast<const MsvcToolChain *>(toolChain());
+    const auto *tc = static_cast<const MsvcToolChain *>(toolchain());
     QTC_ASSERT(tc, return );
     m_nameDisplayLabel->setText(tc->displayName());
     QString args = tc->varsBatArg();
@@ -1434,7 +1434,7 @@ void MsvcToolChainConfigWidget::setFromMsvcToolChain()
 void MsvcToolChainConfigWidget::updateAbis()
 {
     const QString normalizedVcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText());
-    const auto *currentTc = static_cast<const MsvcToolChain *>(toolChain());
+    const auto *currentTc = static_cast<const MsvcToolChain *>(toolchain());
     QTC_ASSERT(currentTc, return );
     const MsvcToolChain::Platform platform = m_varsBatArchCombo->currentData().value<MsvcToolChain::Platform>();
     const Abi::Architecture arch = archForPlatform(platform);
@@ -1564,7 +1564,7 @@ private:
 
 void ClangClToolChainConfigWidget::setFromClangClToolChain()
 {
-    const auto *currentTC = static_cast<const MsvcToolChain *>(toolChain());
+    const auto *currentTC = static_cast<const MsvcToolChain *>(toolchain());
     m_nameDisplayLabel->setText(currentTC->displayName());
     m_varsBatDisplayCombo->clear();
     m_varsBatDisplayCombo->addItem(msvcVarsToDisplay(*currentTC));
@@ -1574,7 +1574,7 @@ void ClangClToolChainConfigWidget::setFromClangClToolChain()
             m_varsBatDisplayCombo->addItem(varsToDisplay);
     }
 
-    const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolChain());
+    const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolchain());
     if (clangClToolChain->isAutoDetected())
         m_llvmDirLabel->setText(clangClToolChain->clangPath().toUserOutput());
     else
@@ -1696,7 +1696,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
 void ClangClToolChainConfigWidget::applyImpl()
 {
     Utils::FilePath clangClPath = m_compilerCommand->filePath();
-    auto clangClToolChain = static_cast<ClangClToolChain *>(toolChain());
+    auto clangClToolChain = static_cast<ClangClToolChain *>(toolchain());
     clangClToolChain->setClangPath(clangClPath);
 
     if (clangClPath.fileName() != "clang-cl.exe") {
diff --git a/src/plugins/projectexplorer/projectimporter.cpp b/src/plugins/projectexplorer/projectimporter.cpp
index 07b57eb4de..d1239088b7 100644
--- a/src/plugins/projectexplorer/projectimporter.cpp
+++ b/src/plugins/projectexplorer/projectimporter.cpp
@@ -386,7 +386,7 @@ static ProjectImporter::ToolchainData createToolChains(const ToolchainDescriptio
 }
 
 ProjectImporter::ToolchainData
-ProjectImporter::findOrCreateToolChains(const ToolchainDescription &tcd) const
+ProjectImporter::findOrCreateToolchains(const ToolchainDescription &tcd) const
 {
     ToolchainData result;
     result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) {
diff --git a/src/plugins/projectexplorer/projectimporter.h b/src/plugins/projectexplorer/projectimporter.h
index cc9a9040e1..f5d563c0e6 100644
--- a/src/plugins/projectexplorer/projectimporter.h
+++ b/src/plugins/projectexplorer/projectimporter.h
@@ -87,7 +87,7 @@ protected:
     // Does *any* kit feature the requested data yet?
     bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const;
 
-    ToolchainData findOrCreateToolChains(const ToolchainDescription &tcd) const;
+    ToolchainData findOrCreateToolchains(const ToolchainDescription &tcd) const;
 
 private:
     void markKitAsTemporary(Kit *k) const;
diff --git a/src/plugins/projectexplorer/rawprojectpart.cpp b/src/plugins/projectexplorer/rawprojectpart.cpp
index 8d3493ae9a..38c695f6d8 100644
--- a/src/plugins/projectexplorer/rawprojectpart.cpp
+++ b/src/plugins/projectexplorer/rawprojectpart.cpp
@@ -162,7 +162,7 @@ ToolchainInfo::ToolchainInfo(const Toolchain *toolChain,
     if (toolChain) {
         // Keep the following cheap/non-blocking for the ui thread...
         type = toolChain->typeId();
-        isMsvc2015ToolChain = toolChain->targetAbi().osFlavor() == Abi::WindowsMsvc2015Flavor;
+        isMsvc2015Toolchain = toolChain->targetAbi().osFlavor() == Abi::WindowsMsvc2015Flavor;
         abi = toolChain->targetAbi();
         targetTriple = toolChain->effectiveCodeModelTargetTriple();
         targetTripleIsAuthoritative = !toolChain->explicitCodeModelTargetTriple().isEmpty();
diff --git a/src/plugins/projectexplorer/rawprojectpart.h b/src/plugins/projectexplorer/rawprojectpart.h
index f4cb947d54..75503170da 100644
--- a/src/plugins/projectexplorer/rawprojectpart.h
+++ b/src/plugins/projectexplorer/rawprojectpart.h
@@ -139,7 +139,7 @@ public:
 
 public:
     Utils::Id type;
-    bool isMsvc2015ToolChain = false;
+    bool isMsvc2015Toolchain = false;
     bool targetTripleIsAuthoritative = false;
     Abi abi;
     QString targetTriple;
diff --git a/src/plugins/projectexplorer/toolchainconfigwidget.cpp b/src/plugins/projectexplorer/toolchainconfigwidget.cpp
index 9ba30dc2af..c7ce623b50 100644
--- a/src/plugins/projectexplorer/toolchainconfigwidget.cpp
+++ b/src/plugins/projectexplorer/toolchainconfigwidget.cpp
@@ -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;
 }
diff --git a/src/plugins/projectexplorer/toolchainconfigwidget.h b/src/plugins/projectexplorer/toolchainconfigwidget.h
index 6ab8cb1581..02257ef571 100644
--- a/src/plugins/projectexplorer/toolchainconfigwidget.h
+++ b/src/plugins/projectexplorer/toolchainconfigwidget.h
@@ -28,7 +28,7 @@ class PROJECTEXPLORER_EXPORT ToolchainConfigWidget : public QScrollArea
 public:
     explicit ToolchainConfigWidget(Toolchain *tc);
 
-    Toolchain *toolChain() const;
+    Toolchain *toolchain() const;
 
     void apply();
     void discard();
diff --git a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp b/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
index a3a607b550..b6cf1b2f51 100644
--- a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
+++ b/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
@@ -185,9 +185,9 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
     return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
         QList<ToolchainData> tcData;
         if (!bgData->cxxCompilerPath.isEmpty())
-            tcData << findOrCreateToolChains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
+            tcData << findOrCreateToolchains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
         if (!bgData->cCompilerPath.isEmpty())
-            tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
+            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());
diff --git a/src/plugins/qnx/qnxsettingspage.cpp b/src/plugins/qnx/qnxsettingspage.cpp
index 81e01afbcb..a2948ed94a 100644
--- a/src/plugins/qnx/qnxsettingspage.cpp
+++ b/src/plugins/qnx/qnxsettingspage.cpp
@@ -231,7 +231,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;
+        auto toolChain = new QnxToolchain;
         toolChain->setDetection(Toolchain::ManualDetection);
         toolChain->setLanguage(language);
         toolChain->setTargetAbi(target.m_abi);
diff --git a/src/plugins/qnx/qnxtoolchain.cpp b/src/plugins/qnx/qnxtoolchain.cpp
index cbcd93912e..c2fda32405 100644
--- a/src/plugins/qnx/qnxtoolchain.cpp
+++ b/src/plugins/qnx/qnxtoolchain.cpp
@@ -22,12 +22,12 @@ using namespace Utils;
 
 namespace Qnx::Internal {
 
-// QnxToolChainConfigWidget
+// QnxToolchainConfigWidget
 
-class QnxToolChainConfigWidget : public ToolchainConfigWidget
+class QnxToolchainConfigWidget : public ToolchainConfigWidget
 {
 public:
-    QnxToolChainConfigWidget(QnxToolChain *tc);
+    QnxToolchainConfigWidget(QnxToolchain *tc);
 
 private:
     void applyImpl() override;
@@ -97,17 +97,17 @@ static QStringList reinterpretOptions(const QStringList &args)
     return arguments;
 }
 
-QnxToolChain::QnxToolChain()
+QnxToolchain::QnxToolchain()
     : GccToolchain(Constants::QNX_TOOLCHAIN_ID)
 {
     setOptionsReinterpreter(&reinterpretOptions);
     setTypeDisplayName(Tr::tr("QCC"));
 
     sdpPath.setSettingsKey("Qnx.QnxToolChain.NDKPath");
-    connect(&sdpPath, &BaseAspect::changed, this, &QnxToolChain::toolChainUpdated);
+    connect(&sdpPath, &BaseAspect::changed, this, &QnxToolchain::toolChainUpdated);
 
     cpuDir.setSettingsKey("Qnx.QnxToolChain.CpuDir");
-    connect(&cpuDir, &BaseAspect::changed, this, &QnxToolChain::toolChainUpdated);
+    connect(&cpuDir, &BaseAspect::changed, this, &QnxToolchain::toolChainUpdated);
 
     connect(this, &AspectContainer::fromMapFinished, this, [this] {
         // Make the ABIs QNX specific (if they aren't already).
@@ -116,12 +116,12 @@ QnxToolChain::QnxToolChain()
     });
 }
 
-std::unique_ptr<ToolchainConfigWidget> QnxToolChain::createConfigurationWidget()
+std::unique_ptr<ToolchainConfigWidget> QnxToolchain::createConfigurationWidget()
 {
-    return std::make_unique<QnxToolChainConfigWidget>(this);
+    return std::make_unique<QnxToolchainConfigWidget>(this);
 }
 
-void QnxToolChain::addToEnvironment(Environment &env) const
+void QnxToolchain::addToEnvironment(Environment &env) const
 {
     if (env.expandedValueForKey("QNX_HOST").isEmpty() ||
         env.expandedValueForKey("QNX_TARGET").isEmpty() ||
@@ -131,7 +131,7 @@ void QnxToolChain::addToEnvironment(Environment &env) const
     GccToolchain::addToEnvironment(env);
 }
 
-QStringList QnxToolChain::suggestedMkspecList() const
+QStringList QnxToolchain::suggestedMkspecList() const
 {
     return {
         "qnx-armle-v7-qcc",
@@ -141,7 +141,7 @@ QStringList QnxToolChain::suggestedMkspecList() const
     };
 }
 
-GccToolchain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
+GccToolchain::DetectedAbisResult QnxToolchain::detectSupportedAbis() const
 {
     // "unknown-qnx-gnu"is needed to get the "--target=xxx" parameter sent code model,
     // which gets translated as "x86_64-qnx-gnu", which gets Clang to happily parse
@@ -152,12 +152,12 @@ 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;
 
-    auto qnxTc = static_cast<const QnxToolChain *>(&other);
+    auto qnxTc = static_cast<const QnxToolchain *>(&other);
 
     return sdpPath() == qnxTc->sdpPath() && cpuDir() == qnxTc->cpuDir();
 }
@@ -166,7 +166,7 @@ bool QnxToolChain::operator ==(const Toolchain &other) const
 // QnxToolChainConfigWidget
 //---------------------------------------------------------------------------------
 
-QnxToolChainConfigWidget::QnxToolChainConfigWidget(QnxToolChain *tc)
+QnxToolchainConfigWidget::QnxToolchainConfigWidget(QnxToolchain *tc)
     : ToolchainConfigWidget(tc)
     , m_compilerCommand(new PathChooser)
     , m_sdpPath(new PathChooser)
@@ -193,16 +193,16 @@ QnxToolChainConfigWidget::QnxToolChainConfigWidget(QnxToolChain *tc)
 
     connect(m_compilerCommand, &PathChooser::rawPathChanged, this, &ToolchainConfigWidget::dirty);
     connect(m_sdpPath, &PathChooser::rawPathChanged,
-            this, &QnxToolChainConfigWidget::handleSdpPathChange);
+            this, &QnxToolchainConfigWidget::handleSdpPathChange);
     connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty);
 }
 
-void QnxToolChainConfigWidget::applyImpl()
+void QnxToolchainConfigWidget::applyImpl()
 {
-    if (toolChain()->isAutoDetected())
+    if (toolchain()->isAutoDetected())
         return;
 
-    auto tc = static_cast<QnxToolChain *>(toolChain());
+    auto tc = static_cast<QnxToolchain *>(toolchain());
     Q_ASSERT(tc);
     QString displayName = tc->displayName();
     tc->setDisplayName(displayName); // reset display name
@@ -211,11 +211,11 @@ void QnxToolChainConfigWidget::applyImpl()
     tc->resetToolchain(m_compilerCommand->filePath());
 }
 
-void QnxToolChainConfigWidget::discardImpl()
+void QnxToolchainConfigWidget::discardImpl()
 {
     // subwidgets are not yet connected!
     QSignalBlocker blocker(this);
-    auto tc = static_cast<const QnxToolChain *>(toolChain());
+    auto tc = static_cast<const QnxToolchain *>(toolchain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_sdpPath->setFilePath(tc->sdpPath());
     m_abiWidget->setAbis(tc->supportedAbis(), tc->targetAbi());
@@ -223,16 +223,16 @@ void QnxToolChainConfigWidget::discardImpl()
         m_abiWidget->setEnabled(true);
 }
 
-bool QnxToolChainConfigWidget::isDirtyImpl() const
+bool QnxToolchainConfigWidget::isDirtyImpl() const
 {
-    auto tc = static_cast<const QnxToolChain *>(toolChain());
+    auto tc = static_cast<const QnxToolchain *>(toolchain());
     Q_ASSERT(tc);
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_sdpPath->filePath() != tc->sdpPath()
             || m_abiWidget->currentAbi() != tc->targetAbi();
 }
 
-void QnxToolChainConfigWidget::handleSdpPathChange()
+void QnxToolchainConfigWidget::handleSdpPathChange()
 {
     const Abi currentAbi = m_abiWidget->currentAbi();
     const bool customAbi = m_abiWidget->isCustomAbi();
@@ -262,7 +262,7 @@ public:
         setSupportedToolchainType(Constants::QNX_TOOLCHAIN_ID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
-        setToolchainConstructor([] { return new QnxToolChain; });
+        setToolchainConstructor([] { return new QnxToolchain; });
         setUserCreatable(true);
     }
 
diff --git a/src/plugins/qnx/qnxtoolchain.h b/src/plugins/qnx/qnxtoolchain.h
index 92fdb4483c..674a94c932 100644
--- a/src/plugins/qnx/qnxtoolchain.h
+++ b/src/plugins/qnx/qnxtoolchain.h
@@ -7,10 +7,10 @@
 
 namespace Qnx::Internal {
 
-class QnxToolChain : public ProjectExplorer::GccToolchain
+class QnxToolchain : public ProjectExplorer::GccToolchain
 {
 public:
-    QnxToolChain();
+    QnxToolchain();
 
     std::unique_ptr<ProjectExplorer::ToolchainConfigWidget> createConfigurationWidget() override;