McuSupport: Rename internal types

"PackageOptions" -> "McuPackage"
"BoardOptions" -> "McuTarget"
"qul" -> "qtForMCUs"

Change-Id: I209cc82c7516fbf6a960b26c440159dbab02a4db
Reviewed-by: hjk <hjk@qt.io>

src/plugins/mcusupport/mcusupportconstants.h

@@ -32,8 +32,8 @@ const char DEVICE_TYPE[] = "McuSupport.DeviceType";
 const char DEVICE_ID[] = "McuSupport.Device";
 const char RUNCONFIGURATION[] = "McuSupport.RunConfiguration";
 const char SETTINGS_ID[] = "CC.McuSupport.Configuration";
-const char KIT_BOARD_VENDOR_KEY[] = "McuSupport.BoardVendor";
-const char KIT_BOARD_MODEL_KEY[] = "McuSupport.BoardModel";
+const char KIT_MCUTARGET_VENDOR_KEY[] = "McuSupport.McuTargetVendor";
+const char KIT_MCUTARGET_MODEL_KEY[] = "McuSupport.McuTargetModel";
 
 const char SETTINGS_GROUP[] = "McuSupport";
 const char SETTINGS_KEY_PACKAGE_PREFIX[] = "Package_";

src/plugins/mcusupport/mcusupportoptions.cpp

