McuSupport: refactor McuPackage

rename 'type' to 'toolChainType' in McuToolChainPackage
'addToPath' and 'relativePath' set in McuPackage constructor
put McuToolChainPackage methods together in same source file
'detectionPath' type changed from QString to FilePath
renamed boolean getters

Task-number: QTCREATORBUG-26897
Change-Id: If59c299901a169d08efa8f39614ef7c6d48d44ed
Reviewed-by: Piotr Mućko <piotr.mucko@qt.io>
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>

12 files changed, 408 insertions, 406 deletions

diff --git a/src/plugins/mcusupport/mcuabstractpackage.h b/src/plugins/mcusupport/mcuabstractpackage.h
index 9406b474fb..e0499ef06f 100644
--- a/src/plugins/mcusupport/mcuabstractpackage.h
+++ b/src/plugins/mcusupport/mcuabstractpackage.h
@@ -45,22 +45,22 @@ public:
         ValidPackage
     };
 
+    virtual QString label() const = 0;
+    virtual const QString &environmentVariableName() const = 0;
+    virtual bool isAddToSystemPath() const = 0;
+    virtual void setVersions(const QStringList &) = 0;
+
     virtual Utils::FilePath basePath() const = 0;
     virtual Utils::FilePath path() const = 0;
-    virtual QString label() const = 0;
     virtual Utils::FilePath defaultPath() const = 0;
-    virtual QString detectionPath() const = 0;
-    virtual QString statusText() const = 0;
-    virtual void updateStatus() = 0;
+    virtual Utils::FilePath detectionPath() const = 0;
 
+    virtual void updateStatus() = 0;
     virtual Status status() const = 0;
-    virtual bool validStatus() const = 0;
-    virtual const QString &environmentVariableName() const = 0;
-    virtual void setAddToPath(bool) = 0;
-    virtual bool addToPath() const = 0;
+    virtual QString statusText() const = 0;
+    virtual bool isValidStatus() const = 0;
+
     virtual bool writeToSettings() const = 0;
-    virtual void setRelativePathModifier(const QString &) = 0;
-    virtual void setVersions(const QStringList &) = 0;
 
     virtual QWidget *widget() = 0;
 
