diff --git a/src/plugins/android/androidtoolchain.cpp b/src/plugins/android/androidtoolchain.cpp
index da67dd1ed6a..576490d3859 100644
--- a/src/plugins/android/androidtoolchain.cpp
+++ b/src/plugins/android/androidtoolchain.cpp
@@ -47,7 +47,7 @@ static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &
 }
 
 AndroidToolChain::AndroidToolChain()
-    : GccToolChain(Constants::ANDROID_TOOLCHAIN_TYPEID, Clang)
+    : GccToolchain(Constants::ANDROID_TOOLCHAIN_TYPEID, Clang)
 {
     setTypeDisplayName(Tr::tr("Android Clang"));
 }
@@ -80,7 +80,7 @@ bool AndroidToolChain::isValid() const
     const bool isChildofSdk = compilerCommand().isChildOf(
         AndroidConfigurations::currentConfig().sdkLocation());
 
-    return GccToolChain::isValid() && typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
+    return GccToolchain::isValid() && typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
            && targetAbi().isValid() && (isChildofNdk || isChildofSdk)
            && !originalTargetTriple().isEmpty();
 }
@@ -104,7 +104,7 @@ void AndroidToolChain::addToEnvironment(Environment &env) const
 
 void AndroidToolChain::fromMap(const Store &data)
 {
-    GccToolChain::fromMap(data);
+    GccToolchain::fromMap(data);
     if (hasError())
         return;
     if (!isValid())
@@ -123,13 +123,13 @@ FilePath AndroidToolChain::makeCommand(const Environment &env) const
     return makePath.exists() ? makePath : FilePath("make");
 }
 
-GccToolChain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
+GccToolchain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
 {
     for (auto itr = ClangTargets->constBegin(); itr != ClangTargets->constEnd(); ++itr) {
         if (itr.value() == targetAbi())
-            return GccToolChain::DetectedAbisResult({targetAbi()}, itr.key());
+            return GccToolchain::DetectedAbisResult({targetAbi()}, itr.key());
     }
-    return GccToolChain::DetectedAbisResult({targetAbi()}, "");
+    return GccToolchain::DetectedAbisResult({targetAbi()}, "");
 }
 
 
@@ -238,7 +238,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
 
                 // Do not only reset newly created toolchains. This triggers call to
                 // addToEnvironment, so that e.g. JAVA_HOME gets updated.
-                if (auto gccTc = dynamic_cast<GccToolChain*>(tc))
+                if (auto gccTc = dynamic_cast<GccToolchain*>(tc))
                     gccTc->resetToolChain(compilerCommand);
 
                 tc->setDetection(Toolchain::AutoDetection);
diff --git a/src/plugins/android/androidtoolchain.h b/src/plugins/android/androidtoolchain.h
index 1e966b0ec7a..a9b00af44c5 100644
--- a/src/plugins/android/androidtoolchain.h
+++ b/src/plugins/android/androidtoolchain.h
@@ -11,7 +11,7 @@ namespace Android::Internal {
 
 using ToolChainList = QList<ProjectExplorer::Toolchain *>;
 
-class AndroidToolChain : public ProjectExplorer::GccToolChain
+class AndroidToolChain : public ProjectExplorer::GccToolchain
 {
 public:
     ~AndroidToolChain() override;
diff --git a/src/plugins/cppeditor/cppmodelmanager.cpp b/src/plugins/cppeditor/cppmodelmanager.cpp
index ac5c76ba0a7..97c3523925b 100644
--- a/src/plugins/cppeditor/cppmodelmanager.cpp
+++ b/src/plugins/cppeditor/cppmodelmanager.cpp
@@ -421,7 +421,7 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
         return;
     }
 
-    const bool isGcc = dynamic_cast<const GccToolChain *>(tc);
+    const bool isGcc = dynamic_cast<const GccToolchain *>(tc);
     const bool isMsvc = !isGcc
             && (tc->typeId() == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID
                 || tc->typeId() == ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID);
diff --git a/src/plugins/ios/iosbuildstep.cpp b/src/plugins/ios/iosbuildstep.cpp
index 8b692d493fd..dd3c88c3330 100644
--- a/src/plugins/ios/iosbuildstep.cpp
+++ b/src/plugins/ios/iosbuildstep.cpp
@@ -211,7 +211,7 @@ QStringList IosBuildStep::defaultArguments() const
     }
     if (tc->typeId() == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID
             || tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) {
-        auto gtc = static_cast<GccToolChain *>(tc);
+        auto gtc = static_cast<GccToolchain *>(tc);
         res << gtc->platformCodeGenFlags();
     }
     if (!SysRootKitAspect::sysRoot(kit).isEmpty())
diff --git a/src/plugins/ios/iosconfigurations.cpp b/src/plugins/ios/iosconfigurations.cpp
index a999fa82b1c..b91ee63e6b9 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,19 +98,19 @@ 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;
+    QList<GccToolchain *> clangToolChains;
     for (Toolchain *toolChain : toolChains)
         if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
-            clangToolChains.append(static_cast<GccToolChain *>(toolChain));
+            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
@@ -119,10 +119,10 @@ static QList<GccToolChain *> autoDetectedIosToolChains()
 
 static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform,
                                               const XcodePlatform::ToolchainTarget &target,