@@ -54,8 +54,8 @@
 namespace McuSupport {
 namespace Internal {
 
-PackageOptions::PackageOptions(const QString &label, const QString &defaultPath,
-                               const QString &detectionPath, const QString &settingsKey)
+McuPackage::McuPackage(const QString &label, const QString &defaultPath,
+                       const QString &detectionPath, const QString &settingsKey)
     : m_label(label)
     , m_defaultPath(defaultPath)
     , m_detectionPath(detectionPath)
@@ -68,22 +68,22 @@ PackageOptions::PackageOptions(const QString &label, const QString &defaultPath,
     s->endGroup();
 }
 
-QString PackageOptions::path() const
+QString McuPackage::path() const
 {
     return QFileInfo(m_fileChooser->path() + m_relativePathModifier).absoluteFilePath();
 }
 
-QString PackageOptions::label() const
+QString McuPackage::label() const
 {
     return m_label;
 }
 
-QString PackageOptions::detectionPath() const
+QString McuPackage::detectionPath() const
 {
     return m_detectionPath;
 }
 
-QWidget *PackageOptions::widget()
+QWidget *McuPackage::widget()
 {
     if (m_widget)
         return m_widget;
@@ -126,37 +126,37 @@ QWidget *PackageOptions::widget()
     return m_widget;
 }
 
-PackageOptions::Status PackageOptions::status() const
+McuPackage::Status McuPackage::status() const
 {
     return m_status;
 }
 
-void PackageOptions::setDownloadUrl(const QString &url)
+void McuPackage::setDownloadUrl(const QString &url)
 {
     m_downloadUrl = url;
 }
 
-void PackageOptions::setEnvironmentVariableName(const QString &name)
+void McuPackage::setEnvironmentVariableName(const QString &name)
 {
     m_environmentVariableName = name;
 }
 
-QString PackageOptions::environmentVariableName() const
+QString McuPackage::environmentVariableName() const
 {
     return m_environmentVariableName;
 }
 
-void PackageOptions::setAddToPath(bool addToPath)
+void McuPackage::setAddToPath(bool addToPath)
 {
     m_addToPath = addToPath;
 }
 
-bool PackageOptions::addToPath() const
+bool McuPackage::addToPath() const
 {
     return m_addToPath;
 }
 
-void PackageOptions::writeToSettings() const
+void McuPackage::writeToSettings() const
 {
     if (m_path.compare(m_defaultPath) == 0)
         return;
@@ -166,12 +166,12 @@ void PackageOptions::writeToSettings() const
     s->endGroup();
 }
 
-void PackageOptions::setRelativePathModifier(const QString &path)
+void McuPackage::setRelativePathModifier(const QString &path)
 {
     m_relativePathModifier = path;
 }
 
-void PackageOptions::updateStatus()
+void McuPackage::updateStatus()
 {
     m_path = m_fileChooser->rawPath();
     const bool validPath = m_fileChooser->isValid();
@@ -201,9 +201,9 @@ void PackageOptions::updateStatus()
     m_statusLabel->setText(statusText);
 }
 
-BoardOptions::BoardOptions(const QString &vendor, const QString &model,
-                           const QString &toolChainFileName, const QString &qulPlatform,
-                           const QVector<PackageOptions*> &packages)
+McuTarget::McuTarget(const QString &vendor, const QString &model,
+                     const QString &toolChainFileName, const QString &qulPlatform,
+                     const QVector<McuPackage*> &packages)
     : m_vendor(vendor)
     , m_model(model)
     , m_toolChainFile(toolChainFileName)
@@ -212,42 +212,42 @@ BoardOptions::BoardOptions(const QString &vendor, const QString &model,
 {
 }
 
-QString BoardOptions::model() const
+QString McuTarget::model() const
 {
     return m_model;
 }
 
-QString BoardOptions::toolChainFile() const
+QString McuTarget::toolChainFile() const
 {
     return m_toolChainFile;
 }
 
-QString BoardOptions::qulPlatform() const
+QString McuTarget::qulPlatform() const
 {
     return m_qulPlatform;
 }
 
-QVector<PackageOptions *> BoardOptions::packages() const
+QVector<McuPackage *> McuTarget::packages() const
 {
     return m_packages;
 }
 
-bool BoardOptions::isValid() const
+bool McuTarget::isValid() const
 {
-    return !Utils::anyOf(packages(), [](PackageOptions *package) {
-        return package->status() != PackageOptions::ValidPackage;
+    return !Utils::anyOf(packages(), [](McuPackage *package) {
+        return package->status() != McuPackage::ValidPackage;
     });
 }
 
-QString BoardOptions::vendor() const
+QString McuTarget::vendor() const
 {
     return m_vendor;
 }
 
-static PackageOptions *createQulPackage()
+static McuPackage *createQtForMCUsPackage()
 {
-    auto result = new PackageOptions(
-                PackageOptions::tr("Qt for MCUs SDK"),
+    auto result = new McuPackage(
+                McuPackage::tr("Qt for MCUs SDK"),
                 QDir::homePath(),
                 Utils::HostOsInfo::withExecutableSuffix("bin/qmltocpp"),
                 "QtMCUSdk");
@@ -255,7 +255,7 @@ static PackageOptions *createQulPackage()
     return result;
 }
 
-static PackageOptions *createArmGccPackage()
+static McuPackage *createArmGccPackage()
 {
     const char envVar[] = "ARMGCC_DIR";
 
@@ -277,8 +277,8 @@ static PackageOptions *createArmGccPackage()
     if (defaultPath.isEmpty())
         defaultPath = QDir::homePath();
 
-    auto result = new PackageOptions(
-                PackageOptions::tr("GNU Arm Embedded Toolchain"),
+    auto result = new McuPackage(
+                McuPackage::tr("GNU Arm Embedded Toolchain"),
                 defaultPath,
                 Utils::HostOsInfo::withExecutableSuffix("bin/arm-none-eabi-g++"),
                 "GNUArmEmbeddedToolchain");
@@ -288,10 +288,10 @@ static PackageOptions *createArmGccPackage()
     return result;
 }
 
-static PackageOptions *createStm32CubeFwF7SdkPackage()
+static McuPackage *createStm32CubeFwF7SdkPackage()
 {
-    auto result = new PackageOptions(
-                PackageOptions::tr("STM32Cube SDK"),
+    auto result = new McuPackage(
+                McuPackage::tr("STM32Cube SDK"),
                 "%{Env:STM32Cube_FW_F7_SDK_PATH}",
                 "Drivers/STM32F7xx_HAL_Driver",
                 "Stm32CubeFwF7Sdk");
@@ -301,15 +301,15 @@ static PackageOptions *createStm32CubeFwF7SdkPackage()
     return result;
 }
 
-static PackageOptions *createStm32CubeProgrammerPackage()
+static McuPackage *createStm32CubeProgrammerPackage()
 {
     const QString defaultPath =
             Utils::HostOsInfo::isWindowsHost() ?
                 QDir::fromNativeSeparators(qEnvironmentVariable("ProgramFiles"))
                 + "/STMicroelectronics/STM32Cube/STM32CubeProgrammer/"
               : QDir::homePath();
-    auto result = new PackageOptions(
-                PackageOptions::tr("STM32CubeProgrammer"),
+    auto result = new McuPackage(
+                McuPackage::tr("STM32CubeProgrammer"),
                 defaultPath,
                 QLatin1String(Utils::HostOsInfo::isWindowsHost() ? "/bin/STM32_Programmer_CLI.exe"
                                                                  : "/bin/STM32_Programmer.sh"),
@@ -321,10 +321,10 @@ static PackageOptions *createStm32CubeProgrammerPackage()
     return result;
 }
 
-static PackageOptions *createEvkbImxrt1050SdkPackage()
+static McuPackage *createEvkbImxrt1050SdkPackage()
 {
-    auto result = new PackageOptions(
-                PackageOptions::tr("NXP i.MXRT SDK"),
+    auto result = new McuPackage(
+                McuPackage::tr("NXP i.MXRT SDK"),
                 "%{Env:EVKB_IMXRT1050_SDK_PATH}", // TODO: Try to not use 1050 specifics
                 "EVKB-IMXRT1050_manifest_v3_5.xml",
                 "EvkbImxrt1050Sdk");
@@ -332,15 +332,15 @@ static PackageOptions *createEvkbImxrt1050SdkPackage()
     return result;
 }
 
-static PackageOptions *createSeggerJLinkPackage()
+static McuPackage *createSeggerJLinkPackage()
 {
     const QString defaultPath =
             Utils::HostOsInfo::isWindowsHost() ?
                 QDir::fromNativeSeparators(qEnvironmentVariable("ProgramFiles(x86)"))
                 + "/SEGGER/JLink"
               : QString("%{Env:SEGGER_JLINK_SOFTWARE_AND_DOCUMENTATION_PATH}");
-    auto result = new PackageOptions(
-                PackageOptions::tr("SEGGER JLink"),
+    auto result = new McuPackage(
+                McuPackage::tr("SEGGER JLink"),
                 defaultPath,
                 Utils::HostOsInfo::withExecutableSuffix("JLink"),
                 "SeggerJLink");
@@ -352,56 +352,66 @@ static PackageOptions *createSeggerJLinkPackage()
 McuSupportOptions::McuSupportOptions(QObject *parent)
     : QObject(parent)
 {
-    PackageOptions* qulPackage = createQulPackage();
-    PackageOptions* armGccPackage = createArmGccPackage();
-    PackageOptions* stm32CubeFwF7SdkPackage = createStm32CubeFwF7SdkPackage();
-    PackageOptions* stm32CubeProgrammerPackage = createStm32CubeProgrammerPackage();
-    PackageOptions* evkbImxrt1050SdkPackage = createEvkbImxrt1050SdkPackage();
-    PackageOptions* seggerJLinkPackage = createSeggerJLinkPackage();
-
-    toolchainPackage = armGccPackage;
-    qulSdkPackage = qulPackage;
+    qtForMCUsSdkPackage = createQtForMCUsPackage();
+    armGccPackage = createArmGccPackage();
+    McuPackage* stm32CubeFwF7SdkPackage = createStm32CubeFwF7SdkPackage();
+    McuPackage* stm32CubeProgrammerPackage = createStm32CubeProgrammerPackage();
+    McuPackage* evkbImxrt1050SdkPackage = createEvkbImxrt1050SdkPackage();
+    McuPackage* seggerJLinkPackage = createSeggerJLinkPackage();
 
     auto stmEvalPackages = {
-        armGccPackage, stm32CubeProgrammerPackage, qulPackage};
+        armGccPackage, stm32CubeProgrammerPackage, qtForMCUsSdkPackage};
     auto stmEngPackages = {
-        armGccPackage, stm32CubeFwF7SdkPackage, stm32CubeProgrammerPackage, qulPackage};
+        armGccPackage, stm32CubeFwF7SdkPackage, stm32CubeProgrammerPackage, qtForMCUsSdkPackage};
     auto nxpEvalPackages = {
-        armGccPackage, seggerJLinkPackage, qulPackage};
+        armGccPackage, seggerJLinkPackage, qtForMCUsSdkPackage};
     auto nxpEngPackages = {
-        armGccPackage, evkbImxrt1050SdkPackage, seggerJLinkPackage, qulPackage};
+        armGccPackage, evkbImxrt1050SdkPackage, seggerJLinkPackage, qtForMCUsSdkPackage};
     auto desktopPackages = {
-        qulPackage};
+        qtForMCUsSdkPackage};
     packages = {
         armGccPackage, stm32CubeFwF7SdkPackage, stm32CubeProgrammerPackage, evkbImxrt1050SdkPackage,
-        seggerJLinkPackage, qulPackage};
+        seggerJLinkPackage, qtForMCUsSdkPackage};
 
     const QString vendorStm = "STM";
     const QString vendorNxp = "NXP";
     const QString vendorQt = "Qt";
 
-    boards.append(new BoardOptions(vendorStm,
-                                   "stm32f7508",
-                                   "CMake/stm32f7508-discovery.cmake", "", stmEvalPackages));
-    boards.append(new BoardOptions(vendorStm,
-                                   "stm32f769i",
-                                   "CMake/stm32f769i-discovery.cmake", "", stmEvalPackages));
-    boards.append(new BoardOptions(vendorStm,
-                                   "Engineering",
-                                   "CMake/<toolchain file>", "", stmEngPackages));
+    mcuTargets.append(new McuTarget(vendorStm,
+                                    "stm32f7508",
+                                    "CMake/stm32f7508-discovery.cmake",
+                                    "",
+                                    stmEvalPackages));
+    mcuTargets.append(new McuTarget(vendorStm,
+                                    "stm32f769i",
+                                    "CMake/stm32f769i-discovery.cmake",
+                                    "",
+                                    stmEvalPackages));
+    mcuTargets.append(new McuTarget(vendorStm,
+                                    "Engineering",
+                                    "CMake/<toolchain file>",
+                                    "",
+                                    stmEngPackages));
 
-    boards.append(new BoardOptions(vendorNxp,
-                                   "evkbimxrt1050",
-                                   "CMake/evkbimxrt1050-toolchain.cmake", "", nxpEvalPackages));
-    boards.append(new BoardOptions(vendorNxp,
-                                   "Engineering",
-                                   "CMake/<toolchain file>", "", nxpEngPackages));
+    mcuTargets.append(new McuTarget(vendorNxp,
+                                    "evkbimxrt1050",
+                                    "CMake/evkbimxrt1050-toolchain.cmake",
+                                    "",
+                                    nxpEvalPackages));
+    mcuTargets.append(new McuTarget(vendorNxp,
+                                    "Engineering",
+                                    "CMake/<toolchain file>",
+                                    "",
+                                    nxpEngPackages));
 
-    boards.append(new BoardOptions(vendorQt,
-                                   "Desktop", "", "Qt", desktopPackages));
+    mcuTargets.append(new McuTarget(vendorQt,
+                                    "Desktop",
+                                    "",
+                                    "Qt",
+                                    desktopPackages));
 
     for (auto package : packages)
-        connect(package, &PackageOptions::changed, [this](){
+        connect(package, &McuPackage::changed, [this](){
             emit changed();
         });
 }
@@ -410,8 +420,8 @@ McuSupportOptions::~McuSupportOptions()
 {
     qDeleteAll(packages);
     packages.clear();
-    qDeleteAll(boards);
-    boards.clear();
+    qDeleteAll(mcuTargets);
+    mcuTargets.clear();
 }
 
 static ProjectExplorer::ToolChain* armGccToolchain(const Utils::FilePath &path, Core::Id language)
@@ -440,22 +450,22 @@ static ProjectExplorer::ToolChain* armGccToolchain(const Utils::FilePath &path,
     return toolChain;
 }
 
-static bool isDesktop(const BoardOptions* board)
+static bool mcuTargetIsDesktop(const McuTarget* mcuTarget)
 {
-    return board->qulPlatform() == "Qt";
+    return mcuTarget->qulPlatform() == "Qt";
 }
 
 static void setKitProperties(const QString &kitName, ProjectExplorer::Kit *k,
-                             const BoardOptions* board)
+                             const McuTarget* mcuTarget)
 {
     using namespace ProjectExplorer;
 
     k->setUnexpandedDisplayName(kitName);
-    k->setValue(Constants::KIT_BOARD_VENDOR_KEY, board->vendor());
-    k->setValue(Constants::KIT_BOARD_MODEL_KEY, board->model());
+    k->setValue(Constants::KIT_MCUTARGET_VENDOR_KEY, mcuTarget->vendor());
+    k->setValue(Constants::KIT_MCUTARGET_MODEL_KEY, mcuTarget->model());
     k->setAutoDetected(true);
     k->makeSticky();
-    if (isDesktop(board)) {
+    if (mcuTargetIsDesktop(mcuTarget)) {
         k->setDeviceTypeForIcon(Constants::DEVICE_TYPE);
     } else {
         k->setIrrelevantAspects({SysRootKitAspect::id(),
@@ -492,7 +502,7 @@ static void setKitDebugger(ProjectExplorer::Kit *k, const QString &armGccPath)
         DebuggerItem newDebugger;
         newDebugger.setCommand(command);
         newDebugger.setUnexpandedDisplayName(
-                    PackageOptions::tr("Arm GDB at %1").arg(command.toUserOutput()));
+                    McuPackage::tr("Arm GDB at %1").arg(command.toUserOutput()));
         debuggerId = DebuggerItemManager::registerDebugger(newDebugger);
     } else {
         debuggerId = debugger->id();
@@ -508,13 +518,13 @@ static void setKitDevice(ProjectExplorer::Kit *k)
     DeviceTypeKitAspect::setDeviceTypeId(k, Constants::DEVICE_TYPE);
 }
 
-static void setKitEnvironment(ProjectExplorer::Kit *k, const BoardOptions* board)
+static void setKitEnvironment(ProjectExplorer::Kit *k, const McuTarget* mcuTarget)
 {
     using namespace ProjectExplorer;
 
     Utils::EnvironmentItems changes;
     QStringList pathAdditions;
-    for (auto package : board->packages()) {
+    for (auto package : mcuTarget->packages()) {
         if (package->addToPath())
             pathAdditions.append(QDir::toNativeSeparators(package->path()));
         if (!package->environmentVariableName().isEmpty())
@@ -529,7 +539,7 @@ static void setKitEnvironment(ProjectExplorer::Kit *k, const BoardOptions* board
     EnvironmentKitAspect::setEnvironmentChanges(k, changes);
 }
 
-static void setKitCMakeOptions(ProjectExplorer::Kit *k, const BoardOptions* board,
+static void setKitCMakeOptions(ProjectExplorer::Kit *k, const McuTarget* mcuTarget,
                                const QString &qulDir)
 {
     using namespace CMakeProjectManager;
@@ -537,13 +547,13 @@ static void setKitCMakeOptions(ProjectExplorer::Kit *k, const BoardOptions* boar
     CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
     config.append(CMakeConfigItem("CMAKE_CXX_COMPILER", "%{Compiler:Executable:Cxx}"));
     config.append(CMakeConfigItem("CMAKE_C_COMPILER", "%{Compiler:Executable:C}"));
-    if (!board->toolChainFile().isEmpty())
+    if (!mcuTarget->toolChainFile().isEmpty())
         config.append(CMakeConfigItem("CMAKE_TOOLCHAIN_FILE",
-                                      (qulDir + "/" + board->toolChainFile()).toUtf8()));
-    if (!board->qulPlatform().isEmpty())
+                                      (qulDir + "/" + mcuTarget->toolChainFile()).toUtf8()));
+    if (!mcuTarget->qulPlatform().isEmpty())
         config.append(CMakeConfigItem("QUL_PLATFORM",
-                                      board->qulPlatform().toUtf8()));
-    if (isDesktop(board)) {
+                                      mcuTarget->qulPlatform().toUtf8()));
+    if (mcuTargetIsDesktop(mcuTarget)) {
         config.append(CMakeConfigItem("CMAKE_PREFIX_PATH", "%{Qt:QT_INSTALL_PREFIX}"));
         // TODO: Hack! Implement color depth variants of all targets
         config.append(CMakeConfigItem("QUL_COLOR_DEPTH", "32"));
@@ -553,38 +563,38 @@ static void setKitCMakeOptions(ProjectExplorer::Kit *k, const BoardOptions* boar
         CMakeGeneratorKitAspect::setGenerator(k, "NMake Makefiles JOM");
 }
 
-QString McuSupportOptions::kitName(const BoardOptions *board) const
+QString McuSupportOptions::kitName(const McuTarget *mcuTarget) const
 {
     // TODO: get version from qulSdkPackage and insert into name
-    return QString::fromLatin1("Qt for MCUs - %1 %2").arg(board->vendor(), board->model());
+    return QString::fromLatin1("Qt for MCUs - %1 %2").arg(mcuTarget->vendor(), mcuTarget->model());
 }
 
-QList<ProjectExplorer::Kit *> McuSupportOptions::existingKits(const BoardOptions *board)
+QList<ProjectExplorer::Kit *> McuSupportOptions::existingKits(const McuTarget *mcuTargt)
 {
     using namespace ProjectExplorer;
-    const QString boardKitName = kitName(board);
-    return Utils::filtered(KitManager::kits(), [&boardKitName](Kit *kit) {
-            return kit->isAutoDetected() && kit->unexpandedDisplayName() == boardKitName;
+    const QString mcuTargetKitName = kitName(mcuTargt);
+    return Utils::filtered(KitManager::kits(), [&mcuTargetKitName](Kit *kit) {
+            return kit->isAutoDetected() && kit->unexpandedDisplayName() == mcuTargetKitName;
     });
 }
 
-ProjectExplorer::Kit *McuSupportOptions::newKit(const BoardOptions* board)
+ProjectExplorer::Kit *McuSupportOptions::newKit(const McuTarget *mcuTarget)
 {
     using namespace ProjectExplorer;
 
-    const QString armGccPath = toolchainPackage->path();
-    const QString qulDir = qulSdkPackage->path();
-    const auto init = [this, board](Kit *k) {
+    const QString armGccPath = armGccPackage->path();
+    const QString qulDir = qtForMCUsSdkPackage->path();
+    const auto init = [this, mcuTarget](Kit *k) {
         KitGuard kitGuard(k);
 
-        setKitProperties(kitName(board), k, board);
-        if (!isDesktop(board)) {
-            setKitToolchains(k, toolchainPackage->path());
-            setKitDebugger(k, toolchainPackage->path());
+        setKitProperties(kitName(mcuTarget), k, mcuTarget);
+        if (!mcuTargetIsDesktop(mcuTarget)) {
+            setKitToolchains(k, armGccPackage->path());
+            setKitDebugger(k, armGccPackage->path());
             setKitDevice(k);
         }
-        setKitEnvironment(k, board);
-        setKitCMakeOptions(k, board, qulSdkPackage->path());
+        setKitEnvironment(k, mcuTarget);
+        setKitCMakeOptions(k, mcuTarget, qtForMCUsSdkPackage->path());
 
         k->setup();
         k->fix();

src/plugins/mcusupport/mcusupportoptions.h

@@ -42,7 +42,7 @@ class Kit;
 namespace McuSupport {
 namespace Internal {
 
-class PackageOptions : public QObject
+class McuPackage : public QObject
 {
     Q_OBJECT
 
@@ -53,8 +53,8 @@ public:
         ValidPackage
     };
 
-    PackageOptions(const QString &label, const QString &defaultPath, const QString &detectionPath,
-                   const QString &settingsKey);
+    McuPackage(const QString &label, const QString &defaultPath, const QString &detectionPath,
+               const QString &settingsKey);
 
     QString path() const;
     QString label() const;
@@ -96,19 +96,19 @@ private:
     Status m_status = InvalidPath;
 };
 
-class BoardOptions : public QObject
+class McuTarget : public QObject
 {
     Q_OBJECT
 
 public:
-    BoardOptions(const QString &vendor, const QString &model, const QString &toolChainFile,
-                 const QString &qulPlatform, const QVector<PackageOptions *> &packages);
+    McuTarget(const QString &vendor, const QString &model, const QString &toolChainFile,
+              const QString &qulPlatform, const QVector<McuPackage *> &packages);
 
     QString vendor() const;
     QString model() const;
     QString toolChainFile() const;
     QString qulPlatform() const;
-    QVector<PackageOptions *> packages() const;
+    QVector<McuPackage *> packages() const;
     bool isValid() const;
 
 private:
@@ -116,7 +116,7 @@ private:
     const QString m_model;
     const QString m_toolChainFile;
     const QString m_qulPlatform;
-    const QVector<PackageOptions*> m_packages;
+    const QVector<McuPackage*> m_packages;
 };
 
 class McuSupportOptions : public QObject
@@ -127,15 +127,15 @@ public:
     McuSupportOptions(QObject *parent = nullptr);
     ~McuSupportOptions() override;
 
-    QVector<PackageOptions*> packages;
-    QVector<BoardOptions*> boards;
-    PackageOptions *toolchainPackage = nullptr;
-    PackageOptions *qulSdkPackage = nullptr;
+    QVector<McuPackage*> packages;
+    QVector<McuTarget*> mcuTargets;
+    McuPackage *armGccPackage = nullptr;
+    McuPackage *qtForMCUsSdkPackage = nullptr;
 
-    QString kitName(const BoardOptions* board) const;
+    QString kitName(const McuTarget* mcuTarget) const;
 
-    QList<ProjectExplorer::Kit *> existingKits(const BoardOptions* board);
-    ProjectExplorer::Kit *newKit(const BoardOptions* board);
+    QList<ProjectExplorer::Kit *> existingKits(const McuTarget *mcuTargt);
+    ProjectExplorer::Kit *newKit(const McuTarget *mcuTarget);
 
 signals:
     void changed();

src/plugins/mcusupport/mcusupportoptionspage.cpp

@@ -50,17 +50,17 @@ public:
     McuSupportOptionsWidget(const McuSupportOptions *options, QWidget *parent = nullptr);
 
     void updateStatus();
-    void showBoardPackages();
-    BoardOptions *currentBoard() const;
+    void showMcuTargetPackages();
+    McuTarget *currentMcuTarget() const;
 
 private:
     QString m_armGccPath;
     const McuSupportOptions *m_options;
-    QMap <PackageOptions*, QWidget*> m_packageWidgets;
-    QMap <BoardOptions*, QWidget*> m_boardPacketWidgets;
+    QMap <McuPackage*, QWidget*> m_packageWidgets;
+    QMap <McuTarget*, QWidget*> m_mcuTargetPacketWidgets;
     QFormLayout *m_packagesLayout = nullptr;
     QLabel *m_statusLabel = nullptr;
-    QComboBox *m_boardComboBox = nullptr;
+    QComboBox *m_mcuTargetComboBox = nullptr;
 };
 
 McuSupportOptionsWidget::McuSupportOptionsWidget(const McuSupportOptions *options, QWidget *parent)
@@ -69,18 +69,18 @@ McuSupportOptionsWidget::McuSupportOptionsWidget(const McuSupportOptions *option
 {
     auto mainLayout = new QVBoxLayout(this);
 
-    auto boardChooserlayout = new QHBoxLayout;
-    auto boardChooserLabel = new QLabel(McuSupportOptionsPage::tr("Target:"));
-    boardChooserlayout->addWidget(boardChooserLabel);
-    m_boardComboBox = new QComboBox;
-    boardChooserLabel->setBuddy(m_boardComboBox);
-    boardChooserLabel->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
-    m_boardComboBox->addItems(
-                Utils::transform<QStringList>(m_options->boards, [this](BoardOptions *b){
-                    return m_options->kitName(b);
+    auto mcuTargetChooserlayout = new QHBoxLayout;
+    auto mcuTargetChooserLabel = new QLabel(McuSupportOptionsPage::tr("Target:"));
+    mcuTargetChooserlayout->addWidget(mcuTargetChooserLabel);
+    m_mcuTargetComboBox = new QComboBox;
+    mcuTargetChooserLabel->setBuddy(m_mcuTargetComboBox);
+    mcuTargetChooserLabel->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
+    m_mcuTargetComboBox->addItems(
+                Utils::transform<QStringList>(m_options->mcuTargets, [this](McuTarget *t){
+                    return m_options->kitName(t);
                 }));
-    boardChooserlayout->addWidget(m_boardComboBox);
-    mainLayout->addLayout(boardChooserlayout);
+    mcuTargetChooserlayout->addWidget(m_mcuTargetComboBox);
+    mainLayout->addLayout(mcuTargetChooserlayout);
 
     auto m_packagesGroupBox = new QGroupBox(McuSupportOptionsPage::tr("Packages"));
     mainLayout->addWidget(m_packagesGroupBox);
@@ -93,30 +93,31 @@ McuSupportOptionsWidget::McuSupportOptionsWidget(const McuSupportOptions *option
     m_statusLabel->setAlignment(Qt::AlignBottom | Qt::AlignLeft);
 
     connect(options, &McuSupportOptions::changed, this, &McuSupportOptionsWidget::updateStatus);
-    connect(m_boardComboBox, &QComboBox::currentTextChanged,
-            this, &McuSupportOptionsWidget::showBoardPackages);
+    connect(m_mcuTargetComboBox, &QComboBox::currentTextChanged,
+            this, &McuSupportOptionsWidget::showMcuTargetPackages);
 
-    showBoardPackages();
+    showMcuTargetPackages();
     updateStatus();
 }
 
 void McuSupportOptionsWidget::updateStatus()
 {
-    const BoardOptions *board = currentBoard();
-    if (!board)
+    const McuTarget *mcuTarget = currentMcuTarget();
+    if (!mcuTarget)
         return;
 
-    m_statusLabel->setText(board->isValid()
+    m_statusLabel->setText(mcuTarget->isValid()
                 ? QString::fromLatin1("A kit <b>%1</b> for the selected target can be generated. "
-                                      "Press Apply to generate it.").arg(m_options->kitName(board))
+                                      "Press Apply to generate it.").arg(m_options->kitName(
+                                                                             mcuTarget))
                 : QString::fromLatin1("Provide the package paths in order to create a kit for "
                                       "your target."));
 }
 
-void McuSupportOptionsWidget::showBoardPackages()
+void McuSupportOptionsWidget::showMcuTargetPackages()
 {
-    const BoardOptions *board = currentBoard();
-    if (!board)
+    const McuTarget *mcuTarget = currentMcuTarget();
+    if (!mcuTarget)
         return;
 
     while (m_packagesLayout->rowCount() > 0) {
@@ -127,7 +128,7 @@ void McuSupportOptionsWidget::showBoardPackages()
 
     for (auto package : m_options->packages) {
         QWidget *packageWidget = package->widget();
-        if (!board->packages().contains(package))
+        if (!mcuTarget->packages().contains(package))
             continue;
         m_packagesLayout->addRow(package->label(), packageWidget);
         packageWidget->show();
@@ -136,10 +137,10 @@ void McuSupportOptionsWidget::showBoardPackages()
     updateStatus();
 }
 
-BoardOptions *McuSupportOptionsWidget::currentBoard() const
+McuTarget *McuSupportOptionsWidget::currentMcuTarget() const
 {
-    const int boardIndex = m_boardComboBox->currentIndex();
-    return m_options->boards.isEmpty() ? nullptr : m_options->boards.at(boardIndex);
+    const int mcuTargetIndex = m_mcuTargetComboBox->currentIndex();
+    return m_options->mcuTargets.isEmpty() ? nullptr : m_options->mcuTargets.at(mcuTargetIndex);
 }
 
 McuSupportOptionsPage::McuSupportOptionsPage(QObject* parent)
@@ -164,18 +165,18 @@ void McuSupportOptionsPage::apply()
     for (auto package : m_options->packages)
         package->writeToSettings();
 
-    QTC_ASSERT(m_options->toolchainPackage, return);
-    QTC_ASSERT(m_options->qulSdkPackage, return);
+    QTC_ASSERT(m_options->armGccPackage, return);
+    QTC_ASSERT(m_options->qtForMCUsSdkPackage, return);
 
-    const BoardOptions *board = m_widget->currentBoard();
-    if (!board)
+    const McuTarget *mcuTarget = m_widget->currentMcuTarget();
+    if (!mcuTarget)
         return;
 
     using namespace ProjectExplorer;
 
-    for (auto existingKit : m_options->existingKits(board))
+    for (auto existingKit : m_options->existingKits(mcuTarget))
         ProjectExplorer::KitManager::deregisterKit(existingKit);
-    m_options->newKit(board);
+    m_options->newKit(mcuTarget);
 }
 
 void McuSupportOptionsPage::finish()

src/plugins/mcusupport/mcusupportrunconfiguration.cpp

@@ -51,7 +51,7 @@ static CommandLine flashAndRunCommand(Target *target)
 
     // TODO: Hack! Implement flash target name handling, properly
     const QString targetName =
-            target->kit()->value(Constants::KIT_BOARD_VENDOR_KEY).toString() == "NXP"
+            target->kit()->value(Constants::KIT_MCUTARGET_VENDOR_KEY).toString() == "NXP"
             ? QString("flash_%1").arg(projectName)
             : QString("flash_%1_and_bootloader").arg(projectName);