McuSupport: Rename remaining ToolChain things to Toolchain

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

15 files changed, 207 insertions, 207 deletions

diff --git a/src/plugins/mcusupport/mcuabstracttargetfactory.h b/src/plugins/mcusupport/mcuabstracttargetfactory.h
index aac2842edba..eef7796db77 100644
--- a/src/plugins/mcusupport/mcuabstracttargetfactory.h
+++ b/src/plugins/mcusupport/mcuabstracttargetfactory.h
@@ -28,7 +28,7 @@ public:
                                                    const McuPackagePtr &qtForMCUsPackage)
         = 0;
     using AdditionalPackages
-        = QPair<QHash<QString, McuToolChainPackagePtr>, QHash<QString, McuPackagePtr>>;
+        = QPair<QHash<QString, McuToolchainPackagePtr>, QHash<QString, McuPackagePtr>>;
     virtual AdditionalPackages getAdditionalPackages() const { return {}; }
 }; // struct McuAbstractTargetFactory
 } // namespace McuSupport::Internal
diff --git a/src/plugins/mcusupport/mcukitmanager.cpp b/src/plugins/mcusupport/mcukitmanager.cpp
index 988aa659cec..456bdbdcdfc 100644
--- a/src/plugins/mcusupport/mcukitmanager.cpp
+++ b/src/plugins/mcusupport/mcukitmanager.cpp
@@ -75,22 +75,22 @@ static const int KIT_VERSION = 9; // Bumps up whenever details in Kit creation c
 class McuKitFactory
 {
 public:
-    static void setKitToolchains(Kit *k, const McuToolChainPackagePtr &tcPackage)
+    static void setKitToolchains(Kit *k, const McuToolchainPackagePtr &tcPackage)
     {
         switch (tcPackage->toolchainType()) {
-        case McuToolChainPackage::ToolChainType::Unsupported:
+        case McuToolchainPackage::ToolchainType::Unsupported:
             return;
 
-        case McuToolChainPackage::ToolChainType::GHS:
-        case McuToolChainPackage::ToolChainType::GHSArm:
+        case McuToolchainPackage::ToolchainType::GHS:
+        case McuToolchainPackage::ToolchainType::GHSArm:
             return; // No Green Hills toolchain, because support for it is missing.
 
-        case McuToolChainPackage::ToolChainType::IAR:
-        case McuToolChainPackage::ToolChainType::KEIL:
-        case McuToolChainPackage::ToolChainType::MSVC:
-        case McuToolChainPackage::ToolChainType::GCC:
-        case McuToolChainPackage::ToolChainType::MinGW:
-        case McuToolChainPackage::ToolChainType::ArmGcc:
+        case McuToolchainPackage::ToolchainType::IAR:
+        case McuToolchainPackage::ToolchainType::KEIL:
+        case McuToolchainPackage::ToolchainType::MSVC:
+        case McuToolchainPackage::ToolchainType::GCC:
+        case McuToolchainPackage::ToolchainType::MinGW:
+        case McuToolchainPackage::ToolchainType::ArmGcc:
             ToolchainKitAspect::setToolchain(k,
                                              tcPackage->toolChain(
                                                  ProjectExplorer::Constants::C_LANGUAGE_ID));
@@ -116,7 +116,7 @@ public:
         k->setValue(KIT_MCUTARGET_SDKVERSION_KEY, mcuTarget->qulVersion().toString());
         k->setValue(KIT_MCUTARGET_KITVERSION_KEY, KIT_VERSION);
         k->setValue(KIT_MCUTARGET_OS_KEY, static_cast<int>(mcuTarget->os()));
-        k->setValue(KIT_MCUTARGET_TOOLCHAIN_KEY, mcuTarget->toolChainPackage()->toolChainName());
+        k->setValue(KIT_MCUTARGET_TOOLCHAIN_KEY, mcuTarget->toolChainPackage()->toolchainName());
         k->setAutoDetected(false);
         k->makeSticky();
         if (mcuTarget->toolChainPackage()->isDesktopToolchain())
@@ -136,25 +136,25 @@ public:
         k->setIrrelevantAspects(irrelevant);
     }
 
-    static void setKitDebugger(Kit *k, const McuToolChainPackagePtr &tcPackage)
+    static void setKitDebugger(Kit *k, const McuToolchainPackagePtr &tcPackage)
     {
         if (tcPackage->isDesktopToolchain()) {
-            // Qt Creator seems to be smart enough to deduce the right Kit debugger from the ToolChain
+            // Qt Creator seems to be smart enough to deduce the right Kit debugger from the Toolchain
             return;
         }
 
         switch (tcPackage->toolchainType()) {
-        case McuToolChainPackage::ToolChainType::Unsupported:
-        case McuToolChainPackage::ToolChainType::GHS:
-        case McuToolChainPackage::ToolChainType::GHSArm:
-        case McuToolChainPackage::ToolChainType::IAR:
+        case McuToolchainPackage::ToolchainType::Unsupported:
+        case McuToolchainPackage::ToolchainType::GHS:
+        case McuToolchainPackage::ToolchainType::GHSArm:
+        case McuToolchainPackage::ToolchainType::IAR:
             return; // No Green Hills and IAR debugger, because support for it is missing.
 
-        case McuToolChainPackage::ToolChainType::KEIL:
-        case McuToolChainPackage::ToolChainType::MSVC:
-        case McuToolChainPackage::ToolChainType::GCC:
-        case McuToolChainPackage::ToolChainType::MinGW:
-        case McuToolChainPackage::ToolChainType::ArmGcc: {
+        case McuToolchainPackage::ToolchainType::KEIL:
+        case McuToolchainPackage::ToolchainType::MSVC:
+        case McuToolchainPackage::ToolchainType::GCC:
+        case McuToolchainPackage::ToolchainType::MinGW:
+        case McuToolchainPackage::ToolchainType::ArmGcc: {
             const QVariant debuggerId = tcPackage->debuggerId();
             if (debuggerId.isValid()) {
                 Debugger::DebuggerKitAspect::setDebugger(k, debuggerId);
@@ -252,10 +252,10 @@ public:
         using namespace CMakeProjectManager;
         auto configMap = cMakeConfigToMap(CMakeConfigurationKitAspect::configuration(k));
 
-        // CMake ToolChain file for ghs handles CMAKE_*_COMPILER autonomously
+        // CMake Toolchain file for ghs handles CMAKE_*_COMPILER autonomously
         const QList autonomousCompilerDetectionToolchains{
-            McuToolChainPackage::ToolChainType::GHS,
-            McuToolChainPackage::ToolChainType::GHSArm,
+            McuToolchainPackage::ToolchainType::GHS,
+            McuToolchainPackage::ToolchainType::GHSArm,
         };
         if (!autonomousCompilerDetectionToolchains.contains(
                 mcuTarget->toolChainPackage()->toolchainType())) {
@@ -324,8 +324,8 @@ public:
 
         if (HostOsInfo::isWindowsHost()) {
             auto type = mcuTarget->toolChainPackage()->toolchainType();
-            if (type == McuToolChainPackage::ToolChainType::GHS
-                || type == McuToolChainPackage::ToolChainType::GHSArm) {
+            if (type == McuToolchainPackage::ToolchainType::GHS
+                || type == McuToolchainPackage::ToolchainType::GHSArm) {
                 // See https://bugreports.qt.io/browse/UL-4247?focusedCommentId=565802&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-565802
                 // and https://bugreports.qt.io/browse/UL-4247?focusedCommentId=565803&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-565803
                 CMakeGeneratorKitAspect::setGenerator(k, "NMake Makefiles JOM");
@@ -387,9 +387,9 @@ Kit *newKit(const McuTarget *mcuTarget, const McuPackagePtr &qtForMCUsSdk)
 // Kit Information
 QString generateKitNameFromTarget(const McuTarget *mcuTarget)
 {
-    McuToolChainPackagePtr tcPkg = mcuTarget->toolChainPackage();
+    McuToolchainPackagePtr tcPkg = mcuTarget->toolChainPackage();
     const QString compilerName = tcPkg ? QString::fromLatin1(" (%1)").arg(
-                                     tcPkg->toolChainName().toUpper())
+                                     tcPkg->toolchainName().toUpper())
                                        : "";
     const QString colorDepth = mcuTarget->colorDepth() != McuTarget::UnspecifiedColorDepth
                                    ? QString::fromLatin1(" %1bpp").arg(mcuTarget->colorDepth())
@@ -453,7 +453,7 @@ QList<Kit *> existingKits(const McuTarget *mcuTarget)
                        && kit->value(KIT_MCUTARGET_OS_KEY).toInt()
                               == static_cast<int>(mcuTarget->os())
                        && kit->value(KIT_MCUTARGET_TOOLCHAIN_KEY)
-                              == mcuTarget->toolChainPackage()->toolChainName()));
+                              == mcuTarget->toolChainPackage()->toolchainName()));
     });
 }
 
diff --git a/src/plugins/mcusupport/mcupackage.cpp b/src/plugins/mcusupport/mcupackage.cpp
index c6235a3d4e6..15b6b589859 100644
--- a/src/plugins/mcusupport/mcupackage.cpp
+++ b/src/plugins/mcusupport/mcupackage.cpp
@@ -352,12 +352,12 @@ const QMap<QString, QString> McuPackage::packageLabelTranslations {
     {"Path to project for Renesas e2 Studio",               Tr::tr("Path to project for Renesas e2 Studio")}
 };
 
-McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackage::McuToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                          const QString &label,
                                          const FilePath &defaultPath,
                                          const QList<FilePath> &detectionPaths,
                                          const Key &settingsKey,
-                                         McuToolChainPackage::ToolChainType type,
+                                         McuToolchainPackage::ToolchainType type,
                                          const QStringList &versions,
                                          const QString &cmakeVarName,
                                          const QString &envVarName,
@@ -375,18 +375,18 @@ McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHan
     , m_type(type)
 {}
 
-McuToolChainPackage::ToolChainType McuToolChainPackage::toolchainType() const
+McuToolchainPackage::ToolchainType McuToolchainPackage::toolchainType() const
 {
     return m_type;
 }
 
-bool McuToolChainPackage::isDesktopToolchain() const
+bool McuToolchainPackage::isDesktopToolchain() const
 {
-    return m_type == ToolChainType::MSVC || m_type == ToolChainType::GCC
-           || m_type == ToolChainType::MinGW;
+    return m_type == ToolchainType::MSVC || m_type == ToolchainType::GCC
+           || m_type == ToolchainType::MinGW;
 }
 
-Toolchain *McuToolChainPackage::msvcToolChain(Id language)
+Toolchain *McuToolchainPackage::msvcToolchain(Id language)
 {
     Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
         const Abi abi = t->targetAbi();
@@ -398,7 +398,7 @@ Toolchain *McuToolChainPackage::msvcToolChain(Id language)
     return toolChain;
 }
 
-Toolchain *McuToolChainPackage::gccToolChain(Id language)
+Toolchain *McuToolchainPackage::gccToolchain(Id language)
 {
     Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
         const Abi abi = t->targetAbi();
@@ -408,7 +408,7 @@ Toolchain *McuToolChainPackage::gccToolChain(Id language)
     return toolChain;
 }
 
-static Toolchain *mingwToolChain(const FilePath &path, Id language)
+static Toolchain *mingwToolchain(const FilePath &path, Id language)
 {
     Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
         // find a MinGW toolchain having the same path from registered toolchains
@@ -430,7 +430,7 @@ static Toolchain *mingwToolChain(const FilePath &path, Id language)
     return toolChain;
 }
 
-static Toolchain *armGccToolChain(const FilePath &path, Id language)
+static Toolchain *armGccToolchain(const FilePath &path, Id language)
 {
     Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
         return t->compilerCommand() == path && t->language() == language;
@@ -456,7 +456,7 @@ static Toolchain *armGccToolChain(const FilePath &path, Id language)
     return toolChain;
 }
 
-static Toolchain *iarToolChain(const FilePath &path, Id language)
+static Toolchain *iarToolchain(const FilePath &path, Id language)
 {
     Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
         return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
@@ -488,67 +488,67 @@ static Toolchain *iarToolChain(const FilePath &path, Id language)
     return toolChain;
 }
 
-Toolchain *McuToolChainPackage::toolChain(Id language) const
+Toolchain *McuToolchainPackage::toolChain(Id language) const
 {
     switch (m_type) {
-    case ToolChainType::MSVC:
-        return msvcToolChain(language);
-    case ToolChainType::GCC:
-        return gccToolChain(language);
-    case ToolChainType::MinGW: {
+    case ToolchainType::MSVC:
+        return msvcToolchain(language);
+    case ToolchainType::GCC:
+        return gccToolchain(language);
+    case ToolchainType::MinGW: {
         const QLatin1String compilerName(
             language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++");
         const FilePath compilerPath = (path() / "bin" / compilerName).withExecutableSuffix();
-        return mingwToolChain(compilerPath, language);
+        return mingwToolchain(compilerPath, language);
     }
-    case ToolChainType::IAR: {
+    case ToolchainType::IAR: {
         const FilePath compiler = (path() / "/bin/iccarm").withExecutableSuffix();
-        return iarToolChain(compiler, language);
+        return iarToolchain(compiler, language);
     }
-    case ToolChainType::ArmGcc:
-    case ToolChainType::KEIL:
-    case ToolChainType::GHS:
-    case ToolChainType::GHSArm:
-    case ToolChainType::Unsupported: {
+    case ToolchainType::ArmGcc:
+    case ToolchainType::KEIL:
+    case ToolchainType::GHS:
+    case ToolchainType::GHSArm:
+    case ToolchainType::Unsupported: {
         const QLatin1String compilerName(
             language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++");
-        const QString comp = QLatin1String(m_type == ToolChainType::ArmGcc ? "/bin/arm-none-eabi-%1"
+        const QString comp = QLatin1String(m_type == ToolchainType::ArmGcc ? "/bin/arm-none-eabi-%1"
                                                                            : "/bar/foo-keil-%1")
                                  .arg(compilerName);
         const FilePath compiler = (path() / comp).withExecutableSuffix();
 
-        return armGccToolChain(compiler, language);
+        return armGccToolchain(compiler, language);
     }
     default:
         Q_UNREACHABLE();
     }
 }
 
-QString McuToolChainPackage::toolChainName() const
+QString McuToolchainPackage::toolchainName() const
 {
     switch (m_type) {
-    case ToolChainType::MSVC:
+    case ToolchainType::MSVC:
         return QLatin1String("msvc");
-    case ToolChainType::GCC:
+    case ToolchainType::GCC:
         return QLatin1String("gcc");
-    case ToolChainType::MinGW:
+    case ToolchainType::MinGW:
         return QLatin1String("mingw");
-    case ToolChainType::ArmGcc:
+    case ToolchainType::ArmGcc:
         return QLatin1String("armgcc");
-    case ToolChainType::IAR:
+    case ToolchainType::IAR:
         return QLatin1String("iar");
-    case ToolChainType::KEIL:
+    case ToolchainType::KEIL:
         return QLatin1String("keil");
-    case ToolChainType::GHS:
+    case ToolchainType::GHS:
         return QLatin1String("ghs");
-    case ToolChainType::GHSArm:
+    case ToolchainType::GHSArm:
         return QLatin1String("ghs-arm");
     default:
         return QLatin1String("unsupported");
     }
 }
 
-QVariant McuToolChainPackage::debuggerId() const
+QVariant McuToolchainPackage::debuggerId() const
 {
     using namespace Debugger;
 
@@ -556,19 +556,19 @@ QVariant McuToolChainPackage::debuggerId() const
     DebuggerEngineType engineType;
 
     switch (m_type) {
-    case ToolChainType::ArmGcc: {
+    case ToolchainType::ArmGcc: {
         sub = QString::fromLatin1("bin/arm-none-eabi-gdb-py");
         displayName = Tr::tr("Arm GDB at %1");
         engineType = Debugger::GdbEngineType;
         break;
     }
-    case ToolChainType::IAR: {
+    case ToolchainType::IAR: {
         sub = QString::fromLatin1("../common/bin/CSpyBat");
         displayName = QLatin1String("CSpy");
         engineType = Debugger::NoEngineType; // support for IAR missing
         break;
     }
-    case ToolChainType::KEIL: {
+    case ToolchainType::KEIL: {
         sub = QString::fromLatin1("UV4/UV4");
         displayName = QLatin1String("KEIL uVision Debugger");
         engineType = Debugger::UvscEngineType;
diff --git a/src/plugins/mcusupport/mcupackage.h b/src/plugins/mcusupport/mcupackage.h
index 88171bc93bc..2efeb5e127f 100644
--- a/src/plugins/mcusupport/mcupackage.h
+++ b/src/plugins/mcusupport/mcupackage.h
@@ -100,36 +100,36 @@ private:
     Status m_status = Status::InvalidPath;
 }; // class McuPackage
 
-class McuToolChainPackage final : public McuPackage
+class McuToolchainPackage final : public McuPackage
 {
     Q_OBJECT
 public:
-    enum class ToolChainType { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, MinGW, Unsupported };
+    enum class ToolchainType { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, MinGW, Unsupported };
 
-    McuToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+    McuToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                         const QString &label,
                         const Utils::FilePath &defaultPath,
                         const Utils::FilePaths &detectionPaths,
                         const Utils::Key &settingsKey,
-                        ToolChainType toolchainType,
+                        ToolchainType toolchainType,
                         const QStringList &versions,
                         const QString &cmakeVarName,
                         const QString &envVarName,
                         const McuPackageVersionDetector *versionDetector);
 
-    ToolChainType toolchainType() const;
+    ToolchainType toolchainType() const;
     bool isDesktopToolchain() const;
     ProjectExplorer::Toolchain *toolChain(Utils::Id language) const;
-    QString toolChainName() const;
+    QString toolchainName() const;
     QVariant debuggerId() const;
 
-    static ProjectExplorer::Toolchain *msvcToolChain(Utils::Id language);
-    static ProjectExplorer::Toolchain *gccToolChain(Utils::Id language);
+    static ProjectExplorer::Toolchain *msvcToolchain(Utils::Id language);
+    static ProjectExplorer::Toolchain *gccToolchain(Utils::Id language);
 
 private:
-    const ToolChainType m_type;
+    const ToolchainType m_type;
 };
 
 } // namespace McuSupport::Internal
 
-Q_DECLARE_METATYPE(McuSupport::Internal::McuToolChainPackage::ToolChainType)
+Q_DECLARE_METATYPE(McuSupport::Internal::McuToolchainPackage::ToolchainType)
diff --git a/src/plugins/mcusupport/mcusupport_global.h b/src/plugins/mcusupport/mcusupport_global.h
index 20de9a73298..ebff4dacf6d 100644
--- a/src/plugins/mcusupport/mcusupport_global.h
+++ b/src/plugins/mcusupport/mcusupport_global.h
@@ -19,10 +19,10 @@ namespace McuSupport::Internal {
 
 class McuTarget;
 class McuAbstractPackage;
-class McuToolChainPackage;
+class McuToolchainPackage;
 
 using McuPackagePtr = QSharedPointer<McuAbstractPackage>;
-using McuToolChainPackagePtr = QSharedPointer<McuToolChainPackage>;
+using McuToolchainPackagePtr = QSharedPointer<McuToolchainPackage>;
 using McuTargetPtr = QSharedPointer<McuTarget>;
 
 static const QVersionNumber minimalVersion{2, 0, 0};
diff --git a/src/plugins/mcusupport/mcusupportsdk.cpp b/src/plugins/mcusupport/mcusupportsdk.cpp
index 29d6b97ebfe..689ab875b42 100644
--- a/src/plugins/mcusupport/mcusupportsdk.cpp
+++ b/src/plugins/mcusupport/mcusupportsdk.cpp
@@ -152,7 +152,7 @@ McuPackagePtr createFreeRTOSSourcesPackage(const SettingsHandler::Ptr &settingsH
                        "https://freertos.org")}; // download url
 }
 
-McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &settingsHandler,
+McuPackagePtr createUnsupportedToolchainFilePackage(const SettingsHandler::Ptr &settingsHandler,
                                                     const FilePath &qtForMCUSdkPath)
 {
     const FilePath toolchainFilePath = qtForMCUSdkPath / Constants::QUL_TOOLCHAIN_CMAKE_DIR
@@ -166,25 +166,25 @@ McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &
                                         {})};
 }
 
-McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolchainPackagePtr createUnsupportedToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
 {
-    return McuToolChainPackagePtr{
-        new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{
+        new McuToolchainPackage(settingsHandler,
                                 {},
                                 {},
                                 {},
                                 {},
-                                McuToolChainPackage::ToolChainType::Unsupported,
+                                McuToolchainPackage::ToolchainType::Unsupported,
                                 {},
                                 {},
                                 {},
                                 nullptr)};
 }
 
-McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackagePtr createMsvcToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                   const QStringList &versions)
 {
-    Toolchain *toolChain = McuToolChainPackage::msvcToolChain(
+    Toolchain *toolChain = McuToolchainPackage::msvcToolchain(
         ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     const FilePath detectionPath = FilePath("cl").withExecutableSuffix();
@@ -194,22 +194,22 @@ McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &se
                                                                           {"/?"},
                                                                           R"(\b(\d+\.\d+)\.\d+\b)");
 
-    return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{new McuToolchainPackage(settingsHandler,
                                                           Tr::tr("MSVC Binary directory"),
                                                           defaultPath,
                                                           {detectionPath},
                                                           "MsvcToolchain",
-                                                          McuToolChainPackage::ToolChainType::MSVC,
+                                                          McuToolchainPackage::ToolchainType::MSVC,
                                                           versions,
                                                           {},
                                                           {},
                                                           versionDetector)};
 }
 
-McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackagePtr createGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                  const QStringList &versions)
 {
-    Toolchain *toolChain = McuToolChainPackage::gccToolChain(
+    Toolchain *toolChain = McuToolchainPackage::gccToolchain(
         ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     const FilePath detectionPath = FilePath("bin/g++*").withExecutableSuffix();
@@ -220,19 +220,19 @@ McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &set
                                                                           {"--version"},
                                                                           R"(\b(\d+\.\d+\.\d+)\b)");
 
-    return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{new McuToolchainPackage(settingsHandler,
                                                           Tr::tr("GCC Toolchain"),
                                                           defaultPath,
                                                           {detectionPath},
                                                           "GnuToolchain",
-                                                          McuToolChainPackage::ToolChainType::GCC,
+                                                          McuToolchainPackage::ToolchainType::GCC,
                                                           versions,
                                                           {},
                                                           {},
                                                           versionDetector)};
 }
 
-McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                     const QStringList &versions)
 {
     const char envVar[] = "ARMGCC_DIR";
@@ -256,20 +256,20 @@ McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &
                                                                           {"--version"},
                                                                           R"(\b(\d+\.\d+\.\d+)\b)");
 
-    return McuToolChainPackagePtr{
-        new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{
+        new McuToolchainPackage(settingsHandler,
                                 Tr::tr("GNU Arm Embedded Toolchain"),
                                 defaultPath,
                                 {detectionPath},
                                 "GNUArmEmbeddedToolchain",                  // settingsKey
-                                McuToolChainPackage::ToolChainType::ArmGcc, // toolchainType
+                                McuToolchainPackage::ToolchainType::ArmGcc, // toolchainType
                                 versions,
                                 Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
                                 envVar,                                  // env var
                                 versionDetector)};
 }
 
-McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                  const QStringList &versions)
 {
     const char envVar[] = "GHS_COMPILER_DIR";
@@ -281,20 +281,20 @@ McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &set
                                                   {"-help"},
                                                   R"(\bv(\d+\.\d+\.\d+)\b)");
 
-    return McuToolChainPackagePtr{
-        new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{
+        new McuToolchainPackage(settingsHandler,
                                 "Green Hills Compiler",
                                 defaultPath,
                                 {FilePath("ccv850").withExecutableSuffix()}, // detectionPath
                                 "GHSToolchain",                              // settingsKey
-                                McuToolChainPackage::ToolChainType::GHS,     // toolchainType
+                                McuToolchainPackage::ToolchainType::GHS,     // toolchainType
                                 versions,
                                 Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
                                 envVar,                                  // env var
                                 versionDetector)};
 }
 
-McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                     const QStringList &versions)
 {
     const char envVar[] = "GHS_ARM_COMPILER_DIR";
@@ -306,20 +306,20 @@ McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &
                                                   {"-help"},
                                                   R"(\bv(\d+\.\d+\.\d+)\b)");
 
-    return McuToolChainPackagePtr{
-        new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{
+        new McuToolchainPackage(settingsHandler,
                                 "Green Hills Compiler for ARM",
                                 defaultPath,
                                 {FilePath("cxarm").withExecutableSuffix()}, // detectionPath
                                 "GHSArmToolchain",                          // settingsKey
-                                McuToolChainPackage::ToolChainType::GHSArm, // toolchainType
+                                McuToolchainPackage::ToolchainType::GHSArm, // toolchainType
                                 versions,
                                 Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
                                 envVar,                                  // env var
                                 versionDetector)};
 }
 
-McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+McuToolchainPackagePtr createIarToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
                                                  const QStringList &versions)
 {
     const char envVar[] = "IAR_ARM_COMPILER_DIR";
@@ -344,13 +344,13 @@ McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &set
                                                   {"--version"},
                                                   R"(\bV(\d+\.\d+\.\d+)\.\d+\b)");
 
-    return McuToolChainPackagePtr{
-        new McuToolChainPackage(settingsHandler,
+    return McuToolchainPackagePtr{
+        new McuToolchainPackage(settingsHandler,
                                 "IAR ARM Compiler",
                                 defaultPath,
                                 {detectionPath},
                                 "IARToolchain",                          // settings key
-                                McuToolChainPackage::ToolChainType::IAR, // toolchainType
+                                McuToolchainPackage::ToolchainType::IAR, // toolchainType
                                 versions,
                                 Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
                                 envVar,                                  // env var
@@ -494,13 +494,13 @@ static McuAbstractTargetFactory::Ptr createFactory(bool isLegacy,
                  return Legacy::createGhsToolchainPackage(settingsHandler, versions);
              }},
             {{"iar"}, {[settingsHandler](const QStringList &versions) {
-                 return Legacy::createIarToolChainPackage(settingsHandler, versions);
+                 return Legacy::createIarToolchainPackage(settingsHandler, versions);
              }}},
             {{"msvc"}, {[settingsHandler](const QStringList &versions) {
-                 return Legacy::createMsvcToolChainPackage(settingsHandler, versions);
+                 return Legacy::createMsvcToolchainPackage(settingsHandler, versions);
              }}},
             {{"gcc"}, {[settingsHandler](const QStringList &versions) {
-                 return Legacy::createGccToolChainPackage(settingsHandler, versions);
+                 return Legacy::createGccToolchainPackage(settingsHandler, versions);
              }}},
             {{"arm-greenhills"}, {[settingsHandler](const QStringList &versions) {
                  return Legacy::createGhsArmToolchainPackage(settingsHandler, versions);
@@ -585,7 +585,7 @@ McuSdkRepository targetsFromDescriptions(const QList<McuTargetDescription> &desc
 
     if (isLegacy) {
         auto [toolchainPkgs, vendorPkgs]{targetFactory->getAdditionalPackages()};
-        for (McuToolChainPackagePtr &package : toolchainPkgs) {
+        for (McuToolchainPackagePtr &package : toolchainPkgs) {
             mcuPackages.insert(package);
         }
         for (McuPackagePtr &package : vendorPkgs) {
diff --git a/src/plugins/mcusupport/mcusupportsdk.h b/src/plugins/mcusupport/mcusupportsdk.h
index e4d6576df4f..f63036f34eb 100644
--- a/src/plugins/mcusupport/mcusupportsdk.h
+++ b/src/plugins/mcusupport/mcusupportsdk.h
@@ -15,7 +15,7 @@ class McuAbstractPackage;
 class McuPackage;
 class McuSdkRepository;
 class McuTarget;
-class McuToolChainPackage;
+class McuToolchainPackage;
 struct McuTargetDescription;
 
 McuPackagePtr createQtForMCUsPackage(const SettingsHandler::Ptr &);
@@ -35,16 +35,16 @@ Utils::FilePath kitsPath(const Utils::FilePath &dir);
 
 namespace Legacy {
 
-McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &,
+McuPackagePtr createUnsupportedToolchainFilePackage(const SettingsHandler::Ptr &,
                                                     const Utils::FilePath &qtMcuSdkPath);
-McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &);
-McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &,
+McuToolchainPackagePtr createUnsupportedToolchainPackage(const SettingsHandler::Ptr &);
+McuToolchainPackagePtr createIarToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
+McuToolchainPackagePtr createGccToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
+McuToolchainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &,
                                                     const QStringList &);
-McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &,
+McuToolchainPackagePtr createMsvcToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
+McuToolchainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
+McuToolchainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &,
                                                     const QStringList &);
 
 McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &, const McuTargetDescription &);
diff --git a/src/plugins/mcusupport/mcutarget.cpp b/src/plugins/mcusupport/mcutarget.cpp
index 84cc80f7aa0..8a053353e79 100644
--- a/src/plugins/mcusupport/mcutarget.cpp
+++ b/src/plugins/mcusupport/mcutarget.cpp
@@ -19,7 +19,7 @@ McuTarget::McuTarget(const QVersionNumber &qulVersion,
                      const Platform &platform,
                      OS os,
                      const Packages &packages,
-                     const McuToolChainPackagePtr &toolChainPackage,
+                     const McuToolchainPackagePtr &toolChainPackage,
                      const McuPackagePtr &toolChainFilePackage,
                      int colorDepth)
     : m_qulVersion(qulVersion)
@@ -36,7 +36,7 @@ Packages McuTarget::packages() const
     return m_packages;
 }
 
-McuToolChainPackagePtr McuTarget::toolChainPackage() const
+McuToolchainPackagePtr McuTarget::toolChainPackage() const
 {
     return m_toolChainPackage;
 }
@@ -72,10 +72,10 @@ QString McuTarget::desktopCompilerId() const
     // for MSVC and MinGW.
     if (m_toolChainPackage) {
         switch (m_toolChainPackage->toolchainType()) {
-        case McuToolChainPackage::ToolChainType::MSVC:
+        case McuToolchainPackage::ToolchainType::MSVC:
             return QLatin1String("msvc");
-        case McuToolChainPackage::ToolChainType::GCC:
-        case McuToolChainPackage::ToolChainType::MinGW:
+        case McuToolchainPackage::ToolchainType::GCC:
+        case McuToolchainPackage::ToolchainType::MinGW:
             return QLatin1String("gnu");
         default:
             return QLatin1String("unsupported");
diff --git a/src/plugins/mcusupport/mcutarget.h b/src/plugins/mcusupport/mcutarget.h
index 0d87f739ff5..822c625e14c 100644
--- a/src/plugins/mcusupport/mcutarget.h
+++ b/src/plugins/mcusupport/mcutarget.h
@@ -19,7 +19,7 @@ class InfoLabel;
 
 namespace McuSupport::Internal {
 
-class McuToolChainPackage;
+class McuToolchainPackage;
 
 class McuTarget : public QObject
 {
@@ -41,13 +41,13 @@ public:
               const Platform &platform,
               OS os,
               const Packages &packages,
-              const McuToolChainPackagePtr &toolChainPackage,
+              const McuToolchainPackagePtr &toolChainPackage,
               const McuPackagePtr &toolChainFilePackage,
               int colorDepth = UnspecifiedColorDepth);
 
     QVersionNumber qulVersion() const;
     Packages packages() const;
-    McuToolChainPackagePtr toolChainPackage() const;
+    McuToolchainPackagePtr toolChainPackage() const;
     McuPackagePtr toolChainFilePackage() const;
     Platform platform() const;
     OS os() const;
@@ -67,7 +67,7 @@ private:
     const Platform m_platform;
     const OS m_os;
     const Packages m_packages;
-    McuToolChainPackagePtr m_toolChainPackage;
+    McuToolchainPackagePtr m_toolChainPackage;
     McuPackagePtr m_toolChainFilePackage;
     const int m_colorDepth;
 }; // class McuTarget
diff --git a/src/plugins/mcusupport/mcutargetfactory.cpp b/src/plugins/mcusupport/mcutargetfactory.cpp
index 98f9854e3ac..120e2ce89ca 100644
--- a/src/plugins/mcusupport/mcutargetfactory.cpp
+++ b/src/plugins/mcusupport/mcutargetfactory.cpp
@@ -18,11 +18,11 @@
 
 namespace McuSupport::Internal {
 
-bool isDesktopToolchain(McuToolChainPackage::ToolChainType type)
+bool isDesktopToolchain(McuToolchainPackage::ToolchainType type)
 {
-    return type == McuToolChainPackage::ToolChainType::MSVC
-           || type == McuToolChainPackage::ToolChainType::GCC
-           || type == McuToolChainPackage::ToolChainType::MinGW;
+    return type == McuToolchainPackage::ToolchainType::MSVC
+           || type == McuToolchainPackage::ToolchainType::GCC
+           || type == McuToolchainPackage::ToolchainType::MinGW;
 }
 
 McuPackageVersionDetector *createVersionDetection(const VersionDetection &versionDetection)
@@ -82,7 +82,7 @@ QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescript
         if (!toolchain || !toolchainFile)
             continue;
         Packages targetPackages = createPackages(desc);
-        McuToolChainPackagePtr toolchainPtr{toolchain};
+        McuToolchainPackagePtr toolchainPtr{toolchain};
         targetPackages.insert({toolchainPtr});
         targetPackages.insert({qtForMCUsPackage});
         targetPackages.unite({toolchainFile});
@@ -141,29 +141,29 @@ McuPackagePtr McuTargetFactory::createPackage(const PackageDescription &pkgDesc)
                                         pkgDesc.type}};
 }
 
-McuToolChainPackage *McuTargetFactory::createToolchain(
+McuToolchainPackage *McuTargetFactory::createToolchain(
     const McuTargetDescription::Toolchain &toolchain,
     const Utils::FilePath &sourceFile
     )
 {
-    const static QMap<QString, McuToolChainPackage::ToolChainType> toolchainTypeMapping{
-        {"iar", McuToolChainPackage::ToolChainType::IAR},
-        {"keil", McuToolChainPackage::ToolChainType::KEIL},
-        {"msvc", McuToolChainPackage::ToolChainType::MSVC},
-        {"gcc", McuToolChainPackage::ToolChainType::GCC},
-        {"mingw", McuToolChainPackage::ToolChainType::MinGW},
-        {"armgcc", McuToolChainPackage::ToolChainType::ArmGcc},
-        {"greenhills", McuToolChainPackage::ToolChainType::GHS},
-        {"arm-greenhills", McuToolChainPackage::ToolChainType::GHSArm},
+    const static QMap<QString, McuToolchainPackage::ToolchainType> toolchainTypeMapping{
+        {"iar", McuToolchainPackage::ToolchainType::IAR},
+        {"keil", McuToolchainPackage::ToolchainType::KEIL},
+        {"msvc", McuToolchainPackage::ToolchainType::MSVC},
+        {"gcc", McuToolchainPackage::ToolchainType::GCC},
+        {"mingw", McuToolchainPackage::ToolchainType::MinGW},
+        {"armgcc", McuToolchainPackage::ToolchainType::ArmGcc},
+        {"greenhills", McuToolchainPackage::ToolchainType::GHS},
+        {"arm-greenhills", McuToolchainPackage::ToolchainType::GHSArm},
     };
 
     const PackageDescription compilerDescription{toolchain.compiler};
 
-    McuToolChainPackage::ToolChainType toolchainType
-        = toolchainTypeMapping.value(toolchain.id, McuToolChainPackage::ToolChainType::Unsupported);
+    McuToolchainPackage::ToolchainType toolchainType
+        = toolchainTypeMapping.value(toolchain.id, McuToolchainPackage::ToolchainType::Unsupported);
 
     if (isDesktopToolchain(toolchainType)) {
-        return new McuToolChainPackage{settingsHandler,
+        return new McuToolchainPackage{settingsHandler,
                                        compilerDescription.label,
                                        compilerDescription.defaultPath,
                                        compilerDescription.detectionPaths,
@@ -189,7 +189,7 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
     }
 
     if (!errorMessage.isEmpty()) {
-        toolchainType = McuToolChainPackage::ToolChainType::Unsupported;
+        toolchainType = McuToolchainPackage::ToolchainType::Unsupported;
 
         if (toolchain.id.isEmpty()) {
             printMessage(Tr::tr("Toolchain is invalid because %2 in file \"%3\".")
@@ -203,7 +203,7 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
 
     }
 
-    return new McuToolChainPackage{settingsHandler,
+    return new McuToolchainPackage{settingsHandler,
                                    compilerDescription.label,
                                    compilerDescription.defaultPath,
                                    compilerDescription.detectionPaths,
diff --git a/src/plugins/mcusupport/mcutargetfactory.h b/src/plugins/mcusupport/mcutargetfactory.h
index 544b78a561c..43f09b0465f 100644
--- a/src/plugins/mcusupport/mcutargetfactory.h
+++ b/src/plugins/mcusupport/mcutargetfactory.h
@@ -20,7 +20,7 @@ public:
     QPair<Targets, Packages> createTargets(const McuTargetDescription &,
                                            const McuPackagePtr &qtForMCUsPackage) override;
     Packages createPackages(const McuTargetDescription &);
-    McuToolChainPackage *createToolchain(const McuTargetDescription::Toolchain &, const Utils::FilePath &sourceFile = Utils::FilePath());
+    McuToolchainPackage *createToolchain(const McuTargetDescription::Toolchain &, const Utils::FilePath &sourceFile = Utils::FilePath());
     McuPackagePtr createPackage(const PackageDescription &);
 
 private:
diff --git a/src/plugins/mcusupport/mcutargetfactorylegacy.cpp b/src/plugins/mcusupport/mcutargetfactorylegacy.cpp
index 753cd8a2efa..a5077f3eba0 100644
--- a/src/plugins/mcusupport/mcutargetfactorylegacy.cpp
+++ b/src/plugins/mcusupport/mcutargetfactorylegacy.cpp
@@ -31,14 +31,14 @@ QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescript
     QHash<QString, McuPackagePtr> freeRTOSPkgs;
     Targets mcuTargets;
     Packages packages;
-    McuToolChainPackagePtr toolchainPackage = getToolchainCompiler(desc.toolchain);
+    McuToolchainPackagePtr toolchainPackage = getToolchainCompiler(desc.toolchain);
     McuPackagePtr toolchainFilePackage = getToolchainFile(qtForMcuPath, desc.toolchain.id);
     for (int colorDepth : desc.platform.colorDepths) {
         Packages required3rdPartyPkgs;
         // Desktop toolchains don't need any additional settings
         if (toolchainPackage
             && toolchainPackage->toolchainType()
-                   != McuToolChainPackage::ToolChainType::Unsupported) {
+                   != McuToolchainPackage::ToolchainType::Unsupported) {
             required3rdPartyPkgs.insert(toolchainPackage);
         }
 
@@ -90,13 +90,13 @@ McuAbstractTargetFactory::AdditionalPackages McuTargetFactory::getAdditionalPack
     return {{}, vendorPkgs};
 }
 
-McuToolChainPackagePtr McuTargetFactory::getToolchainCompiler(
+McuToolchainPackagePtr McuTargetFactory::getToolchainCompiler(
     const McuTargetDescription::Toolchain &desc) const
 {
     auto compilerCreator = toolchainCreators.value(desc.id, [this](const QStringList & /*versions*/) {
-        return McuToolChainPackagePtr{Legacy::createUnsupportedToolChainPackage(settingsHandler)};
+        return McuToolchainPackagePtr{Legacy::createUnsupportedToolchainPackage(settingsHandler)};
     });
-    McuToolChainPackagePtr toolchainPackage = compilerCreator(desc.versions);
+    McuToolchainPackagePtr toolchainPackage = compilerCreator(desc.versions);
     return toolchainPackage;
 }
 
@@ -107,7 +107,7 @@ McuPackagePtr McuTargetFactory::getToolchainFile(const Utils::FilePath &qtForMCU
         return toolchainFile;
     } else {
         return McuPackagePtr{
-            Legacy::createUnsupportedToolChainFilePackage(settingsHandler, qtForMCUSdkPath)};
+            Legacy::createUnsupportedToolchainFilePackage(settingsHandler, qtForMCUSdkPath)};
     }
 }
 } // namespace McuSupport::Internal::Legacy
diff --git a/src/plugins/mcusupport/mcutargetfactorylegacy.h b/src/plugins/mcusupport/mcutargetfactorylegacy.h
index 5fcf52a1734..7d92add06cd 100644
--- a/src/plugins/mcusupport/mcutargetfactorylegacy.h
+++ b/src/plugins/mcusupport/mcutargetfactorylegacy.h
@@ -17,7 +17,7 @@ class McuPackage;
 
 namespace Legacy {
 
-using ToolchainCompilerCreator = std::function<McuToolChainPackagePtr(const QStringList &version)>;
+using ToolchainCompilerCreator = std::function<McuToolchainPackagePtr(const QStringList &version)>;
 
 class McuTargetFactory : public McuAbstractTargetFactory
 {
@@ -31,7 +31,7 @@ public:
                                            const McuPackagePtr &qtForMCUsPackage) override;
     AdditionalPackages getAdditionalPackages() const override;
 
-    McuToolChainPackagePtr getToolchainCompiler(const McuTargetDescription::Toolchain &) const;
+    McuToolchainPackagePtr getToolchainCompiler(const McuTargetDescription::Toolchain &) const;
     McuPackagePtr getToolchainFile(const Utils::FilePath &qtForMCUSdkPath,
                                    const QString &toolchainName) const;
 
diff --git a/src/plugins/mcusupport/test/unittest.cpp b/src/plugins/mcusupport/test/unittest.cpp
index 01feb09a005..d523d6a4bf1 100644
--- a/src/plugins/mcusupport/test/unittest.cpp
+++ b/src/plugins/mcusupport/test/unittest.cpp
@@ -210,7 +210,7 @@ auto expandTargetsAndPackages = [](Targets &targets, Packages &packages) {
     McuSdkRepository{targets, packages}.expandVariablesAndWildcards();
 };
 
-void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
+void verifyIarToolchain(const McuToolchainPackagePtr &iarToolchainPackage)
 {
     ProjectExplorer::ToolchainFactory toolchainFactory;
     Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
@@ -222,8 +222,8 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
     QCOMPARE(iarToolchainPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);
     QCOMPARE(iarToolchainPackage->environmentVariableName(), iarEnvVar);
     QCOMPARE(iarToolchainPackage->isDesktopToolchain(), false);
-    QCOMPARE(iarToolchainPackage->toolChainName(), iar);
-    QCOMPARE(iarToolchainPackage->toolchainType(), McuToolChainPackage::ToolChainType::IAR);
+    QCOMPARE(iarToolchainPackage->toolchainName(), iar);
+    QCOMPARE(iarToolchainPackage->toolchainType(), McuToolchainPackage::ToolchainType::IAR);
     QCOMPARE(iarToolchainPackage->label(), iarLabel);
 
     iarToolchain = iarToolchainPackage->toolChain(cxxLanguageId);
@@ -232,7 +232,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
     QCOMPARE(iarToolchain->detection(), Toolchain::UninitializedDetection);
 }
 
-void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QStringList &versions)
+void verifyArmGccToolchain(const McuToolchainPackagePtr &armGccPackage, const QStringList &versions)
 {
     //Fake register and fake detect compiler.
     ProjectExplorer::ToolchainFactory toolchainFactory;
@@ -246,46 +246,46 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
     QCOMPARE(armGccPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);
     QCOMPARE(armGccPackage->environmentVariableName(), armGccEnvVar);
     QCOMPARE(armGccPackage->isDesktopToolchain(), false);
-    QCOMPARE(armGccPackage->toolChainName(), armGcc);
-    QCOMPARE(armGccPackage->toolchainType(), McuToolChainPackage::ToolChainType::ArmGcc);
+    QCOMPARE(armGccPackage->toolchainName(), armGcc);
+    QCOMPARE(armGccPackage->toolchainType(), McuToolchainPackage::ToolchainType::ArmGcc);
     QCOMPARE(armGccPackage->settingsKey(), armGccDirectorySetting);
     QCOMPARE(armGccPackage->versions(), versions);
 
-    // FIXME(piotr.mucko): Re-enable when toolchains retrieval from McuToolChainPackage is unified for arm and iar.
+    // FIXME(piotr.mucko): Re-enable when toolchains retrieval from McuToolchainPackage is unified for arm and iar.
     // armToolchain = armGccPackage->toolChain(cxxLanguageId);
     // QVERIFY(armToolchain != nullptr);
 }
 
-void verifyGccToolchain(const McuToolChainPackagePtr &gccPackage, const QStringList &versions)
+void verifyGccToolchain(const McuToolchainPackagePtr &gccPackage, const QStringList &versions)
 {
     QVERIFY(gccPackage != nullptr);
     QCOMPARE(gccPackage->cmakeVariableName(), "");
     QCOMPARE(gccPackage->environmentVariableName(), "");
     QCOMPARE(gccPackage->isDesktopToolchain(), true);
-    QCOMPARE(gccPackage->toolChainName(), "gcc");
-    QCOMPARE(gccPackage->toolchainType(), McuToolChainPackage::ToolChainType::GCC);
+    QCOMPARE(gccPackage->toolchainName(), "gcc");
+    QCOMPARE(gccPackage->toolchainType(), McuToolchainPackage::ToolchainType::GCC);
     QVERIFY(allOf(versions, [&](const QString &v) { return gccPackage->versions().contains(v); }));
 }
 
-void verifyMsvcToolchain(const McuToolChainPackagePtr &msvcPackage, const QStringList &versions)
+void verifyMsvcToolchain(const McuToolchainPackagePtr &msvcPackage, const QStringList &versions)
 {
     QVERIFY(msvcPackage != nullptr);
     QCOMPARE(msvcPackage->cmakeVariableName(), "");
     QCOMPARE(msvcPackage->environmentVariableName(), "");
-    QCOMPARE(msvcPackage->toolchainType(), McuToolChainPackage::ToolChainType::MSVC);
+    QCOMPARE(msvcPackage->toolchainType(), McuToolchainPackage::ToolchainType::MSVC);
     QCOMPARE(msvcPackage->isDesktopToolchain(), true);
-    QCOMPARE(msvcPackage->toolChainName(), "msvc");
+    QCOMPARE(msvcPackage->toolchainName(), "msvc");
     QVERIFY(allOf(versions, [&](const QString &v) { return msvcPackage->versions().contains(v); }));
 }
 
-void verifyMingwToolchain(const McuToolChainPackagePtr &mingwPackage, const QStringList &versions)
+void verifyMingwToolchain(const McuToolchainPackagePtr &mingwPackage, const QStringList &versions)
 {
     QVERIFY(mingwPackage != nullptr);
     QCOMPARE(mingwPackage->cmakeVariableName(), "");
     QCOMPARE(mingwPackage->environmentVariableName(), "");
-    QCOMPARE(mingwPackage->toolchainType(), McuToolChainPackage::ToolChainType::MinGW);
+    QCOMPARE(mingwPackage->toolchainType(), McuToolchainPackage::ToolchainType::MinGW);
     QCOMPARE(mingwPackage->isDesktopToolchain(), true);
-    QCOMPARE(mingwPackage->toolChainName(), "mingw");
+    QCOMPARE(mingwPackage->toolchainName(), "mingw");
     QVERIFY(allOf(versions, [&](const QString &v) { return mingwPackage->versions().contains(v); }));
 }
 
@@ -404,34 +404,34 @@ McuSupportTest::McuSupportTest()
         PackageDescription{},
         McuTargetDescription::FreeRTOS{},
     }
-    , toolchainPackagePtr{new McuToolChainPackage{
+    , toolchainPackagePtr{new McuToolchainPackage{
           settingsMockPtr,
           {},                                              // label
           {},                                              // defaultPath
           {},                                              // detectionPath
           {},                                              // settingsKey
-          McuToolChainPackage::ToolChainType::Unsupported, // toolchain type
+          McuToolchainPackage::ToolchainType::Unsupported, // toolchain type
           {},                                              // versions
           {},                                              // cmake var name
           {},                                              // env var name
           nullptr                                          // version detector
       }}
-    , armGccToolchainPackagePtr{new McuToolChainPackage{settingsMockPtr,
+    , armGccToolchainPackagePtr{new McuToolchainPackage{settingsMockPtr,
                                                         armGccLabel,
                                                         armGccDir,
                                                         {}, // validation path
                                                         armGccDirectorySetting,
-                                                        McuToolChainPackage::ToolChainType::ArmGcc,
+                                                        McuToolchainPackage::ToolchainType::ArmGcc,
                                                         {armGccVersion},
                                                         TOOLCHAIN_DIR_CMAKE_VARIABLE,
                                                         armGccEnvVar,
                                                         nullptr}}
-    , iarToolchainPackagePtr{new McuToolChainPackage{settingsMockPtr,
+    , iarToolchainPackagePtr{new McuToolchainPackage{settingsMockPtr,
                                                      iarLabel,
                                                      iarDir,
                                                      {}, // validation path
                                                      iarSetting,
-                                                     McuToolChainPackage::ToolChainType::IAR,
+                                                     McuToolchainPackage::ToolchainType::IAR,
                                                      {armGccVersion},
                                                      TOOLCHAIN_DIR_CMAKE_VARIABLE,
                                                      iarEnvVar,
@@ -580,7 +580,7 @@ void McuSupportTest::test_parseToolchainFromJSON()
 
 void McuSupportTest::test_legacy_createIarToolchain()
 {
-    McuToolChainPackagePtr iarToolchainPackage = Legacy::createIarToolChainPackage(settingsMockPtr,
+    McuToolchainPackagePtr iarToolchainPackage = Legacy::createIarToolchainPackage(settingsMockPtr,
                                                                                    iarVersions);
     verifyIarToolchain(iarToolchainPackage);
 }
@@ -589,13 +589,13 @@ void McuSupportTest::test_createIarToolchain()
 {
     const auto description = parseDescriptionJson(iar_stm32f469i_discovery_baremetal_json);
 
-    McuToolChainPackagePtr iarToolchainPackage{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr iarToolchainPackage{targetFactory.createToolchain(description.toolchain)};
     verifyIarToolchain(iarToolchainPackage);
 }
 
 void McuSupportTest::test_legacy_createDesktopGccToolchain()
 {
-    McuToolChainPackagePtr gccPackage = Legacy::createGccToolChainPackage(settingsMockPtr,
+    McuToolchainPackagePtr gccPackage = Legacy::createGccToolchainPackage(settingsMockPtr,
                                                                           {armGccVersion});
     verifyGccToolchain(gccPackage, {armGccVersion});
 }
@@ -603,13 +603,13 @@ void McuSupportTest::test_legacy_createDesktopGccToolchain()
 void McuSupportTest::test_createDesktopGccToolchain()
 {
     const auto description = parseDescriptionJson(gcc_desktop_json);
-    McuToolChainPackagePtr gccPackage{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr gccPackage{targetFactory.createToolchain(description.toolchain)};
     verifyGccToolchain(gccPackage, {});
 }
 
 void McuSupportTest::test_legacy_createDesktopMsvcToolchain()
 {
-    McuToolChainPackagePtr msvcPackage = Legacy::createMsvcToolChainPackage(settingsMockPtr,
+    McuToolchainPackagePtr msvcPackage = Legacy::createMsvcToolchainPackage(settingsMockPtr,
                                                                             {msvcVersion});
     verifyMsvcToolchain(msvcPackage, {msvcVersion});
 }
@@ -617,14 +617,14 @@ void McuSupportTest::test_legacy_createDesktopMsvcToolchain()
 void McuSupportTest::test_createDesktopMsvcToolchain()
 {
     const auto description = parseDescriptionJson(msvc_desktop_json);
-    McuToolChainPackagePtr msvcPackage{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr msvcPackage{targetFactory.createToolchain(description.toolchain)};
     verifyMsvcToolchain(msvcPackage, {});
 }
 
 void McuSupportTest::test_createDesktopMingwToolchain()
 {
     const auto description = parseDescriptionJson(mingw_desktop_json);
-    McuToolChainPackagePtr mingwPackage{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr mingwPackage{targetFactory.createToolchain(description.toolchain)};
     verifyMingwToolchain(mingwPackage, {"11.2.0"});
 }
 
@@ -635,7 +635,7 @@ void McuSupportTest::test_verifyManuallyCreatedArmGccToolchain()
 
 void McuSupportTest::test_legacy_createArmGccToolchain()
 {
-    McuToolChainPackagePtr armGccPackage = Legacy::createArmGccToolchainPackage(settingsMockPtr,
+    McuToolchainPackagePtr armGccPackage = Legacy::createArmGccToolchainPackage(settingsMockPtr,
                                                                                 {armGccVersion});
     verifyArmGccToolchain(armGccPackage, {armGccVersion});
 }
@@ -656,31 +656,31 @@ void McuSupportTest::test_createArmGccToolchain()
     QFETCH(QString, json);
 
     const auto description = parseDescriptionJson(json.toLocal8Bit());
-    McuToolChainPackagePtr armGccPackage{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr armGccPackage{targetFactory.createToolchain(description.toolchain)};
     verifyArmGccToolchain(armGccPackage, description.toolchain.versions);
 }
 
 void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType_data()
 {
     QTest::addColumn<McuTargetDescription>("description");
-    QTest::addColumn<McuToolChainPackage::ToolChainType>("toolchainType");
+    QTest::addColumn<McuToolchainPackage::ToolchainType>("toolchainType");
 
     QTest::newRow("armgcc_stm32h750b_discovery_baremetal_json")
         << parseDescriptionJson(armgcc_stm32h750b_discovery_baremetal_json)
-        << McuToolChainPackage::ToolChainType::ArmGcc;
+        << McuToolchainPackage::ToolchainType::ArmGcc;
     QTest::newRow("iar_mimxrt1064_evk_freertos_json")
         << parseDescriptionJson(iar_mimxrt1064_evk_freertos_json)
-        << McuToolChainPackage::ToolChainType::IAR;
+        << McuToolchainPackage::ToolchainType::IAR;
     QTest::newRow("iar_stm32f469i") << parseDescriptionJson(iar_stm32f469i_discovery_baremetal_json)
-                                    << McuToolChainPackage::ToolChainType::IAR;
+                                    << McuToolchainPackage::ToolchainType::IAR;
 }
 
 void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType()
 {
     QFETCH(McuTargetDescription, description);
-    QFETCH(McuToolChainPackage::ToolChainType, toolchainType);
+    QFETCH(McuToolchainPackage::ToolchainType, toolchainType);
 
-    const McuToolChainPackage *toolchain{targetFactory.createToolchain(description.toolchain)};
+    const McuToolchainPackage *toolchain{targetFactory.createToolchain(description.toolchain)};
 
     QVERIFY(toolchain != nullptr);
     QCOMPARE(toolchain->toolchainType(), toolchainType);
@@ -857,7 +857,7 @@ void McuSupportTest::test_useFallbackPathForToolchainWhenPathFromSettingsIsNotAv
         .Times(2)
         .WillRepeatedly(Return(FilePath{fallbackDir}));
 
-    McuToolChainPackage *toolchain = targetFactory.createToolchain(toolchainDescription);
+    McuToolchainPackage *toolchain = targetFactory.createToolchain(toolchainDescription);
 
     QCOMPARE(toolchain->path().toString(), fallbackDir);
 }
@@ -882,7 +882,7 @@ void McuSupportTest::test_usePathFromSettingsForToolchainPath()
         .WillOnce(Return(FilePath{empty}))      // system scope settings
         .WillOnce(Return(FilePath{armGccDir})); // user scope settings
 
-    McuToolChainPackage *toolchain = targetFactory.createToolchain(toolchainDescription);
+    McuToolchainPackage *toolchain = targetFactory.createToolchain(toolchainDescription);
     QCOMPARE(toolchain->path().toString(), armGccDir);
 }
 
@@ -1312,7 +1312,7 @@ void McuSupportTest::test_passExecutableVersionDetectorToToolchainPackage()
     QCOMPARE(description.toolchain.compiler.versionDetection.executableArgs, versionDetectionArgs);
     QCOMPARE(description.toolchain.compiler.versionDetection.regex, versionRegex);
 
-    McuToolChainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)};
 
     const auto *versionDetector{toolchain->getVersionDetector()};
     QVERIFY(versionDetector != nullptr);
@@ -1333,7 +1333,7 @@ void McuSupportTest::test_legacy_passExecutableVersionDetectorToToolchainPackage
     QFETCH(QString, versionRegex);
 
     const McuTargetDescription description = parseDescriptionJson(json.toLocal8Bit());
-    McuToolChainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)};
+    McuToolchainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)};
 
     const auto *versionDetector{toolchain->getVersionDetector()};
     QVERIFY(versionDetector != nullptr);
diff --git a/src/plugins/mcusupport/test/unittest.h b/src/plugins/mcusupport/test/unittest.h
index 43a4dc5cef5..77ade01e617 100644
--- a/src/plugins/mcusupport/test/unittest.h
+++ b/src/plugins/mcusupport/test/unittest.h
@@ -124,9 +124,9 @@ private:
     PackageDescription compilerDescription;
     PackageDescription toochainFileDescription;
     McuTargetDescription targetDescription;
-    McuToolChainPackagePtr toolchainPackagePtr;
-    McuToolChainPackagePtr armGccToolchainPackagePtr;
-    McuToolChainPackagePtr iarToolchainPackagePtr;
+    McuToolchainPackagePtr toolchainPackagePtr;
+    McuToolchainPackagePtr armGccToolchainPackagePtr;
+    McuToolchainPackagePtr iarToolchainPackagePtr;
     PackageMock *armGccToolchainFilePackage{new PackageMock};
     McuPackagePtr armGccToolchainFilePackagePtr{armGccToolchainFilePackage};
     McuTarget::Platform platform;