-                                              const QList<GccToolChain *> &toolChains)
+                                              const QList<GccToolchain *> &toolChains)
 {
     ToolChainPair platformToolChains;
-    auto toolchainMatch = [](GccToolChain *toolChain, const FilePath &compilerPath, const QStringList &flags) {
+    auto toolchainMatch = [](GccToolchain *toolChain, const FilePath &compilerPath, const QStringList &flags) {
         return compilerPath == toolChain->compilerCommand()
                 && flags == toolChain->platformCodeGenFlags()
                 && flags == toolChain->platformLinkerFlags();
@@ -139,7 +139,7 @@ static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform,
 static QHash<XcodePlatform::ToolchainTarget, ToolChainPair> findToolChains(const QList<XcodePlatform> &platforms)
 {
     QHash<XcodePlatform::ToolchainTarget, ToolChainPair> platformToolChainHash;
-    const QList<GccToolChain *> toolChains = autoDetectedIosToolChains();
+    const QList<GccToolchain *> toolChains = autoDetectedIosToolChains();
     for (const XcodePlatform &platform : platforms) {
         for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
             ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
@@ -581,7 +581,7 @@ 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());
@@ -589,10 +589,10 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
         for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
             ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
                                                                         existingClangToolChains);
-            auto createOrAdd = [&](GccToolChain *toolChain, Id l) {
+            auto createOrAdd = [&](GccToolchain *toolChain, Id l) {
                 if (!toolChain) {
-                    toolChain = new GccToolChain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
-                                                 GccToolChain::Clang);
+                    toolChain = new GccToolchain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
+                                                 GccToolchain::Clang);
                     toolChain->setPriority(Toolchain::PriorityHigh);
                     toolChain->setDetection(Toolchain::AutoDetection);
                     toolChain->setLanguage(l);
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index a3f2605e93f..69b2e555726 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -104,10 +104,10 @@ const QStringList gccPredefinedMacrosOptions(Id languageId)
 }
 
 class TargetTripleWidget;
-class GccToolChainConfigWidget : public ToolchainConfigWidget
+class GccToolchainConfigWidget : public ToolchainConfigWidget
 {
 public:
-    explicit GccToolChainConfigWidget(GccToolChain *tc);
+    explicit GccToolchainConfigWidget(GccToolchain *tc);
 
 private:
     void handleCompilerCommandChange();
@@ -125,7 +125,7 @@ private:
 
     AbiWidget *m_abiWidget;
 
-    GccToolChain::SubType m_subType = GccToolChain::RealGcc;
+    GccToolchain::SubType m_subType = GccToolchain::RealGcc;
 
     PathChooser *m_compilerCommand;
     QLineEdit *m_platformCodeGenFlagsLineEdit;
@@ -206,7 +206,7 @@ static ProjectExplorer::Macros gccPredefinedMacros(const FilePath &gcc,
     return predefinedMacros;
 }
 
-HeaderPaths GccToolChain::gccHeaderPaths(const FilePath &gcc,
+HeaderPaths GccToolchain::gccHeaderPaths(const FilePath &gcc,
                                          const QStringList &arguments,
                                          const Environment &env)
 {
@@ -293,13 +293,13 @@ static Abis guessGccAbi(const QString &m, const ProjectExplorer::Macros &macros)
 }
 
 
-static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path,
+static GccToolchain::DetectedAbisResult guessGccAbi(const FilePath &path,
                                                     const Environment &env,
                                                     const Macros &macros,
                                                     const QStringList &extraArgs = {})
 {
     if (path.isEmpty())
-        return GccToolChain::DetectedAbisResult();
+        return GccToolchain::DetectedAbisResult();
 
     QStringList arguments = extraArgs;
     arguments << "-dumpmachine";
@@ -307,10 +307,10 @@ static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path,
     if (machine.isEmpty()) {
         // ICC does not implement the -dumpmachine option on macOS.
         if (HostOsInfo::isMacHost() && (path.fileName() == "icc" || path.fileName() == "icpc"))
-            return GccToolChain::DetectedAbisResult({Abi::hostAbi()});
-        return GccToolChain::DetectedAbisResult(); // no need to continue if running failed once...
+            return GccToolchain::DetectedAbisResult({Abi::hostAbi()});
+        return GccToolchain::DetectedAbisResult(); // no need to continue if running failed once...
     }
-    return GccToolChain::DetectedAbisResult(guessGccAbi(machine, macros), machine);
+    return GccToolchain::DetectedAbisResult(guessGccAbi(machine, macros), machine);
 }
 
 static QString gccVersion(const FilePath &path,
@@ -343,26 +343,26 @@ static FilePath gccInstallDir(const FilePath &compiler,
 }
 
 // --------------------------------------------------------------------------
-// GccToolChain
+// GccToolchain
 // --------------------------------------------------------------------------
 
-static Id idForSubType(GccToolChain::SubType subType)
+static Id idForSubType(GccToolchain::SubType subType)
 {
     switch (subType) {
-    case GccToolChain::RealGcc:
+    case GccToolchain::RealGcc:
         return Constants::GCC_TOOLCHAIN_TYPEID;
-    case GccToolChain::Clang:
+    case GccToolchain::Clang:
         return Constants::CLANG_TOOLCHAIN_TYPEID;
-    case GccToolChain::MinGW:
+    case GccToolchain::MinGW:
         return Constants::MINGW_TOOLCHAIN_TYPEID;
-    case GccToolChain::LinuxIcc:
+    case GccToolchain::LinuxIcc:
         return Constants::LINUXICC_TOOLCHAIN_TYPEID;
     }
     QTC_CHECK(false);
     return Constants::GCC_TOOLCHAIN_TYPEID;
 }
 
-GccToolChain::GccToolChain(Id typeId, SubType subType)
+GccToolchain::GccToolchain(Id typeId, SubType subType)
     : Toolchain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
 {
     setTypeDisplayName(Tr::tr("GCC"));
@@ -378,7 +378,7 @@ GccToolChain::GccToolChain(Id typeId, SubType subType)
     }
 }
 
-GccToolChain::~GccToolChain()
+GccToolchain::~GccToolchain()
 {
     if (m_subType == Clang) {
         QObject::disconnect(m_thisToolchainRemovedConnection);
@@ -386,7 +386,7 @@ GccToolChain::~GccToolChain()
     }
 }
 
-void GccToolChain::setSupportedAbis(const Abis &abis)
+void GccToolchain::setSupportedAbis(const Abis &abis)
 {
     if (m_supportedAbis == abis)
         return;
@@ -395,7 +395,7 @@ void GccToolChain::setSupportedAbis(const Abis &abis)
     toolChainUpdated();
 }
 
-void GccToolChain::setOriginalTargetTriple(const QString &targetTriple)
+void GccToolchain::setOriginalTargetTriple(const QString &targetTriple)
 {
     if (m_originalTargetTriple == targetTriple)
         return;
@@ -404,7 +404,7 @@ void GccToolChain::setOriginalTargetTriple(const QString &targetTriple)
     toolChainUpdated();
 }
 
-void GccToolChain::setInstallDir(const FilePath &installDir)
+void GccToolchain::setInstallDir(const FilePath &installDir)
 {
     if (m_installDir == installDir)
         return;
@@ -413,7 +413,7 @@ void GccToolChain::setInstallDir(const FilePath &installDir)
     toolChainUpdated();
 }
 
-QString GccToolChain::defaultDisplayName() const
+QString GccToolchain::defaultDisplayName() const
 {
     QString type = typeDisplayName();
     const QRegularExpression regexp(binaryRegexp);
@@ -430,7 +430,7 @@ QString GccToolChain::defaultDisplayName() const
                                           compilerCommand().toUserOutput());
 }
 
-LanguageExtensions GccToolChain::defaultLanguageExtensions() const
+LanguageExtensions GccToolchain::defaultLanguageExtensions() const
 {
     return LanguageExtension::Gnu;
 }
@@ -442,23 +442,23 @@ static const Toolchains mingwToolChains()
     });
 }
 
-static const GccToolChain *mingwToolChainFromId(const QByteArray &id)
+static const GccToolchain *mingwToolChainFromId(const QByteArray &id)
 {
     if (id.isEmpty())
         return nullptr;
 
     for (const Toolchain *tc : mingwToolChains()) {
         if (tc->id() == id)
-            return static_cast<const GccToolChain *>(tc);
+            return static_cast<const GccToolchain *>(tc);
     }
 
     return nullptr;
 }
 
-QString GccToolChain::originalTargetTriple() const
+QString GccToolchain::originalTargetTriple() const
 {
     if (m_subType == Clang) {
-        if (const GccToolChain *parentTC = mingwToolChainFromId(m_parentToolChainId))
+        if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId))
             return parentTC->originalTargetTriple();
     }
 