diff --git a/src/plugins/mcusupport/mcukitmanager.cpp b/src/plugins/mcusupport/mcukitmanager.cpp
index 5fffe2b8da..6b52b475cb 100644
--- a/src/plugins/mcusupport/mcukitmanager.cpp
+++ b/src/plugins/mcusupport/mcukitmanager.cpp
@@ -68,19 +68,19 @@ static FilePath qulDocsDir()
 
 static void setKitToolchains(Kit *k, const McuToolChainPackage *tcPackage)
 {
-    switch (tcPackage->type()) {
-    case McuToolChainPackage::Type::Unsupported:
+    switch (tcPackage->toolchainType()) {
+    case McuToolChainPackage::ToolChainType::Unsupported:
         return;
 
-    case McuToolChainPackage::Type::GHS:
-    case McuToolChainPackage::Type::GHSArm:
+    case McuToolChainPackage::ToolChainType::GHS:
+    case McuToolChainPackage::ToolChainType::GHSArm:
         return; // No Green Hills toolchain, because support for it is missing.
 
-    case McuToolChainPackage::Type::IAR:
-    case McuToolChainPackage::Type::KEIL:
-    case McuToolChainPackage::Type::MSVC:
-    case McuToolChainPackage::Type::GCC:
-    case McuToolChainPackage::Type::ArmGcc:
+    case McuToolChainPackage::ToolChainType::IAR:
+    case McuToolChainPackage::ToolChainType::KEIL:
+    case McuToolChainPackage::ToolChainType::MSVC:
+    case McuToolChainPackage::ToolChainType::GCC:
+    case McuToolChainPackage::ToolChainType::ArmGcc:
         ToolChainKitAspect::setToolChain(k,
                                          tcPackage->toolChain(
                                              ProjectExplorer::Constants::C_LANGUAGE_ID));
@@ -136,17 +136,17 @@ static void setKitDebugger(Kit *k, const McuToolChainPackage *tcPackage)
         return;
     }
 
-    switch (tcPackage->type()) {
-    case McuToolChainPackage::Type::Unsupported:
-    case McuToolChainPackage::Type::GHS:
-    case McuToolChainPackage::Type::GHSArm:
-    case McuToolChainPackage::Type::IAR:
+    switch (tcPackage->toolchainType()) {
+    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::Type::KEIL:
-    case McuToolChainPackage::Type::MSVC:
-    case McuToolChainPackage::Type::GCC:
-    case McuToolChainPackage::Type::ArmGcc: {
+    case McuToolChainPackage::ToolChainType::KEIL:
+    case McuToolChainPackage::ToolChainType::MSVC:
+    case McuToolChainPackage::ToolChainType::GCC:
+    case McuToolChainPackage::ToolChainType::ArmGcc: {
         const QVariant debuggerId = tcPackage->debuggerId();
         if (debuggerId.isValid()) {
             Debugger::DebuggerKitAspect::setDebugger(k, debuggerId);
@@ -182,7 +182,7 @@ static void setKitDependencies(Kit *k,
     auto processPackage = [&dependencies](const McuAbstractPackage *package) {
         if (!package->environmentVariableName().isEmpty())
             dependencies.append({package->environmentVariableName(),
-                                 QDir::toNativeSeparators(package->detectionPath())});
+                                 package->detectionPath().toUserOutput()});
     };
     for (auto package : mcuTarget->packages())
         processPackage(package);
@@ -201,8 +201,8 @@ static void setKitCMakeOptions(Kit *k, const McuTarget *mcuTarget, const FilePat
 
     CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
     // CMake ToolChain file for ghs handles CMAKE_*_COMPILER autonomously
-    if (mcuTarget->toolChainPackage()->type() != McuToolChainPackage::Type::GHS
-        && mcuTarget->toolChainPackage()->type() != McuToolChainPackage::Type::GHSArm) {
+    if (mcuTarget->toolChainPackage()->toolchainType() != McuToolChainPackage::ToolChainType::GHS
+        && mcuTarget->toolChainPackage()->toolchainType() != McuToolChainPackage::ToolChainType::GHSArm) {
         config.append(CMakeConfigItem("CMAKE_CXX_COMPILER", "%{Compiler:Executable:Cxx}"));
         config.append(CMakeConfigItem("CMAKE_C_COMPILER", "%{Compiler:Executable:C}"));
     }
@@ -240,8 +240,8 @@ static void setKitCMakeOptions(Kit *k, const McuTarget *mcuTarget, const FilePat
     CMakeConfigurationKitAspect::setConfiguration(k, config);
 
     if (HostOsInfo::isWindowsHost()) {
-        auto type = mcuTarget->toolChainPackage()->type();
-        if (type == McuToolChainPackage::Type::GHS || type == McuToolChainPackage::Type::GHSArm) {
+        auto type = mcuTarget->toolChainPackage()->toolchainType();
+        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");
@@ -389,13 +389,12 @@ void createAutomaticKits()
     const auto createKits = [qtForMCUsPackage]() {
         if (McuSupportOptions::automaticKitCreationFromSettings()) {
             qtForMCUsPackage->updateStatus();
-            if (!qtForMCUsPackage->validStatus()) {
+            if (!qtForMCUsPackage->isValidStatus()) {
                 switch (qtForMCUsPackage->status()) {
                 case McuAbstractPackage::Status::ValidPathInvalidPackage: {
-                    const QString displayPath
-                        = FilePath::fromString(qtForMCUsPackage->detectionPath()).toUserOutput();
                     printMessage(McuPackage::tr("Path %1 exists, but does not contain %2.")
-                                     .arg(qtForMCUsPackage->path().toUserOutput(), displayPath),
+                                     .arg(qtForMCUsPackage->path().toUserOutput(),
+                                          qtForMCUsPackage->detectionPath().toUserOutput()),
                                  true);
                     break;
                 }
@@ -408,7 +407,7 @@ void createAutomaticKits()
                 }
                 case McuAbstractPackage::Status::EmptyPath: {
                     printMessage(McuPackage::tr("Missing %1. Add the path in Tools > Options > Devices > MCU.")
-                                     .arg(qtForMCUsPackage->detectionPath()),
+                                     .arg(qtForMCUsPackage->detectionPath().toUserOutput()),
                                  true);
                     return;
                 }
@@ -575,7 +574,7 @@ void fixExistingKits()
     // Fix kit dependencies for known targets
     auto qtForMCUsPackage = Sdk::createQtForMCUsPackage();
     qtForMCUsPackage->updateStatus();
-    if (qtForMCUsPackage->validStatus()) {
+    if (qtForMCUsPackage->isValidStatus()) {
         FilePath dir = qtForMCUsPackage->path();
         McuSdkRepository repo;
         Sdk::targetsAndPackages(dir, &repo);
diff --git a/src/plugins/mcusupport/mcupackage.cpp b/src/plugins/mcusupport/mcupackage.cpp
index f108ca67f8..197389515a 100644
--- a/src/plugins/mcusupport/mcupackage.cpp
+++ b/src/plugins/mcusupport/mcupackage.cpp
@@ -28,26 +28,36 @@
 #include "mcusupportversiondetection.h"
 #include "mcusupportsdk.h"
 
+#include <baremetal/baremetalconstants.h>
 #include <coreplugin/icore.h>
+#include <utils/algorithm.h>
 #include <utils/infolabel.h>
 #include <utils/pathchooser.h>
 #include <utils/utilsicons.h>
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/toolchain.h>
+#include <projectexplorer/toolchainmanager.h>
+#include <debugger/debuggeritem.h>
+#include <debugger/debuggeritemmanager.h>
 
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QToolButton>
 
+using namespace ProjectExplorer;
 using namespace Utils;
 
 namespace McuSupport::Internal {
 
 McuPackage::McuPackage(const QString &label,
                        const FilePath &defaultPath,
-                       const QString &detectionPath,
+                       const FilePath &detectionPath,
                        const QString &settingsKey,
                        const QString &envVarName,
                        const QString &downloadUrl,
-                       const McuPackageVersionDetector *versionDetector)
+                       const McuPackageVersionDetector *versionDetector,
+                       const bool addToSystemPath,
+                       const FilePath &relativePathModifier)
     : m_label(label)
     , m_defaultPath(Sdk::packagePathFromSettings(settingsKey, QSettings::SystemScope, defaultPath))
     , m_detectionPath(detectionPath)
@@ -55,123 +65,50 @@ McuPackage::McuPackage(const QString &label,
     , m_versionDetector(versionDetector)
     , m_environmentVariableName(envVarName)
     , m_downloadUrl(downloadUrl)
+    , m_addToSystemPath(addToSystemPath)
+    , m_relativePathModifier(relativePathModifier)
 {
     m_path = Sdk::packagePathFromSettings(settingsKey, QSettings::UserScope, m_defaultPath);
 }
 
-FilePath McuPackage::basePath() const
-{
-    return m_fileChooser != nullptr ? m_fileChooser->filePath() : m_path;
-}
-
-FilePath McuPackage::path() const
-{
-    return basePath().resolvePath(m_relativePathModifier).absoluteFilePath();
-}
-
 QString McuPackage::label() const
 {
     return m_label;
 }
 
-FilePath McuPackage::defaultPath() const
-{
-    return m_defaultPath;
-}
-
-QString McuPackage::detectionPath() const
-{
-    return m_detectionPath;
-}
-
-QWidget *McuPackage::widget()
-{
-    if (m_widget)
-        return m_widget;
-
-    m_widget = new QWidget;
-    m_fileChooser = new PathChooser;
-    m_fileChooser->lineEdit()->setButtonIcon(FancyLineEdit::Right, Icons::RESET.icon());
-    m_fileChooser->lineEdit()->setButtonVisible(FancyLineEdit::Right, true);
-    connect(m_fileChooser->lineEdit(), &FancyLineEdit::rightButtonClicked, this, [&] {
-        m_fileChooser->setFilePath(m_defaultPath);
-    });
-
-    auto layout = new QGridLayout(m_widget);
-    layout->setContentsMargins(0, 0, 0, 0);
-    m_infoLabel = new InfoLabel();
-
-    if (!m_downloadUrl.isEmpty()) {
-        auto downLoadButton = new QToolButton;
-        downLoadButton->setIcon(Icons::ONLINE.icon());
-        downLoadButton->setToolTip(tr("Download from \"%1\"").arg(m_downloadUrl));
-        QObject::connect(downLoadButton, &QToolButton::pressed, this, [this] {
-            QDesktopServices::openUrl(m_downloadUrl);
-        });
-        layout->addWidget(downLoadButton, 0, 2);
-    }
-
-    layout->addWidget(m_fileChooser, 0, 0, 1, 2);
-    layout->addWidget(m_infoLabel, 1, 0, 1, -1);
-
-    m_fileChooser->setFilePath(m_path);
-
-    QObject::connect(this, &McuPackage::statusChanged, this, [this] { updateStatusUi(); });
-
-    QObject::connect(m_fileChooser, &PathChooser::pathChanged, this, [this] {
-        updatePath();
-        emit changed();
-    });
-
-    updateStatus();
-    return m_widget;
-}
-
-McuPackage::Status McuPackage::status() const
-{
-    return m_status;
-}
-
-bool McuPackage::validStatus() const
-{
-    return m_status == Status::ValidPackage || m_status == Status::ValidPackageMismatchedVersion;
-}
-
 const QString &McuPackage::environmentVariableName() const
 {
     return m_environmentVariableName;
 }
 
-void McuPackage::setAddToPath(bool addToPath)
+bool McuPackage::isAddToSystemPath() const
 {
-    m_addToPath = addToPath;
+    return m_addToSystemPath;
 }
 
-bool McuPackage::addToPath() const
+void McuPackage::setVersions(const QStringList &versions)
 {
-    return m_addToPath;
+    m_versions = versions;
 }
 
-bool McuPackage::writeToSettings() const
+FilePath McuPackage::basePath() const
 {
-    const FilePath savedPath = Sdk::packagePathFromSettings(m_settingsKey,
-                                                            QSettings::UserScope,
-                                                            m_defaultPath);
-    const QString key = QLatin1String(Constants::SETTINGS_GROUP) + '/'
-                        + QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX) + m_settingsKey;
-    Core::ICore::settings()->setValueWithDefault(key, m_path.toString(), m_defaultPath.toString());
+    return m_fileChooser != nullptr ? m_fileChooser->filePath() : m_path;
+}
 
-    return savedPath != m_path;
+FilePath McuPackage::path() const
+{
+    return basePath().resolvePath(m_relativePathModifier).absoluteFilePath();
 }
 
-void McuPackage::setRelativePathModifier(const QString &path)
+FilePath McuPackage::defaultPath() const
 {
-    m_relativePathModifier = path;
+    return m_defaultPath;
 }
 
-void McuPackage::setVersions(const QStringList &versions)
+FilePath McuPackage::detectionPath() const
 {
-    m_versions = versions;
+    return m_detectionPath;
 }
 
 void McuPackage::updatePath()
@@ -184,7 +121,7 @@ void McuPackage::updatePath()
 void McuPackage::updateStatus()
 {
     bool validPath = !m_path.isEmpty() && m_path.exists();
-    const FilePath detectionPath = basePath() / m_detectionPath;
+    const FilePath detectionPath = basePath().resolvePath(m_detectionPath);
     const bool validPackage = m_detectionPath.isEmpty() || detectionPath.exists();
     m_detectedVersion = validPath && validPackage && m_versionDetector
                             ? m_versionDetector->parseVersion(basePath().toString())
@@ -201,6 +138,17 @@ void McuPackage::updateStatus()
     emit statusChanged();
 }
 
+McuPackage::Status McuPackage::status() const
+{
+    return m_status;
+}
+
+bool McuPackage::isValidStatus() const
+{
+    return m_status == Status::ValidPackage || m_status == Status::ValidPackageMismatchedVersion;
+}
+
+
 void McuPackage::updateStatusUi()
 {
     switch (m_status) {
@@ -221,7 +169,7 @@ QString McuPackage::statusText() const
 {
     const QString displayPackagePath = m_path.toUserOutput();
     const QString displayVersions = m_versions.join(" or ");
-    const QString outDetectionPath = FilePath::fromString(m_detectionPath).toUserOutput();
+    const QString outDetectionPath = m_detectionPath.toUserOutput();
     const QString displayRequiredPath = m_versions.empty() ? outDetectionPath
                                                            : QString("%1 %2").arg(outDetectionPath,
                                                                                   displayVersions);
@@ -266,25 +214,256 @@ QString McuPackage::statusText() const
     return response;
 }
 
+bool McuPackage::writeToSettings() const
+{
+    const FilePath savedPath = Sdk::packagePathFromSettings(m_settingsKey,
+                                                            QSettings::UserScope,
+                                                            m_defaultPath);
+    const QString key = QLatin1String(Constants::SETTINGS_GROUP) + '/'
+                        + QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX) + m_settingsKey;
+    Core::ICore::settings()->setValueWithDefault(key, m_path.toString(), m_defaultPath.toString());
+
+    return savedPath != m_path;
+}
+
+QWidget *McuPackage::widget()
+{
+    if (m_widget)
+        return m_widget;
+
+    m_widget = new QWidget;
+    m_fileChooser = new PathChooser;
+    m_fileChooser->lineEdit()->setButtonIcon(FancyLineEdit::Right, Icons::RESET.icon());
+    m_fileChooser->lineEdit()->setButtonVisible(FancyLineEdit::Right, true);
+    connect(m_fileChooser->lineEdit(), &FancyLineEdit::rightButtonClicked, this, [&] {
+        m_fileChooser->setFilePath(m_defaultPath);
+    });
+
+    auto layout = new QGridLayout(m_widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    m_infoLabel = new InfoLabel();
+
+    if (!m_downloadUrl.isEmpty()) {
+        auto downLoadButton = new QToolButton;
+        downLoadButton->setIcon(Icons::ONLINE.icon());
+        downLoadButton->setToolTip(tr("Download from \"%1\"").arg(m_downloadUrl));
+        QObject::connect(downLoadButton, &QToolButton::pressed, this, [this] {
+            QDesktopServices::openUrl(m_downloadUrl);
+        });
+        layout->addWidget(downLoadButton, 0, 2);
+    }
+
+    layout->addWidget(m_fileChooser, 0, 0, 1, 2);
+    layout->addWidget(m_infoLabel, 1, 0, 1, -1);
+
+    m_fileChooser->setFilePath(m_path);
+
+    QObject::connect(this, &McuPackage::statusChanged, this, [this] { updateStatusUi(); });
+
+    QObject::connect(m_fileChooser, &PathChooser::pathChanged, this, [this] {
+        updatePath();
+        emit changed();
+    });
+
+    updateStatus();
+    return m_widget;
+}
+
+
 McuToolChainPackage::McuToolChainPackage(const QString &label,
                                          const FilePath &defaultPath,
-                                         const QString &detectionPath,
+                                         const FilePath &detectionPath,
                                          const QString &settingsKey,
-                                         McuToolChainPackage::Type type,
+                                         McuToolChainPackage::ToolChainType type,
                                          const QString &envVarName,
                                          const McuPackageVersionDetector *versionDetector)
     : McuPackage(label, defaultPath, detectionPath, settingsKey, envVarName, {}, versionDetector)
     , m_type(type)
 {}
 
-McuToolChainPackage::Type McuToolChainPackage::type() const
+McuToolChainPackage::ToolChainType McuToolChainPackage::toolchainType() const
 {
     return m_type;
 }
 
 bool McuToolChainPackage::isDesktopToolchain() const
 {
-    return m_type == Type::MSVC || m_type == Type::GCC;
+    return m_type == ToolChainType::MSVC || m_type == ToolChainType::GCC;
+}
+
+static ToolChain *msvcToolChain(Id language)
+{
+    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+        const Abi abi = t->targetAbi();
+        // TODO: Should Abi::WindowsMsvc2022Flavor be added too?
+        return (abi.osFlavor() == Abi::WindowsMsvc2017Flavor
+                || abi.osFlavor() == Abi::WindowsMsvc2019Flavor)
+               && abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
+               && t->language() == language;
+    });
+    return toolChain;
+}
+
+static ToolChain *gccToolChain(Id language)
+{
+    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+        const Abi abi = t->targetAbi();
+        return abi.os() != Abi::WindowsOS && abi.architecture() == Abi::X86Architecture
+               && abi.wordWidth() == 64 && t->language() == language;
+    });
+    return toolChain;
+}
+
+static ToolChain *armGccToolChain(const FilePath &path, Id language)
+{
+    ToolChain *toolChain = ToolChainManager::toolChain([&path, language](const ToolChain *t) {
+        return t->compilerCommand() == path && t->language() == language;
+    });
+    if (!toolChain) {
+        ToolChainFactory *gccFactory
+            = Utils::findOrDefault(ToolChainFactory::allToolChainFactories(),
+                                   [](ToolChainFactory *f) {
+                                       return f->supportedToolChainType()
+                                              == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID;
+                                   });
+        if (gccFactory) {
+            const QList<ToolChain *> detected = gccFactory->detectForImport({path, language});
+            if (!detected.isEmpty()) {
+                toolChain = detected.first();
+                toolChain->setDetection(ToolChain::ManualDetection);
+                toolChain->setDisplayName("Arm GCC");
+                ToolChainManager::registerToolChain(toolChain);
+            }
+        }
+    }
+
+    return toolChain;
+}
+
+static ToolChain *iarToolChain(const FilePath &path, Id language)
+{
+    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
+        return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
+               && t->language() == language;
+    });
+    if (!toolChain) {
+        ToolChainFactory *iarFactory
+            = Utils::findOrDefault(ToolChainFactory::allToolChainFactories(),
+                                   [](ToolChainFactory *f) {
+                                       return f->supportedToolChainType()
+                                              == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
+                                   });
+        if (iarFactory) {
+            Toolchains detected = iarFactory->autoDetect(ToolchainDetector({}, {}));
+            if (detected.isEmpty())
+                detected = iarFactory->detectForImport({path, language});
+            for (auto tc : detected) {
+                if (tc->language() == language) {
+                    toolChain = tc;
+                    toolChain->setDetection(ToolChain::ManualDetection);
+                    toolChain->setDisplayName("IAREW");
+                    ToolChainManager::registerToolChain(toolChain);
+                }
+            }
+        }
+    }
+
+    return toolChain;
+}
+
+ToolChain *McuToolChainPackage::toolChain(Id language) const
+{
+    switch (m_type) {
+    case ToolChainType::MSVC:
+        return msvcToolChain(language);
+    case ToolChainType::GCC:
+        return gccToolChain(language);
+    case ToolChainType::IAR: {
+        const FilePath compiler = path().pathAppended("/bin/iccarm").withExecutableSuffix();
+        return iarToolChain(compiler, language);
+    }
+    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"
+                                                                  : "/bar/foo-keil-%1")
+                                 .arg(compilerName);
+        const FilePath compiler = path().pathAppended(comp).withExecutableSuffix();
+
+        return armGccToolChain(compiler, language);
+    }
+    default:
+        Q_UNREACHABLE();
+    }
+}
+
+QString McuToolChainPackage::toolChainName() const
+{
+    switch (m_type) {
+    case ToolChainType::ArmGcc:
+        return QLatin1String("armgcc");
+    case ToolChainType::IAR:
+        return QLatin1String("iar");
+    case ToolChainType::KEIL:
+        return QLatin1String("keil");
+    case ToolChainType::GHS:
+        return QLatin1String("ghs");
+    case ToolChainType::GHSArm:
+        return QLatin1String("ghs-arm");
+    default:
+        return QLatin1String("unsupported");
+    }
+}
+
+QString McuToolChainPackage::cmakeToolChainFileName() const
+{
+    return toolChainName() + QLatin1String(".cmake");
+}
+
+QVariant McuToolChainPackage::debuggerId() const
+{
+    using namespace Debugger;
+
+    QString sub, displayName;
+    DebuggerEngineType engineType;
+
+    switch (m_type) {
+    case ToolChainType::ArmGcc: {
+        sub = QString::fromLatin1("bin/arm-none-eabi-gdb-py");
+        displayName = McuPackage::tr("Arm GDB at %1");
+        engineType = Debugger::GdbEngineType;
+        break;
+    }
+    case ToolChainType::IAR: {
+        sub = QString::fromLatin1("../common/bin/CSpyBat");
+        displayName = QLatin1String("CSpy");
+        engineType = Debugger::NoEngineType; // support for IAR missing
+        break;
+    }
+    case ToolChainType::KEIL: {
+        sub = QString::fromLatin1("UV4/UV4");
+        displayName = QLatin1String("KEIL uVision Debugger");
+        engineType = Debugger::UvscEngineType;
+        break;
+    }
+    default:
+        return QVariant();
+    }
+
+    const FilePath command = path().pathAppended(sub).withExecutableSuffix();
+    if (const DebuggerItem *debugger = DebuggerItemManager::findByCommand(command)) {
+        return debugger->id();
+    }
+
+    DebuggerItem newDebugger;
+    newDebugger.setCommand(command);
+    newDebugger.setUnexpandedDisplayName(displayName.arg(command.toUserOutput()));
+    newDebugger.setEngineType(engineType);
+    return DebuggerItemManager::registerDebugger(newDebugger);
 }
 
 
diff --git a/src/plugins/mcusupport/mcupackage.h b/src/plugins/mcusupport/mcupackage.h
index dcc9917c1c..5a57fad965 100644
--- a/src/plugins/mcusupport/mcupackage.h
+++ b/src/plugins/mcusupport/mcupackage.h
@@ -55,33 +55,35 @@ class McuPackage : public McuAbstractPackage
 public:
     McuPackage(const QString &label,
                const Utils::FilePath &defaultPath,
-               const QString &detectionPath,
+               const Utils::FilePath &detectionPath,
                const QString &settingsKey,
                const QString &envVarName = {},
                const QString &downloadUrl = {},
-               const McuPackageVersionDetector *versionDetector = nullptr);
+               const McuPackageVersionDetector *versionDetector = nullptr,
+               const bool addToPath = false,
+               const Utils::FilePath &relativePathModifier = Utils::FilePath());
+
     ~McuPackage() override = default;
 
+    QString label() const override;
+    const QString &environmentVariableName() const override;
+    bool isAddToSystemPath() const override;
+    void setVersions(const QStringList &versions) override;
+
     Utils::FilePath basePath() const override;
     Utils::FilePath path() const override;
-    QString label() const override;
     Utils::FilePath defaultPath() const override;
-    QString detectionPath() const override;
-    QString statusText() const override;
-    void updateStatus() override;
+    Utils::FilePath detectionPath() const override;
 
+    void updateStatus() override;
     Status status() const override;
-    bool validStatus() const override;
-    void setAddToPath(bool addToPath) override;
-    bool addToPath() const override;
+    bool isValidStatus() const override;
+    QString statusText() const override;
+
     bool writeToSettings() const override;
-    void setRelativePathModifier(const QString &path) override;
-    void setVersions(const QStringList &versions) override;
 
     QWidget *widget() override;
 
-    const QString &environmentVariableName() const override;
-
 private:
     void updatePath();
     void updateStatusUi();
@@ -92,17 +94,17 @@ private:
 
     const QString m_label;
     const Utils::FilePath m_defaultPath;
-    const QString m_detectionPath;
+    const Utils::FilePath m_detectionPath;
     const QString m_settingsKey;
     const McuPackageVersionDetector *m_versionDetector;
 
     Utils::FilePath m_path;
-    QString m_relativePathModifier; // relative path to m_path to be returned by path()
+    Utils::FilePath m_relativePathModifier; // relative path to m_path to be returned by path()
     QString m_detectedVersion;
     QStringList m_versions;
     const QString m_environmentVariableName;
     const QString m_downloadUrl;
-    bool m_addToPath = false;
+    const bool m_addToSystemPath;
 
     Status m_status = Status::InvalidPath;
 };
@@ -110,17 +112,17 @@ private:
 class McuToolChainPackage : public McuPackage
 {
 public:
-    enum class Type { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, Unsupported };
+    enum class ToolChainType { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, Unsupported };
 
     McuToolChainPackage(const QString &label,
                         const Utils::FilePath &defaultPath,
-                        const QString &detectionPath,
+                        const Utils::FilePath &detectionPath,
                         const QString &settingsKey,
-                        Type type,
+                        ToolChainType toolchainType,
                         const QString &envVarName = {},
                         const McuPackageVersionDetector *versionDetector = nullptr);
 
-    Type type() const;
+    ToolChainType toolchainType() const;
     bool isDesktopToolchain() const;
     ProjectExplorer::ToolChain *toolChain(Utils::Id language) const;
     QString toolChainName() const;
@@ -128,7 +130,7 @@ public:
     QVariant debuggerId() const;
 
 private:
-    const Type m_type;
+    const ToolChainType m_type;
 };
 
 } // namespace Internal
diff --git a/src/plugins/mcusupport/mcusupportoptions.cpp b/src/plugins/mcusupport/mcusupportoptions.cpp
index a5915c7aff..cc61de078a 100644
--- a/src/plugins/mcusupport/mcusupportoptions.cpp
+++ b/src/plugins/mcusupport/mcusupportoptions.cpp
@@ -134,7 +134,7 @@ void McuSupportOptions::setQulDir(const FilePath &dir)
 {
     deletePackagesAndTargets();
     qtForMCUsSdkPackage->updateStatus();
-    if (qtForMCUsSdkPackage->validStatus())
+    if (qtForMCUsSdkPackage->isValidStatus())
         Sdk::targetsAndPackages(dir, &sdkRepository);
     for (const auto &package : qAsConst(sdkRepository.packages))
         connect(package, &McuAbstractPackage::changed, this, &McuSupportOptions::packagesChanged);
@@ -165,19 +165,19 @@ void McuSupportOptions::remapQul2xCmakeVars(Kit *kit, const EnvironmentItems &en
 
 static void setKitToolchains(Kit *k, const McuToolChainPackage *tcPackage)
 {
-    switch (tcPackage->type()) {
-    case McuToolChainPackage::Type::Unsupported:
+    switch (tcPackage->toolchainType()) {
+    case McuToolChainPackage::ToolChainType::Unsupported:
         return;
 
-    case McuToolChainPackage::Type::GHS:
-    case McuToolChainPackage::Type::GHSArm:
+    case McuToolChainPackage::ToolChainType::GHS:
+    case McuToolChainPackage::ToolChainType::GHSArm:
         return; // No Green Hills toolchain, because support for it is missing.
 
-    case McuToolChainPackage::Type::IAR:
-    case McuToolChainPackage::Type::KEIL:
-    case McuToolChainPackage::Type::MSVC:
-    case McuToolChainPackage::Type::GCC:
-    case McuToolChainPackage::Type::ArmGcc:
+    case McuToolChainPackage::ToolChainType::IAR:
+    case McuToolChainPackage::ToolChainType::KEIL:
+    case McuToolChainPackage::ToolChainType::MSVC:
+    case McuToolChainPackage::ToolChainType::GCC:
+    case McuToolChainPackage::ToolChainType::ArmGcc:
         ToolChainKitAspect::setToolChain(k,
                                          tcPackage->toolChain(
                                              ProjectExplorer::Constants::C_LANGUAGE_ID));
@@ -198,17 +198,17 @@ static void setKitDebugger(Kit *k, const McuToolChainPackage *tcPackage)
         return;
     }
 
-    switch (tcPackage->type()) {
-    case McuToolChainPackage::Type::Unsupported:
-    case McuToolChainPackage::Type::GHS:
-    case McuToolChainPackage::Type::GHSArm:
-    case McuToolChainPackage::Type::IAR:
+    switch (tcPackage->toolchainType()) {
+    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::Type::KEIL:
-    case McuToolChainPackage::Type::MSVC:
-    case McuToolChainPackage::Type::GCC:
-    case McuToolChainPackage::Type::ArmGcc: {
+    case McuToolChainPackage::ToolChainType::KEIL:
+    case McuToolChainPackage::ToolChainType::MSVC:
+    case McuToolChainPackage::ToolChainType::GCC:
+    case McuToolChainPackage::ToolChainType::ArmGcc: {
         const QVariant debuggerId = tcPackage->debuggerId();
         if (debuggerId.isValid()) {
             Debugger::DebuggerKitAspect::setDebugger(k, debuggerId);
@@ -250,7 +250,7 @@ void McuSupportOptions::setKitEnvironment(Kit *k,
         pathAdditions.append(qtForMCUsSdkPackage->path().pathAppended("bin").toUserOutput());
 
     auto processPackage = [&pathAdditions, &changes](const McuAbstractPackage *package) {
-        if (package->addToPath())
+        if (package->isAddToSystemPath())
             pathAdditions.append(package->path().toUserOutput());
         if (!package->environmentVariableName().isEmpty())
             changes.append({package->environmentVariableName(), package->path().toUserOutput()});
@@ -279,7 +279,7 @@ static void setKitDependencies(Kit *k,
     auto processPackage = [&dependencies](const McuAbstractPackage *package) {
         if (!package->environmentVariableName().isEmpty())
             dependencies.append({package->environmentVariableName(),
-                                 QDir::toNativeSeparators(package->detectionPath())});
+                                 package->detectionPath().toUserOutput()});
     };
     for (auto package : mcuTarget->packages())
         processPackage(package);
@@ -297,7 +297,7 @@ void McuSupportOptions::updateKitEnvironment(Kit *k, const McuTarget *mcuTarget)
     EnvironmentItems changes = EnvironmentKitAspect::environmentChanges(k);
     for (auto package : mcuTarget->packages()) {
         const QString varName = package->environmentVariableName();
-        if (!varName.isEmpty() && package->validStatus()) {
+        if (!varName.isEmpty() && package->isValidStatus()) {
             const int index = Utils::indexOf(changes, [varName](const EnvironmentItem &item) {
                 return item.name == varName;
             });
@@ -324,8 +324,8 @@ static void setKitCMakeOptions(Kit *k, const McuTarget *mcuTarget, const FilePat
 
     CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
     // CMake ToolChain file for ghs handles CMAKE_*_COMPILER autonomously
-    if (mcuTarget->toolChainPackage()->type() != McuToolChainPackage::Type::GHS
-        && mcuTarget->toolChainPackage()->type() != McuToolChainPackage::Type::GHSArm) {
+    if (mcuTarget->toolChainPackage()->toolchainType() != McuToolChainPackage::ToolChainType::GHS
+        && mcuTarget->toolChainPackage()->toolchainType() != McuToolChainPackage::ToolChainType::GHSArm) {
         config.append(CMakeConfigItem("CMAKE_CXX_COMPILER", "%{Compiler:Executable:Cxx}"));
         config.append(CMakeConfigItem("CMAKE_C_COMPILER", "%{Compiler:Executable:C}"));
     }
@@ -363,8 +363,8 @@ static void setKitCMakeOptions(Kit *k, const McuTarget *mcuTarget, const FilePat
     CMakeConfigurationKitAspect::setConfiguration(k, config);
 
     if (HostOsInfo::isWindowsHost()) {
-        auto type = mcuTarget->toolChainPackage()->type();
-        if (type == McuToolChainPackage::Type::GHS || type == McuToolChainPackage::Type::GHSArm) {
+        auto type = mcuTarget->toolChainPackage()->toolchainType();
+        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");
@@ -418,7 +418,7 @@ void McuSupportOptions::deletePackagesAndTargets()
 
 void McuSupportOptions::checkUpgradeableKits()
 {
-    if (!qtForMCUsSdkPackage->validStatus() || sdkRepository.mcuTargets.length() == 0)
+    if (!qtForMCUsSdkPackage->isValidStatus() || sdkRepository.mcuTargets.length() == 0)
         return;
 
     if (Utils::anyOf(sdkRepository.mcuTargets, [this](const McuTarget *target) {
diff --git a/src/plugins/mcusupport/mcusupportoptionspage.cpp b/src/plugins/mcusupport/mcusupportoptionspage.cpp
index 36a8d318a0..2b96f02ce7 100644
--- a/src/plugins/mcusupport/mcusupportoptionspage.cpp
+++ b/src/plugins/mcusupport/mcusupportoptionspage.cpp
@@ -196,7 +196,7 @@ void McuSupportOptionsWidget::updateStatus()
     // Page elements
     {
         m_qtForMCUsSdkGroupBox->setVisible(cMakeAvailable);
-        const bool valid = cMakeAvailable && m_options.qtForMCUsSdkPackage->validStatus();
+        const bool valid = cMakeAvailable && m_options.qtForMCUsSdkPackage->isValidStatus();
         const bool ready = valid && mcuTarget;
         m_mcuTargetsGroupBox->setVisible(ready);
         m_packagesGroupBox->setVisible(ready && !mcuTarget->packages().isEmpty());
diff --git a/src/plugins/mcusupport/mcusupportsdk.cpp b/src/plugins/mcusupport/mcusupportsdk.cpp
index 5550a6848c..b32af50e5c 100644
--- a/src/plugins/mcusupport/mcusupportsdk.cpp
+++ b/src/plugins/mcusupport/mcusupportsdk.cpp
@@ -71,24 +71,24 @@ McuPackage *createQtForMCUsPackage()
 {
     return new McuPackage(McuPackage::tr("Qt for MCUs SDK"),
                           FileUtils::homePath(),                                      // defaultPath
-                          FilePath("bin/qmltocpp").withExecutableSuffix().toString(), // detectionPath
+                          FilePath("bin/qmltocpp").withExecutableSuffix(),            // detectionPath
                           Constants::SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK,            // settingsKey
                           QStringLiteral("Qul_DIR"));                                 // envVarName
 }
 
 static McuToolChainPackage *createMsvcToolChainPackage()
 {
-    return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::Type::MSVC);
+    return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::MSVC);
 }
 
 static McuToolChainPackage *createGccToolChainPackage()
 {
-    return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::Type::GCC);
+    return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::GCC);
 }
 
 static McuToolChainPackage *createUnsupportedToolChainPackage()
 {
-    return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::Type::Unsupported);
+    return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported);
 }
 
 static McuToolChainPackage *createArmGccPackage()
@@ -109,7 +109,7 @@ static McuToolChainPackage *createArmGccPackage()
         }
     }
 
-    const QString detectionPath = Utils::HostOsInfo::withExecutableSuffix("bin/arm-none-eabi-g++");
+    const Utils::FilePath detectionPath = FilePath("bin/arm-none-eabi-g++").withExecutableSuffix();
     const auto versionDetector
         = new McuPackageExecutableVersionDetector(detectionPath,
                                                   {"--version"},
@@ -119,7 +119,7 @@ static McuToolChainPackage *createArmGccPackage()
                                    defaultPath,
                                    detectionPath,
                                    "GNUArmEmbeddedToolchain", // settingsKey
-                                   McuToolChainPackage::Type::ArmGcc,
+                                   McuToolChainPackage::ToolChainType::ArmGcc,
                                    envVar,
                                    versionDetector);
 }
@@ -131,16 +131,15 @@ static McuToolChainPackage *createGhsToolchainPackage()
     const FilePath defaultPath = FilePath::fromUserInput(qEnvironmentVariable(envVar));
 
     const auto versionDetector
-        = new McuPackageExecutableVersionDetector(Utils::HostOsInfo::withExecutableSuffix("as850"),
+        = new McuPackageExecutableVersionDetector(FilePath("as850").withExecutableSuffix(),
                                                   {"-V"},
                                                   "\\bv(\\d+\\.\\d+\\.\\d+)\\b");
 
     return new McuToolChainPackage("Green Hills Compiler",
                                    defaultPath,
-                                   Utils::HostOsInfo::withExecutableSuffix(
-                                       "ccv850"),  // detectionPath
+                                   FilePath("ccv850").withExecutableSuffix(),  // detectionPath
                                    "GHSToolchain", // settingsKey
-                                   McuToolChainPackage::Type::GHS,
+                                   McuToolChainPackage::ToolChainType::GHS,
                                    envVar,
                                    versionDetector);
 }
@@ -152,15 +151,15 @@ static McuToolChainPackage *createGhsArmToolchainPackage()
     const FilePath defaultPath = FilePath::fromUserInput(qEnvironmentVariable(envVar));
 
     const auto versionDetector
-        = new McuPackageExecutableVersionDetector(Utils::HostOsInfo::withExecutableSuffix("asarm"),
+        = new McuPackageExecutableVersionDetector(FilePath("asarm").withExecutableSuffix(),
                                                   {"-V"},
                                                   "\\bv(\\d+\\.\\d+\\.\\d+)\\b");
 
     return new McuToolChainPackage("Green Hills Compiler for ARM",
                                    defaultPath,
-                                   Utils::HostOsInfo::withExecutableSuffix("cxarm"), // detectionPath
+                                   FilePath("cxarm").withExecutableSuffix(), // detectionPath
                                    "GHSArmToolchain",                                // settingsKey
-                                   McuToolChainPackage::Type::GHSArm,
+                                   McuToolChainPackage::ToolChainType::GHSArm,
                                    envVar,
                                    versionDetector);
 }
@@ -183,7 +182,7 @@ static McuToolChainPackage *createIarToolChainPackage()
         }
     }
 
-    const QString detectionPath = Utils::HostOsInfo::withExecutableSuffix("bin/iccarm");
+    const FilePath detectionPath = FilePath("bin/iccarm").withExecutableSuffix();
     const auto versionDetector
         = new McuPackageExecutableVersionDetector(detectionPath,
                                                   {"--version"},
@@ -193,7 +192,7 @@ static McuToolChainPackage *createIarToolChainPackage()
                                    defaultPath,
                                    detectionPath,
                                    "IARToolchain", // settings key
-                                   McuToolChainPackage::Type::IAR,
+                                   McuToolChainPackage::ToolChainType::IAR,
                                    envVar,
                                    versionDetector);
 }
@@ -237,17 +236,24 @@ static McuPackage *createStm32CubeProgrammerPackage()
         if (programPath.exists())
             defaultPath = programPath;
     }
+
+    const FilePath detectionPath =  FilePath::fromString(
+                QLatin1String(Utils::HostOsInfo::isWindowsHost()
+                   ? "/bin/STM32_Programmer_CLI.exe"
+                   : "/bin/STM32_Programmer.sh")
+                );
+
     auto result
         = new McuPackage(McuPackage::tr("STM32CubeProgrammer"),
                          defaultPath,
-                         QLatin1String(Utils::HostOsInfo::isWindowsHost()
-                                           ? "/bin/STM32_Programmer_CLI.exe"
-                                           : "/bin/STM32_Programmer.sh"), // detection path
+                         detectionPath,
                          "Stm32CubeProgrammer",
                          {},                                                            // env var
-                         "https://www.st.com/en/development-tools/stm32cubeprog.html"); // download url
-    result->setRelativePathModifier("/bin");
-    result->setAddToPath(true);
+                         "https://www.st.com/en/development-tools/stm32cubeprog.html", // download url
+                         nullptr, // version detector
+                         true, // add to path
+                         "/bin" // relative path modifier
+                         );
     return result;
 }
 
@@ -276,8 +282,7 @@ static McuPackage *createMcuXpressoIdePackage()
 
     return new McuPackage("MCUXpresso IDE",
                           defaultPath,
-                          Utils::HostOsInfo::withExecutableSuffix(
-                              "ide/binaries/crt_emu_cm_redlink"), // detection path
+                          FilePath("ide/binaries/crt_emu_cm_redlink").withExecutableSuffix(), // detection path
                           "MCUXpressoIDE",                        // settings key
                           envVar,
                           "https://www.nxp.com/mcuxpresso/ide"); // download url
@@ -303,7 +308,7 @@ static McuPackage *createCypressProgrammerPackage()
 
     auto result = new McuPackage("Cypress Auto Flash Utility",
                                  defaultPath,
-                                 Utils::HostOsInfo::withExecutableSuffix("/bin/openocd"),
+                                 FilePath("/bin/openocd").withExecutableSuffix(),
                                  "CypressAutoFlashUtil",
                                  envVar);
     return result;
@@ -329,7 +334,7 @@ static McuPackage *createRenesasProgrammerPackage()
 
     auto result = new McuPackage("Renesas Flash Programmer",
                                  defaultPath,
-                                 Utils::HostOsInfo::withExecutableSuffix("rfp-cli"),
+                                 FilePath("rfp-cli").withExecutableSuffix(),
                                  "RenesasFlashProgrammer",
                                  envVar);
     return result;
@@ -538,7 +543,7 @@ protected:
             QVector<McuAbstractPackage *> required3rdPartyPkgs;
             // Desktop toolchains don't need any additional settings
             if (tcPkg && !tcPkg->isDesktopToolchain()
-                && tcPkg->type() != McuToolChainPackage::Type::Unsupported)
+                && tcPkg->toolchainType() != McuToolChainPackage::ToolChainType::Unsupported)
                 required3rdPartyPkgs.append(tcPkg);
 
             // Add setting specific to platform IDE
diff --git a/src/plugins/mcusupport/mcusupportversiondetection.cpp b/src/plugins/mcusupport/mcusupportversiondetection.cpp
index b3f1a3cd00..5380446a13 100644
--- a/src/plugins/mcusupport/mcusupportversiondetection.cpp
+++ b/src/plugins/mcusupport/mcusupportversiondetection.cpp
@@ -46,7 +46,7 @@ QString matchRegExp(const QString &text, const QString &regExp)
 McuPackageVersionDetector::McuPackageVersionDetector() {}
 
 McuPackageExecutableVersionDetector::McuPackageExecutableVersionDetector(
-    const QString &detectionPath, const QStringList &detectionArgs, const QString &detectionRegExp)
+    const Utils::FilePath &detectionPath, const QStringList &detectionArgs, const QString &detectionRegExp)
     : McuPackageVersionDetector()
     , m_detectionPath(detectionPath)
     , m_detectionArgs(detectionArgs)
@@ -58,7 +58,7 @@ QString McuPackageExecutableVersionDetector::parseVersion(const QString &package
     if (m_detectionPath.isEmpty() || m_detectionRegExp.isEmpty())
         return QString();
 
-    const Utils::FilePath binaryPath = Utils::FilePath::fromString(packagePath) / m_detectionPath;
+    const Utils::FilePath binaryPath = Utils::FilePath::fromString(packagePath).resolvePath(m_detectionPath);
     if (!binaryPath.exists())
         return QString();
 
diff --git a/src/plugins/mcusupport/mcusupportversiondetection.h b/src/plugins/mcusupport/mcusupportversiondetection.h
index a559959156..c5f25875d0 100644
--- a/src/plugins/mcusupport/mcusupportversiondetection.h
+++ b/src/plugins/mcusupport/mcusupportversiondetection.h
@@ -26,6 +26,7 @@
 #pragma once
 
 #include <QObject>
+#include <utils/filepath.h>
 
 namespace McuSupport {
 namespace Internal {
@@ -43,13 +44,13 @@ public:
 class McuPackageExecutableVersionDetector : public McuPackageVersionDetector
 {
 public:
-    McuPackageExecutableVersionDetector(const QString &detectionPath,
+    McuPackageExecutableVersionDetector(const Utils::FilePath &detectionPath,
                                         const QStringList &detectionArgs,
                                         const QString &detectionRegExp);
     QString parseVersion(const QString &packagePath) const final;
 
 private:
-    const QString m_detectionPath;
+    const Utils::FilePath m_detectionPath;
     const QStringList m_detectionArgs;
     const QString m_detectionRegExp;
 };
diff --git a/src/plugins/mcusupport/mcutarget.cpp b/src/plugins/mcusupport/mcutarget.cpp
index 291b861e22..28628eeca5 100644
--- a/src/plugins/mcusupport/mcutarget.cpp
+++ b/src/plugins/mcusupport/mcutarget.cpp
@@ -26,196 +26,14 @@
 #include "mcutarget.h"
 #include "mcupackage.h"
 #include "mcukitmanager.h"
-
 #include "mcusupportplugin.h"
 
-#include <baremetal/baremetalconstants.h>
-#include <debugger/debuggeritem.h>
-#include <debugger/debuggeritemmanager.h>
-#include <projectexplorer/projectexplorerconstants.h>
-#include <projectexplorer/toolchain.h>
-#include <projectexplorer/toolchainmanager.h>
+#include <utils/algorithm.h>
 
-using namespace ProjectExplorer;
 using namespace Utils;
 
 namespace McuSupport::Internal {
 
-static ToolChain *msvcToolChain(Id language)
-{
-    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
-        const Abi abi = t->targetAbi();
-        // TODO: Should Abi::WindowsMsvc2022Flavor be added too?
-        return (abi.osFlavor() == Abi::WindowsMsvc2017Flavor
-                || abi.osFlavor() == Abi::WindowsMsvc2019Flavor)
-               && abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
-               && t->language() == language;
-    });
-    return toolChain;
-}
-
-static ToolChain *gccToolChain(Id language)
-{
-    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
-        const Abi abi = t->targetAbi();
-        return abi.os() != Abi::WindowsOS && abi.architecture() == Abi::X86Architecture
-               && abi.wordWidth() == 64 && t->language() == language;
-    });
-    return toolChain;
-}
-
-static ToolChain *armGccToolChain(const FilePath &path, Id language)
-{
-    ToolChain *toolChain = ToolChainManager::toolChain([&path, language](const ToolChain *t) {
-        return t->compilerCommand() == path && t->language() == language;
-    });
-    if (!toolChain) {
-        ToolChainFactory *gccFactory
-            = Utils::findOrDefault(ToolChainFactory::allToolChainFactories(),
-                                   [](ToolChainFactory *f) {
-                                       return f->supportedToolChainType()
-                                              == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID;
-                                   });
-        if (gccFactory) {
-            const QList<ToolChain *> detected = gccFactory->detectForImport({path, language});
-            if (!detected.isEmpty()) {
-                toolChain = detected.first();
-                toolChain->setDetection(ToolChain::ManualDetection);
-                toolChain->setDisplayName("Arm GCC");
-                ToolChainManager::registerToolChain(toolChain);
-            }
-        }
-    }
-
-    return toolChain;
-}
-
-static ToolChain *iarToolChain(const FilePath &path, Id language)
-{
-    ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
-        return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
-               && t->language() == language;
-    });
-    if (!toolChain) {
-        ToolChainFactory *iarFactory
-            = Utils::findOrDefault(ToolChainFactory::allToolChainFactories(),
-                                   [](ToolChainFactory *f) {
-                                       return f->supportedToolChainType()
-                                              == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
-                                   });
-        if (iarFactory) {
-            Toolchains detected = iarFactory->autoDetect(ToolchainDetector({}, {}));
-            if (detected.isEmpty())
-                detected = iarFactory->detectForImport({path, language});
-            for (auto tc : detected) {
-                if (tc->language() == language) {
-                    toolChain = tc;
-                    toolChain->setDetection(ToolChain::ManualDetection);
-                    toolChain->setDisplayName("IAREW");
-                    ToolChainManager::registerToolChain(toolChain);
-                }
-            }
-        }
-    }
-
-    return toolChain;
-}
-
-ToolChain *McuToolChainPackage::toolChain(Id language) const
-{
-    switch (m_type) {
-    case Type::MSVC:
-        return msvcToolChain(language);
-    case Type::GCC:
-        return gccToolChain(language);
-    case Type::IAR: {
-        const FilePath compiler = path().pathAppended("/bin/iccarm").withExecutableSuffix();
-        return iarToolChain(compiler, language);
-    }
-    case Type::ArmGcc:
-    case Type::KEIL:
-    case Type::GHS:
-    case Type::GHSArm:
-    case Type::Unsupported: {
-        const QLatin1String compilerName(
-            language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++");
-        const QString comp = QLatin1String(m_type == Type::ArmGcc ? "/bin/arm-none-eabi-%1"
-                                                                  : "/bar/foo-keil-%1")
-                                 .arg(compilerName);
-        const FilePath compiler = path().pathAppended(comp).withExecutableSuffix();
-
-        return armGccToolChain(compiler, language);
-    }
-    default:
-        Q_UNREACHABLE();
-    }
-}
-
-QString McuToolChainPackage::toolChainName() const
-{
-    switch (m_type) {
-    case Type::ArmGcc:
-        return QLatin1String("armgcc");
-    case Type::IAR:
-        return QLatin1String("iar");
-    case Type::KEIL:
-        return QLatin1String("keil");
-    case Type::GHS:
-        return QLatin1String("ghs");
-    case Type::GHSArm:
-        return QLatin1String("ghs-arm");
-    default:
-        return QLatin1String("unsupported");
-    }
-}
-
-QString McuToolChainPackage::cmakeToolChainFileName() const
-{
-    return toolChainName() + QLatin1String(".cmake");
-}
-
-QVariant McuToolChainPackage::debuggerId() const
-{
-    using namespace Debugger;
-
-    QString sub, displayName;
-    DebuggerEngineType engineType;
-
-    switch (m_type) {
-    case Type::ArmGcc: {
-        sub = QString::fromLatin1("bin/arm-none-eabi-gdb-py");
-        displayName = McuPackage::tr("Arm GDB at %1");
-        engineType = Debugger::GdbEngineType;
-        break;
-    }
-    case Type::IAR: {
-        sub = QString::fromLatin1("../common/bin/CSpyBat");
-        displayName = QLatin1String("CSpy");
-        engineType = Debugger::NoEngineType; // support for IAR missing
-        break;
-    }
-    case Type::KEIL: {
-        sub = QString::fromLatin1("UV4/UV4");
-        displayName = QLatin1String("KEIL uVision Debugger");
-        engineType = Debugger::UvscEngineType;
-        break;
-    }
-    default:
-        return QVariant();
-    }
-
-    const FilePath command = path().pathAppended(sub).withExecutableSuffix();
-    if (const DebuggerItem *debugger = DebuggerItemManager::findByCommand(command)) {
-        return debugger->id();
-    }
-
-    DebuggerItem newDebugger;
-    newDebugger.setCommand(command);
-    newDebugger.setUnexpandedDisplayName(displayName.arg(command.toUserOutput()));
-    newDebugger.setEngineType(engineType);
-    return DebuggerItemManager::registerDebugger(newDebugger);
-}
-
 McuTarget::McuTarget(const QVersionNumber &qulVersion,
                      const Platform &platform,
                      OS os,
@@ -254,7 +72,7 @@ bool McuTarget::isValid() const
 {
     return Utils::allOf(packages(), [](McuAbstractPackage *package) {
         package->updateStatus();
-        return package->validStatus();
+        return package->isValidStatus();
     });
 }
 
@@ -262,7 +80,7 @@ void McuTarget::printPackageProblems() const
 {
     for (auto package : packages()) {
         package->updateStatus();
-        if (!package->validStatus())
+        if (!package->isValidStatus())
             printMessage(tr("Error creating kit for target %1, package %2: %3")
                              .arg(McuKitManager::kitName(this),
                                   package->label(),
diff --git a/src/plugins/mcusupport/test/packagemock.h b/src/plugins/mcusupport/test/packagemock.h
index 7f8e98d40f..2e41ef6550 100644
--- a/src/plugins/mcusupport/test/packagemock.h
+++ b/src/plugins/mcusupport/test/packagemock.h
@@ -39,17 +39,15 @@ public:
     MOCK_METHOD(Utils::FilePath, path, (), (const));
     MOCK_METHOD(QString, label, (), (const));
     MOCK_METHOD(Utils::FilePath, defaultPath, (), (const));
-    MOCK_METHOD(QString, detectionPath, (), (const));
+    MOCK_METHOD(Utils::FilePath, detectionPath, (), (const));
     MOCK_METHOD(QString, statusText, (), (const));
     MOCK_METHOD(void, updateStatus, ());
 
     MOCK_METHOD(Status, status, (), (const));
-    MOCK_METHOD(bool, validStatus, (), (const));
+    MOCK_METHOD(bool, isValidStatus, (), (const));
     MOCK_METHOD(const QString &, environmentVariableName, (), (const));
-    MOCK_METHOD(void, setAddToPath, (bool) );
-    MOCK_METHOD(bool, addToPath, (), (const));
+    MOCK_METHOD(bool, isAddToSystemPath, (), (const));
     MOCK_METHOD(bool, writeToSettings, (), (const));
-    MOCK_METHOD(void, setRelativePathModifier, (const QString &) );
     MOCK_METHOD(void, setVersions, (const QStringList &) );
 
     MOCK_METHOD(QWidget *, widget, ());
diff --git a/src/plugins/mcusupport/test/unittest.cpp b/src/plugins/mcusupport/test/unittest.cpp
index 30a6fa8a53..62b8fd9c27 100644
--- a/src/plugins/mcusupport/test/unittest.cpp
+++ b/src/plugins/mcusupport/test/unittest.cpp
@@ -47,7 +47,7 @@ using Utils::FilePath;
 void McuSupportTest::initTestCase()
 {
     EXPECT_CALL(freeRtosPackage, environmentVariableName()).WillRepeatedly(ReturnRef(freeRtosEnvVar));
-    EXPECT_CALL(freeRtosPackage, validStatus()).WillRepeatedly(Return(true));
+    EXPECT_CALL(freeRtosPackage, isValidStatus()).WillRepeatedly(Return(true));
     EXPECT_CALL(freeRtosPackage, path())
         .WillRepeatedly(Return(FilePath::fromString(defaultfreeRtosPath)));
 }