McuSupport: Update json kit processing to match Qt for MCUs 1.4

FreeRTOS backend is now a separate platform and requires dedicated json
kit file. Starting form Qul 1.4 there is no option to produce BareMetal
and FreeRTOS kits out of one json file.

This change is backward compatible with Qul 1.3.

Change-Id: Ic50b566a7f1a01fad4b00c07e723dfe1343fc2b0
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>

src/plugins/mcusupport/mcusupportoptions.cpp

@@ -607,7 +607,9 @@ static void setKitCMakeOptions(ProjectExplorer::Kit *k, const McuTarget* mcuTarg
                                   (qulDir + "/lib/cmake/Qul/QulGenerators.cmake").toUtf8()));
     config.append(CMakeConfigItem("QUL_PLATFORM",
                                   mcuTarget->qulPlatform().toUtf8()));
-    if (mcuTarget->os() == McuTarget::OS::FreeRTOS)
+
+    if (mcuTarget->qulVersion() <= QVersionNumber{1,3} // OS variable was removed in Qul 1.4
+        && mcuTarget->os() == McuTarget::OS::FreeRTOS)
         config.append(CMakeConfigItem("OS", "FreeRTOS"));
     if (mcuTarget->colorDepth() >= 0)
         config.append(CMakeConfigItem("QUL_COLOR_DEPTH",
@@ -627,8 +629,12 @@ static void setKitQtVersionOptions(ProjectExplorer::Kit *k)
 
 QString McuSupportOptions::kitName(const McuTarget *mcuTarget)
 {
-    const QString os = QLatin1String(mcuTarget->os()
+    QString os;
-                                     == McuTarget::OS::FreeRTOS ? " FreeRTOS" : "");
+    if (mcuTarget->qulVersion() <= QVersionNumber{1,3} && mcuTarget->os() == McuTarget::OS::FreeRTOS) {
+        // Starting from Qul 1.4 each OS is a separate platform
+        os = QLatin1String(" FreeRTOS");
+    }
+
     const QString colorDepth = mcuTarget->colorDepth() > 0
             ? QString::fromLatin1(" %1bpp").arg(mcuTarget->colorDepth())
             : "";
@@ -637,8 +643,12 @@ QString McuSupportOptions::kitName(const McuTarget *mcuTarget)
             mcuTarget->toolChainPackage()->type() == McuToolChainPackage::TypeDesktop
             ? "Desktop"
             : mcuTarget->qulPlatform();
-    return QString::fromLatin1("Qt for MCUs %1 - %2%3%4")
+    return QString::fromLatin1("Qt for MCUs %1.%2 - %3%4%5")
-            .arg(mcuTarget->qulVersion().toString(), targetName, os, colorDepth);
+            .arg(QString::number(mcuTarget->qulVersion().majorVersion()),
+                 QString::number(mcuTarget->qulVersion().minorVersion()),
+                 targetName,
+                 os,
+                 colorDepth);
 }
 
 QList<ProjectExplorer::Kit *> McuSupportOptions::existingKits(const McuTarget *mcuTarget)

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -150,7 +150,6 @@ static McuPackage *createRGLPackage()
 
 static McuPackage *createStm32CubeProgrammerPackage()
 {
-
     QString defaultPath = QDir::homePath();
     if (Utils::HostOsInfo::isWindowsHost()) {
         const QString programPath =
@@ -204,14 +203,18 @@ static McuPackage *createMcuXpressoIdePackage()
 
 static McuPackage *createBoardSdkPackage(const QString &envVar)
 {
-    const QString envVarPrefix = envVar.chopped(strlen("_SDK_PATH"));
+    auto postfixPos = envVar.indexOf("_SDK_PATH");
+    if (postfixPos < 0) {
+        postfixPos = envVar.indexOf("_DIR");
+    }
+    const QString sdkName = postfixPos > 0 ? envVar.left(postfixPos) : envVar;
 
     const QString defaultPath =
             qEnvironmentVariableIsSet(envVar.toLatin1()) ?
                 qEnvironmentVariable(envVar.toLatin1()) : QDir::homePath();
 
     auto result = new McuPackage(
-                QString::fromLatin1("MCU SDK (%1)").arg(envVarPrefix),
+                QString::fromLatin1("MCU SDK (%1)").arg(sdkName),
                 defaultPath,
                 {},
                 envVar);
@@ -254,34 +257,42 @@ struct McuTargetDescription
     QString freeRTOSBoardSdkSubDir;
 };
 
-static QVector<McuTarget *> targetsFromDescriptions(const QList<McuTargetDescription> &descriptions,
+struct McuTargetFactory
-                                                    QVector<McuPackage *> *packages)
 {
-    const QHash<QString, McuToolChainPackage *> tcPkgs = {
+    McuTargetFactory(const QHash<QString, McuToolChainPackage *> &tcPkgs,
-        {{"armgcc"}, createArmGccPackage()},
+                     const QHash<QString, McuPackage *> &vendorPkgs)
-        {{"greenhills"}, createGhsToolchainPackage()},
+        : tcPkgs(tcPkgs)
-        {{"desktop"}, createDesktopToolChainPackage()},
+        , vendorPkgs(vendorPkgs)
-    };
+    {}
 
-    const QHash<QString, McuPackage *> vendorPkgs = {
+    QVector<McuTarget *> createTargets(const McuTargetDescription& description)
-        {{"ST"}, createStm32CubeProgrammerPackage()},
+    {
-        {{"NXP"}, createMcuXpressoIdePackage()},
+        if (description.toolchainId == "desktop") {
-        {{"Renesas"}, createRGLPackage()}
+            return createDesktopTargets(description);
-    };
-
-    QHash<QString, McuPackage *> boardSdkPkgs;
-    QHash<QString, McuPackage *> freeRTOSPkgs;
-    QVector<McuTarget *> mcuTargets;
-
-    for (const auto &desc : descriptions) {
-        McuToolChainPackage *tcPkg = tcPkgs.value(desc.toolchainId);
-        if (desc.toolchainId == "desktop") {
-            auto mcuTarget = new McuTarget(QVersionNumber::fromString(desc.qulVersion),
-                                           desc.platformVendor, desc.platform,
-                                           McuTarget::OS::Desktop, {}, tcPkg);
-            mcuTargets.append(mcuTarget);
-            continue;
         }
+        auto qulVersion = QVersionNumber::fromString(description.qulVersion);
+        if (qulVersion <= QVersionNumber({1,3})) {
+            // There was a platform backends related refactoring in Qul 1.4
+            // This requires different processing of McuTargetDescriptions
+            return createMcuTargetsLegacy(description);
+        }
+        return createMcuTargets(description);
+    }
+
+    QVector<McuPackage *> getMcuPackages() const
+    {
+        QVector<McuPackage *> packages;
+        packages.append(boardSdkPkgs.values().toVector());
+        packages.append(freeRTOSPkgs.values().toVector());
+        return packages;
+    }
+
+protected:
+    // Implementation for Qul version <= 1.3
+    QVector<McuTarget *> createMcuTargetsLegacy(const McuTargetDescription& desc)
+    {
+        QVector<McuTarget *> mcuTargets;
+        auto tcPkg = tcPkgs.value(desc.toolchainId);
         for (auto os : {McuTarget::OS::BareMetal, McuTarget::OS::FreeRTOS}) {
             for (int colorDepth : desc.colorDepths) {
                 QVector<McuPackage*> required3rdPartyPkgs = {
@@ -319,13 +330,93 @@ static QVector<McuTarget *> targetsFromDescriptions(const QList<McuTargetDescrip
                 mcuTargets.append(mcuTarget);
             }
         }
+        return mcuTargets;
+    }
+
+    QVector<McuTarget *> createMcuTargets(const McuTargetDescription& desc)
+    {
+        QVector<McuTarget *> mcuTargets;
+        auto tcPkg = tcPkgs.value(desc.toolchainId);
+        for (int colorDepth : desc.colorDepths) {
+            QVector<McuPackage*> required3rdPartyPkgs = {
+                vendorPkgs.value(desc.platformVendor), tcPkg
+            };
+            QString boardSdkDefaultPath;
+            if (!desc.boardSdkEnvVar.isEmpty()
+                        && desc.boardSdkEnvVar != "RGL_DIR") { // Already included in vendorPkgs
+                if (!boardSdkPkgs.contains(desc.boardSdkEnvVar)) {
+                    auto boardSdkPkg = createBoardSdkPackage(desc.boardSdkEnvVar);
+                    boardSdkPkgs.insert(desc.boardSdkEnvVar, boardSdkPkg);
+                }
+                auto boardSdkPkg = boardSdkPkgs.value(desc.boardSdkEnvVar);
+                boardSdkDefaultPath = boardSdkPkg->defaultPath();
+                required3rdPartyPkgs.append(boardSdkPkg);
+            }
+
+            auto os = McuTarget::OS::BareMetal;
+            if (!desc.freeRTOSEnvVar.isEmpty()) {
+                os = McuTarget::OS::FreeRTOS;
+                if (!freeRTOSPkgs.contains(desc.freeRTOSEnvVar)) {
+                    freeRTOSPkgs.insert(desc.freeRTOSEnvVar, createFreeRTOSSourcesPackage(
+                                            desc.freeRTOSEnvVar, boardSdkDefaultPath,
+                                            desc.freeRTOSBoardSdkSubDir));
+                }
+                required3rdPartyPkgs.append(freeRTOSPkgs.value(desc.freeRTOSEnvVar));
+            }
+
+            auto mcuTarget = new McuTarget(QVersionNumber::fromString(desc.qulVersion),
+                                            desc.platformVendor, desc.platform, os,
+                                            required3rdPartyPkgs, tcPkg);
+            mcuTarget->setColorDepth(colorDepth);
+            mcuTargets.append(mcuTarget);
+        }
+        return mcuTargets;
+    }
+
+    QVector<McuTarget *> createDesktopTargets(const McuTargetDescription& desc)
+    {
+        auto tcPkg = tcPkgs.value(desc.toolchainId);
+        auto desktopTarget = new McuTarget(QVersionNumber::fromString(desc.qulVersion),
+                                        desc.platformVendor, desc.platform,
+                                        McuTarget::OS::Desktop, {}, tcPkg);
+        return { desktopTarget };
+    }
+
+private:
+    const QHash<QString, McuToolChainPackage *> &tcPkgs;
+    const QHash<QString, McuPackage *> &vendorPkgs;
+
+    QHash<QString, McuPackage *> boardSdkPkgs;
+    QHash<QString, McuPackage *> freeRTOSPkgs;
+};
+
+static QVector<McuTarget *> targetsFromDescriptions(const QList<McuTargetDescription> &descriptions,
+                                                    QVector<McuPackage *> *packages)
+{
+    const QHash<QString, McuToolChainPackage *> tcPkgs = {
+        {{"armgcc"}, createArmGccPackage()},
+        {{"greenhills"}, createGhsToolchainPackage()},
+        {{"desktop"}, createDesktopToolChainPackage()},
+    };
+
+    const QHash<QString, McuPackage *> vendorPkgs = {
+        {{"ST"}, createStm32CubeProgrammerPackage()},
+        {{"NXP"}, createMcuXpressoIdePackage()},
+        {{"Renesas"}, createRGLPackage()}
+    };
+
+    McuTargetFactory targetFactory(tcPkgs, vendorPkgs);
+    QVector<McuTarget *> mcuTargets;
+
+    for (const auto &desc : descriptions) {
+        auto newTargets = targetFactory.createTargets(desc);
+        mcuTargets.append(newTargets);
     }
 
     packages->append(Utils::transform<QVector<McuPackage *> >(
                          tcPkgs.values(), [&](McuToolChainPackage *tcPkg) { return tcPkg; }));
     packages->append(vendorPkgs.values().toVector());
-    packages->append(boardSdkPkgs.values().toVector());
+    packages->append(targetFactory.getMcuPackages());
-    packages->append(freeRTOSPkgs.values().toVector());
 
     return  mcuTargets;
 }