@@ -467,21 +467,21 @@ QString GccToolChain::originalTargetTriple() const
     return m_originalTargetTriple;
 }
 
-QString GccToolChain::version() const
+QString GccToolchain::version() const
 {
     if (m_version.isEmpty())
         m_version = detectVersion();
     return m_version;
 }
 
-FilePath GccToolChain::installDir() const
+FilePath GccToolchain::installDir() const
 {
     if (m_installDir.isEmpty())
         m_installDir = detectInstallDir();
     return m_installDir;
 }
 
-Abis GccToolChain::supportedAbis() const
+Abis GccToolchain::supportedAbis() const
 {
     return m_supportedAbis;
 }
@@ -546,7 +546,7 @@ static QStringList filteredFlags(const QStringList &allFlags, bool considerSysro
     return filtered;
 }
 
-Toolchain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner GccToolchain::createMacroInspectionRunner() const
 {
     // Using a clean environment breaks ccache/distcc/etc.
     Environment env = compilerCommand().deviceEnvironment();
@@ -601,7 +601,7 @@ Toolchain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() con
  * @brief Parses gcc flags -std=*, -fopenmp, -fms-extensions.
  * @see http://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html
  */
-LanguageExtensions GccToolChain::languageExtensions(const QStringList &cxxflags) const
+LanguageExtensions GccToolchain::languageExtensions(const QStringList &cxxflags) const
 {
     LanguageExtensions extensions = defaultLanguageExtensions();
 
@@ -644,7 +644,7 @@ LanguageExtensions GccToolChain::languageExtensions(const QStringList &cxxflags)
     return extensions;
 }
 
-WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
+WarningFlags GccToolchain::warningFlags(const QStringList &cflags) const
 {
     // based on 'LC_ALL="en" gcc -Q --help=warnings | grep enabled'
     WarningFlags flags(WarningFlags::Deprecated | WarningFlags::IgnoredQualifiers
@@ -700,7 +700,7 @@ WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
     return flags;
 }
 
-FilePaths GccToolChain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const
+FilePaths GccToolchain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const
 {
     return Toolchain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
 }
@@ -724,12 +724,12 @@ static QStringList gccPrepareArguments(const QStringList &flags,
 }
 
 // NOTE: extraHeaderPathsFunction must NOT capture this or it's members!!!
-void GccToolChain::initExtraHeaderPathsFunction(ExtraHeaderPathsFunction &&extraHeaderPathsFunction) const
+void GccToolchain::initExtraHeaderPathsFunction(ExtraHeaderPathsFunction &&extraHeaderPathsFunction) const
 {
     m_extraHeaderPathsFunction = std::move(extraHeaderPathsFunction);
 }
 
-HeaderPaths GccToolChain::builtInHeaderPaths(const Environment &env,
+HeaderPaths GccToolchain::builtInHeaderPaths(const Environment &env,
                                              const FilePath &compilerCommand,
                                              const QStringList &platformCodeGenFlags,
                                              OptionsReinterpreter reinterpretOptions,
@@ -770,7 +770,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Environment &env,
     return paths;
 }
 
-Toolchain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner GccToolchain::createBuiltInHeaderPathsRunner(
         const Environment &env) const
 {
     // Using a clean environment breaks ccache/distcc/etc.
@@ -824,12 +824,12 @@ Toolchain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner
     };
 }
 
-void GccToolChain::addCommandPathToEnvironment(const FilePath &command, Environment &env)
+void GccToolchain::addCommandPathToEnvironment(const FilePath &command, Environment &env)
 {
     env.prependOrSetPath(command.parentDir());
 }
 
-void GccToolChain::addToEnvironment(Environment &env) const
+void GccToolchain::addToEnvironment(Environment &env) const
 {
     // On Windows gcc invokes cc1plus which is in libexec directory.
     // cc1plus depends on libwinpthread-1.dll which is in bin, so bin must be in the PATH.
@@ -849,7 +849,7 @@ void GccToolChain::addToEnvironment(Environment &env) const
     }
 }
 
-QStringList GccToolChain::suggestedMkspecList() const
+QStringList GccToolchain::suggestedMkspecList() const
 {
     if (m_subType == LinuxIcc)
         return {QString("linux-icc-%1").arg(targetAbi().wordWidth())};
@@ -930,7 +930,7 @@ static FilePath mingwAwareMakeCommand(const Environment &environment)
     return FilePath::fromString(makes.first());
 }
 
-FilePath GccToolChain::makeCommand(const Environment &environment) const
+FilePath GccToolchain::makeCommand(const Environment &environment) const
 {
     if (m_subType == Clang || m_subType == MinGW)
         return mingwAwareMakeCommand(environment);
@@ -939,7 +939,7 @@ FilePath GccToolChain::makeCommand(const Environment &environment) const
     return tmp.isEmpty() ? "make" : tmp;
 }
 
-QList<OutputLineParser *> GccToolChain::createOutputParsers() const
+QList<OutputLineParser *> GccToolchain::createOutputParsers() const
 {
     if (m_subType == LinuxIcc)
         return LinuxIccParser::iccParserSuite();
@@ -950,7 +950,7 @@ QList<OutputLineParser *> GccToolChain::createOutputParsers() const
     return GccParser::gccParserSuite();
 }
 
-void GccToolChain::resetToolChain(const FilePath &path)
+void GccToolchain::resetToolChain(const FilePath &path)
 {
     bool resetDisplayName = (displayName() == defaultDisplayName());
 
@@ -973,7 +973,7 @@ void GccToolChain::resetToolChain(const FilePath &path)
         toolChainUpdated();
 }
 
-void GccToolChain::setPlatformCodeGenFlags(const QStringList &flags)
+void GccToolchain::setPlatformCodeGenFlags(const QStringList &flags)
 {
     if (flags != m_platformCodeGenFlags) {
         m_platformCodeGenFlags = flags;
@@ -981,7 +981,7 @@ void GccToolChain::setPlatformCodeGenFlags(const QStringList &flags)
     }
 }
 
-QStringList GccToolChain::extraCodeModelFlags() const
+QStringList GccToolchain::extraCodeModelFlags() const
 {
     return platformCodeGenFlags();
 }
@@ -989,12 +989,12 @@ QStringList GccToolChain::extraCodeModelFlags() const
 /*!
     Code gen flags that have to be passed to the compiler.
  */
-QStringList GccToolChain::platformCodeGenFlags() const
+QStringList GccToolchain::platformCodeGenFlags() const
 {
     return m_platformCodeGenFlags;
 }
 
-void GccToolChain::setPlatformLinkerFlags(const QStringList &flags)
+void GccToolchain::setPlatformLinkerFlags(const QStringList &flags)
 {
     if (flags != m_platformLinkerFlags) {
         m_platformLinkerFlags = flags;
@@ -1007,12 +1007,12 @@ void GccToolChain::setPlatformLinkerFlags(const QStringList &flags)
 
     For example: \c{-arch armv7}
  */
-QStringList GccToolChain::platformLinkerFlags() const
+QStringList GccToolchain::platformLinkerFlags() const
 {
     return m_platformLinkerFlags;
 }
 
-void GccToolChain::toMap(Store &data) const
+void GccToolchain::toMap(Store &data) const
 {
     Toolchain::toMap(data);
     data.insert(compilerPlatformCodeGenFlagsKeyC, m_platformCodeGenFlags);
@@ -1026,7 +1026,7 @@ void GccToolChain::toMap(Store &data) const
     }
 }
 
-void GccToolChain::fromMap(const Store &data)
+void GccToolchain::fromMap(const Store &data)
 {
     Toolchain::fromMap(data);
     if (hasError())
@@ -1051,23 +1051,23 @@ void GccToolChain::fromMap(const Store &data)
     }
 }
 
-bool GccToolChain::operator ==(const Toolchain &other) const
+bool GccToolchain::operator ==(const Toolchain &other) const
 {
     if (!Toolchain::operator ==(other))
         return false;
 
-    auto gccTc = static_cast<const GccToolChain *>(&other);
+    auto gccTc = static_cast<const GccToolchain *>(&other);
     return compilerCommand() == gccTc->compilerCommand() && targetAbi() == gccTc->targetAbi()
             && m_platformCodeGenFlags == gccTc->m_platformCodeGenFlags
             && m_platformLinkerFlags == gccTc->m_platformLinkerFlags;
 }
 
-std::unique_ptr<ToolchainConfigWidget> GccToolChain::createConfigurationWidget()
+std::unique_ptr<ToolchainConfigWidget> GccToolchain::createConfigurationWidget()
 {
-    return std::make_unique<GccToolChainConfigWidget>(this);
+    return std::make_unique<GccToolchainConfigWidget>(this);
 }
 
-void GccToolChain::updateSupportedAbis() const
+void GccToolchain::updateSupportedAbis() const
 {
     if (m_supportedAbis.isEmpty()) {
         const DetectedAbisResult detected = detectSupportedAbis();
@@ -1076,12 +1076,12 @@ void GccToolChain::updateSupportedAbis() const
     }
 }
 
-void GccToolChain::setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter)
+void GccToolchain::setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter)
 {
     m_optionsReinterpreter = optionsReinterpreter;
 }
 
-GccToolChain::DetectedAbisResult GccToolChain::detectSupportedAbis() const
+GccToolchain::DetectedAbisResult GccToolchain::detectSupportedAbis() const
 {
     Environment env = compilerCommand().deviceEnvironment();
     addToEnvironment(env);
@@ -1092,7 +1092,7 @@ GccToolChain::DetectedAbisResult GccToolChain::detectSupportedAbis() const
                        platformCodeGenFlags());
 }
 
-QString GccToolChain::detectVersion() const
+QString GccToolchain::detectVersion() const
 {
     Environment env = compilerCommand().deviceEnvironment();
     addToEnvironment(env);
@@ -1100,7 +1100,7 @@ QString GccToolChain::detectVersion() const
                       filteredFlags(platformCodeGenFlags(), true));
 }
 
-FilePath GccToolChain::detectInstallDir() const
+FilePath GccToolchain::detectInstallDir() const
 {
     Environment env = compilerCommand().deviceEnvironment();
     addToEnvironment(env);
@@ -1256,22 +1256,22 @@ static Utils::FilePaths renesasRl78SearchPathsFromRegistry()
 
 static Toolchain *constructRealGccToolchain()
 {
-    return new GccToolChain(Constants::GCC_TOOLCHAIN_TYPEID, GccToolChain::RealGcc);
+    return new GccToolchain(Constants::GCC_TOOLCHAIN_TYPEID, GccToolchain::RealGcc);
 }
 
 static Toolchain *constructClangToolchain()
 {
-    return new GccToolChain(Constants::CLANG_TOOLCHAIN_TYPEID, GccToolChain::Clang);
+    return new GccToolchain(Constants::CLANG_TOOLCHAIN_TYPEID, GccToolchain::Clang);
 }
 
 static Toolchain *constructMinGWToolchain()
 {
-    return new GccToolChain(Constants::MINGW_TOOLCHAIN_TYPEID, GccToolChain::MinGW);
+    return new GccToolchain(Constants::MINGW_TOOLCHAIN_TYPEID, GccToolchain::MinGW);
 }
 
 static Toolchain *constructLinuxIccToolchain()
 {
-    return new GccToolChain(Constants::LINUXICC_TOOLCHAIN_TYPEID, GccToolChain::LinuxIcc);
+    return new GccToolchain(Constants::LINUXICC_TOOLCHAIN_TYPEID, GccToolchain::LinuxIcc);
 }
 
 namespace Internal {
@@ -1279,26 +1279,26 @@ namespace Internal {
 class GccToolchainFactory final : public ToolchainFactory
 {
 public:
-    explicit GccToolchainFactory(GccToolChain::SubType subType)
-        : m_autoDetecting(subType == GccToolChain::RealGcc)
+    explicit GccToolchainFactory(GccToolchain::SubType subType)
+        : m_autoDetecting(subType == GccToolchain::RealGcc)
     {
         switch (subType) {
-        case GccToolChain::RealGcc:
+        case GccToolchain::RealGcc:
             setDisplayName(Tr::tr("GCC"));
             setSupportedToolchainType(Constants::GCC_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructRealGccToolchain);
             break;
-        case GccToolChain::Clang:
+        case GccToolchain::Clang:
             setDisplayName(Tr::tr("Clang"));
             setSupportedToolchainType(Constants::CLANG_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructClangToolchain);
             break;
-        case GccToolChain::MinGW:
+        case GccToolchain::MinGW:
             setDisplayName(Tr::tr("MinGW"));
             setSupportedToolchainType(Constants::MINGW_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructMinGWToolchain);
             break;
-        case GccToolChain::LinuxIcc:
+        case GccToolchain::LinuxIcc:
             setDisplayName(Tr::tr("ICC"));
             setSupportedToolchainType(Constants::LINUXICC_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructLinuxIccToolchain);
@@ -1316,9 +1316,9 @@ private:
                                            const Id language,
                                            const Id requiredTypeId,
                                            const Toolchains &known,
-                                           const GccToolChain::SubType subType);
+                                           const GccToolchain::SubType subType);
     static Toolchains autoDetectToolChain(const ToolchainDescription &tcd,
-                                          const GccToolChain::SubType subType);
+                                          const GccToolchain::SubType subType);
     static Toolchains autoDetectSdkClangToolchain(const Toolchains &known);
 
     const bool m_autoDetecting;
@@ -1327,16 +1327,16 @@ private:
 void setupGccToolchains()
 {
 #ifndef Q_OS_WIN
-    static GccToolchainFactory theLinuxIccToolchainFactory{GccToolChain::LinuxIcc};
+    static GccToolchainFactory theLinuxIccToolchainFactory{GccToolchain::LinuxIcc};
 #endif
 
 #ifndef Q_OS_MACOS
     // Mingw offers cross-compiling to windows
-    static GccToolchainFactory theMingwToolchainFactory{GccToolChain::MinGW};
+    static GccToolchainFactory theMingwToolchainFactory{GccToolchain::MinGW};
 #endif
 
-    static GccToolchainFactory theGccToolchainFactory{GccToolChain::RealGcc};
-    static GccToolchainFactory theClangToolchainFactory{GccToolChain::Clang};
+    static GccToolchainFactory theGccToolchainFactory{GccToolchain::RealGcc};
+    static GccToolchainFactory theClangToolchainFactory{GccToolchain::Clang};
 }
 
 static FilePaths findCompilerCandidates(OsType os,
@@ -1458,14 +1458,14 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
                                    Constants::CXX_LANGUAGE_ID,
                                    Constants::LINUXICC_TOOLCHAIN_TYPEID,
                                    detector.alreadyKnown,
-                                   GccToolChain::LinuxIcc);
+                                   GccToolchain::LinuxIcc);
 
 
     result += autoDetectToolchains(findCompilerCandidates(os, executables, "icc", true),
                                    Constants::C_LANGUAGE_ID,
                                    Constants::LINUXICC_TOOLCHAIN_TYPEID,
                                    detector.alreadyKnown,
-                                   GccToolChain::LinuxIcc);
+                                   GccToolchain::LinuxIcc);
 
     // Clang
 
@@ -1476,12 +1476,12 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
                                     Constants::CXX_LANGUAGE_ID,
                                     Constants::CLANG_TOOLCHAIN_TYPEID,
                                     detector.alreadyKnown,
-                                    GccToolChain::Clang));
+                                    GccToolchain::Clang));
     tcs.append(autoDetectToolchains(findCompilerCandidates(os, executables, "clang", true),
                                     Constants::C_LANGUAGE_ID,
                                     Constants::CLANG_TOOLCHAIN_TYPEID,
                                     detector.alreadyKnown,
-                                    GccToolChain::Clang));
+                                    GccToolchain::Clang));
     known.append(tcs);
 
     tcs.append(autoDetectSdkClangToolchain(known));
@@ -1494,12 +1494,12 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
                                    Constants::CXX_LANGUAGE_ID,
                                    Constants::GCC_TOOLCHAIN_TYPEID,
                                    detector.alreadyKnown,
-                                   GccToolChain::RealGcc /*sic!*/);
+                                   GccToolchain::RealGcc /*sic!*/);
     result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true),
                                    Constants::C_LANGUAGE_ID,
                                    Constants::GCC_TOOLCHAIN_TYPEID,
                                    detector.alreadyKnown,
-                                   GccToolChain::RealGcc /*sic!*/);
+                                   GccToolchain::RealGcc /*sic!*/);
 
     return result;
 }
@@ -1519,7 +1519,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
 
     if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
         (tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc"))) {
-        result += autoDetectToolChain(tcd, GccToolChain::LinuxIcc);
+        result += autoDetectToolChain(tcd, GccToolchain::LinuxIcc);
     }
 
     bool isCCompiler = tcd.language == Constants::C_LANGUAGE_ID
@@ -1531,7 +1531,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
                                    || (fileName == "c++" && resolvedSymlinksFileName.contains("clang")));
 
     if (isCCompiler || isCxxCompiler)
-        result += autoDetectToolChain(tcd, GccToolChain::Clang);
+        result += autoDetectToolChain(tcd, GccToolchain::Clang);
 
     // GCC
 
@@ -1546,7 +1546,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
                 || (fileName == "c++" && !resolvedSymlinksFileName.contains("clang")));
 
     if (isCCompiler || isCxxCompiler)
-        result += autoDetectToolChain(tcd, GccToolChain::RealGcc);
+        result += autoDetectToolChain(tcd, GccToolchain::RealGcc);
 
     return result;
 }
@@ -1562,14 +1562,14 @@ Toolchains GccToolchainFactory::autoDetectSdkClangToolchain(const Toolchains &kn
             return {existingTc};
     }
 
-    return {autoDetectToolChain({compilerPath, Constants::C_LANGUAGE_ID}, GccToolChain::Clang)};
+    return {autoDetectToolChain({compilerPath, Constants::C_LANGUAGE_ID}, GccToolchain::Clang)};
 }
 
 Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPaths,
                                                      const Id language,
                                                      const Id requiredTypeId,
                                                      const Toolchains &known,
-                                                     const GccToolChain::SubType subType)
+                                                     const GccToolchain::SubType subType)
 {
     Toolchains existingCandidates = filtered(known,
             [language](const Toolchain *tc) { return tc->language() == language; });
@@ -1617,12 +1617,12 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
 }
 
 Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &tcd,
-                                                    GccToolChain::SubType subType)
+                                                    GccToolchain::SubType subType)
 {
     Toolchains result;
 
     Environment systemEnvironment = tcd.compilerPath.deviceEnvironment();
-    GccToolChain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment);
+    GccToolchain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment);
     const FilePath localCompilerPath = findLocalCompiler(tcd.compilerPath, systemEnvironment);
     if (ToolchainManager::isBadToolchain(localCompilerPath))
         return result;
@@ -1633,15 +1633,15 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &
         ToolchainManager::addBadToolchain(localCompilerPath);
         return result;
     }
-    const GccToolChain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath,
+    const GccToolchain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath,
                                                                       systemEnvironment,
                                                                       macros);
     for (const Abi &abi : detectedAbis.supportedAbis) {
-        GccToolChain::SubType detectedSubType = subType;
-        if (detectedSubType == GccToolChain::RealGcc && abi.osFlavor() == Abi::WindowsMSysFlavor)
-            detectedSubType = GccToolChain::MinGW;
+        GccToolchain::SubType detectedSubType = subType;
+        if (detectedSubType == GccToolchain::RealGcc && abi.osFlavor() == Abi::WindowsMSysFlavor)
+            detectedSubType = GccToolchain::MinGW;
 
-        auto tc = new GccToolChain({}, detectedSubType);
+        auto tc = new GccToolchain({}, detectedSubType);
 
         tc->setLanguage(tcd.language);
         tc->setDetection(Toolchain::AutoDetection);
@@ -1655,7 +1655,7 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &
         tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple);
         tc->setDisplayName(tc->defaultDisplayName()); // reset displayname
         // lower priority of g++/gcc on macOS - usually just a frontend to clang
-        if (detectedSubType == GccToolChain::RealGcc && abi.binaryFormat() == Abi::MachOFormat)
+        if (detectedSubType == GccToolchain::RealGcc && abi.binaryFormat() == Abi::MachOFormat)
             tc->setPriority(Toolchain::PriorityLow);
         result.append(tc);
     }
@@ -1663,7 +1663,7 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &
 }
 
 // --------------------------------------------------------------------------
-// GccToolChainConfigWidget
+// GccToolchainConfigWidget
 // --------------------------------------------------------------------------
 
 class TargetTripleWidget : public QWidget
@@ -1707,7 +1707,7 @@ private:
 };
 }
 
-GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
+GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
     ToolchainConfigWidget(tc),
     m_abiWidget(new AbiWidget),
     m_subType(tc->m_subType),
@@ -1735,16 +1735,16 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
     setFromToolchain();
 
     connect(m_compilerCommand, &PathChooser::rawPathChanged,
-            this, &GccToolChainConfigWidget::handleCompilerCommandChange);
+            this, &GccToolchainConfigWidget::handleCompilerCommandChange);
     connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished,
-            this, &GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange);
+            this, &GccToolchainConfigWidget::handlePlatformCodeGenFlagsChange);
     connect(m_platformLinkerFlagsLineEdit, &QLineEdit::editingFinished,
-            this, &GccToolChainConfigWidget::handlePlatformLinkerFlagsChange);
+            this, &GccToolchainConfigWidget::handlePlatformLinkerFlagsChange);
     connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty);
     connect(m_targetTripleWidget, &TargetTripleWidget::valueChanged,
             this, &ToolchainConfigWidget::dirty);
 
-    if (m_subType == GccToolChain::Clang) {
+    if (m_subType == GccToolchain::Clang) {
         if (!HostOsInfo::isWindowsHost() || tc->typeId() != Constants::CLANG_TOOLCHAIN_TYPEID)
             return;
 
@@ -1783,12 +1783,12 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
     }
 }
 
-void GccToolChainConfigWidget::applyImpl()
+void GccToolchainConfigWidget::applyImpl()
 {
     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());
@@ -1812,7 +1812,7 @@ void GccToolChainConfigWidget::applyImpl()
                                                   Toolchain::languageVersion(tc->language(),
                                                                              m_macros)});
 
-    if (m_subType == GccToolChain::Clang && m_parentToolchainCombo) {
+    if (m_subType == GccToolchain::Clang && m_parentToolchainCombo) {
 
         tc->m_parentToolChainId.clear();
 
@@ -1830,11 +1830,11 @@ void GccToolChainConfigWidget::applyImpl()
     }
 }
 
-void GccToolChainConfigWidget::setFromToolchain()
+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()));
@@ -1850,9 +1850,9 @@ void GccToolChainConfigWidget::setFromToolchain()
         updateParentToolChainComboBox();
 }
 
-bool GccToolChainConfigWidget::isDirtyImpl() const
+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()
@@ -1868,12 +1868,12 @@ bool GccToolChainConfigWidget::isDirtyImpl() const
     if (!m_parentToolchainCombo)
         return false;
 
-    const GccToolChain *parentTC = mingwToolChainFromId(tc->m_parentToolChainId);
+    const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolChainId);
     const QByteArray parentId = parentTC ? parentTC->id() : QByteArray();
     return parentId != m_parentToolchainCombo->currentData();
 }
 
-void GccToolChainConfigWidget::makeReadOnlyImpl()
+void GccToolchainConfigWidget::makeReadOnlyImpl()
 {
     m_compilerCommand->setReadOnly(true);
     if (m_abiWidget)
@@ -1887,7 +1887,7 @@ void GccToolChainConfigWidget::makeReadOnlyImpl()
         m_parentToolchainCombo->setEnabled(false);
 }
 
-void GccToolChainConfigWidget::handleCompilerCommandChange()
+void GccToolchainConfigWidget::handleCompilerCommandChange()
 {
     if (!m_abiWidget)
         return;
@@ -1903,7 +1903,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
     }
     if (haveCompiler) {
         Environment env = path.deviceEnvironment();
-        GccToolChain::addCommandPathToEnvironment(path, env);
+        GccToolchain::addCommandPathToEnvironment(path, env);
         QStringList args = gccPredefinedMacrosOptions(Constants::CXX_LANGUAGE_ID)
                 + splitString(m_platformCodeGenFlagsLineEdit->text());
         const FilePath localCompilerPath = findLocalCompiler(path, env);
@@ -1922,7 +1922,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
     emit dirty();
 }
 
-void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
+void GccToolchainConfigWidget::handlePlatformCodeGenFlagsChange()
 {
     QString str1 = m_platformCodeGenFlagsLineEdit->text();
     QString str2 = ProcessArgs::joinArgs(splitString(str1));
@@ -1932,7 +1932,7 @@ void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
         handleCompilerCommandChange();
 }
 
-void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange()
+void GccToolchainConfigWidget::handlePlatformLinkerFlagsChange()
 {
     QString str1 = m_platformLinkerFlagsLineEdit->text();
     QString str2 = ProcessArgs::joinArgs(splitString(str1));
@@ -1946,7 +1946,7 @@ void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange()
 // ClangToolChain
 // --------------------------------------------------------------------------
 
-void GccToolChain::syncAutodetectedWithParentToolchains()
+void GccToolchain::syncAutodetectedWithParentToolchains()
 {
     if (!HostOsInfo::isWindowsHost() || typeId() != Constants::CLANG_TOOLCHAIN_TYPEID
         || !isAutoDetected()) {
@@ -1961,7 +1961,7 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
                 [id = id()] {
             if (Toolchain * const tc = ToolchainManager::findToolchain(id)) {
                 if (tc->typeId() == Constants::CLANG_TOOLCHAIN_TYPEID)
-                    static_cast<GccToolChain *>(tc)->syncAutodetectedWithParentToolchains();
+                    static_cast<GccToolchain *>(tc)->syncAutodetectedWithParentToolchains();
             }
         });
         return;
@@ -1993,7 +1993,7 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
           });
 }
 
-bool GccToolChain::matchesCompilerCommand(const FilePath &command) const
+bool GccToolchain::matchesCompilerCommand(const FilePath &command) const
 {
     if (m_subType == Clang) {
         if (!m_resolvedCompilerCommand) {
@@ -2015,10 +2015,10 @@ bool GccToolChain::matchesCompilerCommand(const FilePath &command) const
     return Toolchain::matchesCompilerCommand(command);
 }
 
-QString GccToolChain::sysRoot() const
+QString GccToolchain::sysRoot() const
 {
     if (m_subType == Clang) {
-        if (const GccToolChain *parentTC = mingwToolChainFromId(m_parentToolChainId)) {
+        if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId)) {
             const FilePath mingwCompiler = parentTC->compilerCommand();
             return mingwCompiler.parentDir().parentDir().toString();
         }
@@ -2026,16 +2026,16 @@ QString GccToolChain::sysRoot() const
     return {};
 }
 
-void GccToolChainConfigWidget::updateParentToolChainComboBox()
+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;
 
-    const GccToolChain *parentTC = mingwToolChainFromId(parentId);
+    const GccToolchain *parentTC = mingwToolChainFromId(parentId);
 
     m_parentToolchainCombo->clear();
     m_parentToolchainCombo->addItem(parentTC ? parentTC->displayName() : QString(),
diff --git a/src/plugins/projectexplorer/gcctoolchain.h b/src/plugins/projectexplorer/gcctoolchain.h
index a46595c7358..ee1b0aca8f8 100644
--- a/src/plugins/projectexplorer/gcctoolchain.h
+++ b/src/plugins/projectexplorer/gcctoolchain.h
@@ -16,23 +16,23 @@
 namespace ProjectExplorer {
 
 namespace Internal {
-class GccToolChainConfigWidget;
+class GccToolchainConfigWidget;
 class GccToolchainFactory;
 
 const QStringList gccPredefinedMacrosOptions(Utils::Id languageId);
 }
 
 // --------------------------------------------------------------------------
-// GccToolChain
+// GccToolchain
 // --------------------------------------------------------------------------
 
-class PROJECTEXPLORER_EXPORT GccToolChain : public Toolchain
+class PROJECTEXPLORER_EXPORT GccToolchain : public Toolchain
 {
 public:
     enum SubType { RealGcc, Clang, MinGW, LinuxIcc };
 
-    GccToolChain(Utils::Id typeId, SubType subType = RealGcc);
-    ~GccToolChain() override;
+    GccToolchain(Utils::Id typeId, SubType subType = RealGcc);
+    ~GccToolchain() override;
 
     QString originalTargetTriple() const override;
     Utils::FilePath installDir() const override;
@@ -79,7 +79,7 @@ public:
         Abis supportedAbis;
         QString originalTargetTriple;
     };
-    GccToolChain *asGccToolChain() final { return this; }
+    GccToolchain *asGccToolchain() final { return this; }
 
     bool matchesCompilerCommand(const Utils::FilePath &command) const override;
 
@@ -102,7 +102,7 @@ protected:
     virtual QString detectVersion() const;
     virtual Utils::FilePath detectInstallDir() const;
 
-    // Reinterpret options for compiler drivers inheriting from GccToolChain (e.g qcc) to apply -Wp option
+    // Reinterpret options for compiler drivers inheriting from GccToolchain (e.g qcc) to apply -Wp option
     // that passes the initial options directly down to the gcc compiler
     using OptionsReinterpreter = std::function<QStringList(const QStringList &options)>;
     void setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter);
@@ -148,7 +148,7 @@ private:
     mutable QString m_version;
     mutable Utils::FilePath m_installDir;
 
-    friend class Internal::GccToolChainConfigWidget;
+    friend class Internal::GccToolchainConfigWidget;
     friend class Internal::GccToolchainFactory;
     friend class ToolchainFactory;
 
diff --git a/src/plugins/projectexplorer/toolchain.h b/src/plugins/projectexplorer/toolchain.h
index 5d11df2a868..54cc2718c48 100644
--- a/src/plugins/projectexplorer/toolchain.h
+++ b/src/plugins/projectexplorer/toolchain.h
@@ -40,7 +40,7 @@ QString languageId(Language l);
 } // namespace Toolchain
 } // namespace Deprecated
 
-class GccToolChain;
+class GccToolchain;
 class ToolchainConfigWidget;
 class Kit;
 
@@ -161,7 +161,7 @@ public:
     };
 
     virtual int priority() const { return PriorityNormal; }
-    virtual GccToolChain *asGccToolChain() { return nullptr; }
+    virtual GccToolchain *asGccToolchain() { return nullptr; }
 
 protected:
     explicit Toolchain(Utils::Id typeId);
diff --git a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp b/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
index 97b17346552..ec25dc0fd83 100644
--- a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
+++ b/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
@@ -336,7 +336,7 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
         }
         data.insert(QLatin1String(CPP_TOOLCHAINPATH), mainFilePath.absolutePath().toString());
 
-        if (auto gcc = mainTc->asGccToolChain()) {
+        if (auto gcc = mainTc->asGccToolchain()) {
             QStringList compilerFlags = gcc->platformCodeGenFlags();
             filterCompilerLinkerFlags(targetAbi, compilerFlags);
             data.insert(QLatin1String(CPP_PLATFORMCOMMONCOMPILERFLAGS), compilerFlags);
diff --git a/src/plugins/qnx/qnxtoolchain.cpp b/src/plugins/qnx/qnxtoolchain.cpp
index 052cea48ed6..ad3fae16417 100644
--- a/src/plugins/qnx/qnxtoolchain.cpp
+++ b/src/plugins/qnx/qnxtoolchain.cpp
@@ -98,7 +98,7 @@ static QStringList reinterpretOptions(const QStringList &args)
 }
 
 QnxToolChain::QnxToolChain()
-    : GccToolChain(Constants::QNX_TOOLCHAIN_ID)
+    : GccToolchain(Constants::QNX_TOOLCHAIN_ID)
 {
     setOptionsReinterpreter(&reinterpretOptions);
     setTypeDisplayName(Tr::tr("QCC"));
@@ -128,7 +128,7 @@ void QnxToolChain::addToEnvironment(Environment &env) const
         env.expandedValueForKey("QNX_CONFIGURATION_EXCLUSIVE").isEmpty())
         setQnxEnvironment(env, QnxUtils::qnxEnvironment(sdpPath()));
 
-    GccToolChain::addToEnvironment(env);
+    GccToolchain::addToEnvironment(env);
 }
 
 QStringList QnxToolChain::suggestedMkspecList() const
@@ -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
@@ -149,12 +149,12 @@ GccToolChain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
     //
     // Without it on Windows Clang defaults to a MSVC mode, which breaks with
     // the QNX code, which is mostly GNU based.
-    return GccToolChain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"};
+    return GccToolchain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"};
 }
 
 bool QnxToolChain::operator ==(const Toolchain &other) const
 {
-    if (!GccToolChain::operator ==(other))
+    if (!GccToolchain::operator ==(other))
         return false;
 
     auto qnxTc = static_cast<const QnxToolChain *>(&other);
diff --git a/src/plugins/qnx/qnxtoolchain.h b/src/plugins/qnx/qnxtoolchain.h
index 02e8690e5f5..92fdb4483c3 100644
--- a/src/plugins/qnx/qnxtoolchain.h
+++ b/src/plugins/qnx/qnxtoolchain.h
@@ -7,7 +7,7 @@
 
 namespace Qnx::Internal {
 
-class QnxToolChain : public ProjectExplorer::GccToolChain
+class QnxToolChain : public ProjectExplorer::GccToolchain
 {
 public:
     QnxToolChain();
diff --git a/src/plugins/webassembly/webassemblytoolchain.cpp b/src/plugins/webassembly/webassemblytoolchain.cpp
index 3b451ccc59b..212876e92e3 100644
--- a/src/plugins/webassembly/webassemblytoolchain.cpp
+++ b/src/plugins/webassembly/webassemblytoolchain.cpp
@@ -63,7 +63,7 @@ void WebAssemblyToolChain::addToEnvironment(Environment &env) const
 }
 
 WebAssemblyToolChain::WebAssemblyToolChain() :
-    GccToolChain(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID)
+    GccToolchain(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID)
 {
     setSupportedAbis({toolChainAbi()});
     setTargetAbi(toolChainAbi());
@@ -88,7 +88,7 @@ FilePath WebAssemblyToolChain::makeCommand(const Environment &environment) const
 
 bool WebAssemblyToolChain::isValid() const
 {
-    return GccToolChain::isValid()
+    return GccToolchain::isValid()
             && QVersionNumber::fromString(version()) >= minimumSupportedEmSdkVersion();
 }
 
diff --git a/src/plugins/webassembly/webassemblytoolchain.h b/src/plugins/webassembly/webassemblytoolchain.h
index 9d91f675432..fca0249c1d4 100644
--- a/src/plugins/webassembly/webassemblytoolchain.h
+++ b/src/plugins/webassembly/webassemblytoolchain.h
@@ -9,7 +9,7 @@
 
 namespace WebAssembly::Internal {
 
-class WebAssemblyToolChain final : public ProjectExplorer::GccToolChain
+class WebAssemblyToolChain final : public ProjectExplorer::GccToolchain
 {
 public:
     WebAssemblyToolChain();