McuSupport: Pass versioning from json to McuPackage ctor

Use versions parameter from JSON kits.
Instead of setting version in separate step pass it directly
to ctor.

Change-Id: I7ac9017d56dafa316f95ba4c504dcb0af641dbdc
Reviewed-by: Dawid Śliwa <dawid.sliwa@qt.io>
Reviewed-by: Yasser Grimes <yasser.grimes@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: hjk <hjk@qt.io>
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>

src/plugins/mcusupport/mcuabstractpackage.h

@@ -51,7 +51,7 @@ public:
     virtual QString cmakeVariableName() const = 0;
     virtual QString environmentVariableName() const = 0;
     virtual bool isAddToSystemPath() const = 0;
-    virtual void setVersions(const QStringList &) = 0;
+    virtual QStringList versions() const = 0;
 
     virtual Utils::FilePath basePath() const = 0;
     virtual Utils::FilePath path() const = 0;

src/plugins/mcusupport/mcupackage.cpp

@@ -57,6 +57,7 @@ McuPackage::McuPackage(const SettingsHandler::Ptr &settingsHandler,
                        const QString &settingsKey,
                        const QString &cmakeVarName,
                        const QString &envVarName,
+                       const QStringList &versions,
                        const QString &downloadUrl,
                        const McuPackageVersionDetector *versionDetector,
                        const bool addToSystemPath,
@@ -68,6 +69,7 @@ McuPackage::McuPackage(const SettingsHandler::Ptr &settingsHandler,
     , m_settingsKey(settingsKey)
     , m_versionDetector(versionDetector)
     , m_relativePathModifier(relativePathModifier)
+    , m_versions(versions)
     , m_cmakeVariableName(cmakeVarName)
     , m_environmentVariableName(envVarName)
     , m_downloadUrl(downloadUrl)
@@ -101,9 +103,9 @@ bool McuPackage::isAddToSystemPath() const
     return m_addToSystemPath;
 }
 
-void McuPackage::setVersions(const QStringList &versions)
+QStringList McuPackage::versions() const
 {
-    m_versions = versions;
+    return m_versions;
 }
 
 FilePath McuPackage::basePath() const
@@ -279,6 +281,7 @@ McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHan
                                          const FilePath &detectionPath,
                                          const QString &settingsKey,
                                          McuToolChainPackage::ToolChainType type,
+                                         const QStringList &versions,
                                          const QString &cmakeVarName,
                                          const QString &envVarName,
                                          const McuPackageVersionDetector *versionDetector)
@@ -289,7 +292,8 @@ McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHan
                  settingsKey,
                  cmakeVarName,
                  envVarName,
-                 {},
+                 versions,
+                 {}, // url
                  versionDetector)
     , m_type(type)
 {}

src/plugins/mcusupport/mcupackage.h

@@ -62,6 +62,7 @@ public:
                const QString &settingsKey,
                const QString &cmakeVarName,
                const QString &envVarName,
+               const QStringList &versions = {},
                const QString &downloadUrl = {},
                const McuPackageVersionDetector *versionDetector = nullptr,
                const bool addToPath = false,
@@ -73,7 +74,7 @@ public:
     QString cmakeVariableName() const override;
     QString environmentVariableName() const override;
     bool isAddToSystemPath() const override;
-    void setVersions(const QStringList &versions) override;
+    QStringList versions() const override;
 
     Utils::FilePath basePath() const override;
     Utils::FilePath path() const override;
@@ -129,7 +130,8 @@ public:
                         const Utils::FilePath &detectionPath,
                         const QString &settingsKey,
                         ToolChainType toolchainType,
-                        const QString &cmakeVarName = {},
+                        const QStringList &versions,
+                        const QString &cmakeVarName,
                         const QString &envVarName = {},
                         const McuPackageVersionDetector *versionDetector = nullptr);
 

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -145,7 +145,8 @@ McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &settingsHandler,
                                         desc.boardSdk.envVar, // settings key
                                         "QUL_BOARD_SDK_DIR",  // cmake var
                                         desc.boardSdk.envVar, // env var
-                                        {},                   // download URL
+                                        desc.boardSdk.versions,
+                                        {}, // download URL
                                         versionDetector)};
 }
 
@@ -170,6 +171,7 @@ McuPackagePtr createFreeRTOSSourcesPackage(const SettingsHandler::Ptr &settingsH
                        QString{Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(envVarPrefix),
                        "FREERTOS_DIR",           // cmake var
                        envVar,                   // env var
+                       {},                       // versions
                        "https://freertos.org")}; // download url
 }
 
@@ -190,30 +192,25 @@ McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &
 McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
 {
     return McuToolChainPackagePtr{new McuToolChainPackage(
-        settingsHandler, {}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported)};
+        settingsHandler, {}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported, {}, {})};
 }
 
-McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+                                                  const QStringList &versions)
 {
-    return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler,
+    return McuToolChainPackagePtr{new McuToolChainPackage(
-                                                          {},
+        settingsHandler, {}, {}, {}, {}, McuToolChainPackage::ToolChainType::MSVC, versions, {})};
-                                                          {},
-                                                          {},
-                                                          {},
-                                                          McuToolChainPackage::ToolChainType::MSVC)};
 }
 
-McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+                                                 const QStringList &versions)
 {
-    return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler,
+    return McuToolChainPackagePtr{new McuToolChainPackage(
-                                                          {},
+        settingsHandler, {}, {}, {}, {}, McuToolChainPackage::ToolChainType::GCC, versions, {})};
-                                                          {},
-                                                          {},
-                                                          {},
-                                                          McuToolChainPackage::ToolChainType::GCC)};
 }
 
-McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
+                                                    const QStringList &versions)
 {
     const char envVar[] = "ARMGCC_DIR";
 
@@ -244,12 +241,14 @@ McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &
                                 detectionPath,
                                 "GNUArmEmbeddedToolchain",                  // settingsKey
                                 McuToolChainPackage::ToolChainType::ArmGcc, // toolchainType
-                                Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE,    // cmake var
+                                versions,
-                                envVar,                                     // env var
+                                Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
+                                envVar,                                  // env var
                                 versionDetector)};
 }
 
-McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
+                                                 const QStringList &versions)
 {
     const char envVar[] = "GHS_COMPILER_DIR";
 
@@ -267,12 +266,14 @@ McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &set
                                 FilePath("ccv850").withExecutableSuffix(), // detectionPath
                                 "GHSToolchain",                            // settingsKey
                                 McuToolChainPackage::ToolChainType::GHS,   // toolchainType
-                                Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE,   // cmake var
+                                versions,
-                                envVar,                                    // env var
+                                Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
+                                envVar,                                  // env var
                                 versionDetector)};
 }
 
-McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
+                                                    const QStringList &versions)
 {
     const char envVar[] = "GHS_ARM_COMPILER_DIR";
 
@@ -290,12 +291,14 @@ McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &
                                 FilePath("cxarm").withExecutableSuffix(),   // detectionPath
                                 "GHSArmToolchain",                          // settingsKey
                                 McuToolChainPackage::ToolChainType::GHSArm, // toolchainType
-                                Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE,    // cmake var
+                                versions,
-                                envVar,                                     // env var
+                                Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
+                                envVar,                                  // env var
                                 versionDetector)};
 }
 
-McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
+McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
+                                                 const QStringList &versions)
 {
     const char envVar[] = "IAR_ARM_COMPILER_DIR";
 
@@ -326,6 +329,7 @@ McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &set
                                 detectionPath,
                                 "IARToolchain",                          // settings key
                                 McuToolChainPackage::ToolChainType::IAR, // toolchainType
+                                versions,
                                 Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
                                 envVar,                                  // env var
                                 versionDetector)};
@@ -357,6 +361,7 @@ static McuPackagePtr createStm32CubeProgrammerPackage(const SettingsHandler::Ptr
                        "Stm32CubeProgrammer",
                        {},                                                           // cmake var
                        {},                                                           // env var
+                       {},                                                           // versions
                        "https://www.st.com/en/development-tools/stm32cubeprog.html", // download url
                        nullptr, // version detector
                        true,    // add to path
@@ -395,6 +400,7 @@ static McuPackagePtr createMcuXpressoIdePackage(const SettingsHandler::Ptr &sett
                                         "MCUXpressoIDE",             // settings key
                                         "MCUXPRESSO_IDE_PATH",       // cmake var
                                         envVar,
+                                        {},                                     // versions
                                         "https://www.nxp.com/mcuxpresso/ide")}; // download url
 }
 
@@ -459,15 +465,25 @@ static McuAbstractTargetFactory::Ptr createFactory(bool isLegacy,
     McuAbstractTargetFactory::Ptr result;
     if (isLegacy) {
         static const QHash<QString, ToolchainCompilerCreator> toolchainCreators = {
-            {{"armgcc"},
+            {{"armgcc"}, {[settingsHandler](const QStringList &versions) {
-             {[settingsHandler] { return createArmGccToolchainPackage(settingsHandler); }}},
+                 return createArmGccToolchainPackage(settingsHandler, versions);
+             }}},
             {{"greenhills"},
-             [settingsHandler] { return createGhsToolchainPackage(settingsHandler); }},
+             [settingsHandler](const QStringList &versions) {
-            {{"iar"}, {[settingsHandler] { return createIarToolChainPackage(settingsHandler); }}},
+                 return createGhsToolchainPackage(settingsHandler, versions);
-            {{"msvc"}, {[settingsHandler] { return createMsvcToolChainPackage(settingsHandler); }}},
+             }},
-            {{"gcc"}, {[settingsHandler] { return createGccToolChainPackage(settingsHandler); }}},
+            {{"iar"}, {[settingsHandler](const QStringList &versions) {
-            {{"arm-greenhills"},
+                 return createIarToolChainPackage(settingsHandler, versions);
-             {[settingsHandler] { return createGhsArmToolchainPackage(settingsHandler); }}},
+             }}},
+            {{"msvc"}, {[settingsHandler](const QStringList &versions) {
+                 return createMsvcToolChainPackage(settingsHandler, versions);
+             }}},
+            {{"gcc"}, {[settingsHandler](const QStringList &versions) {
+                 return createGccToolChainPackage(settingsHandler, versions);
+             }}},
+            {{"arm-greenhills"}, {[settingsHandler](const QStringList &versions) {
+                 return createGhsArmToolchainPackage(settingsHandler, versions);
+             }}},
         };
 
         const FilePath toolchainFilePrefix = qtMcuSdkPath / Constants::QUL_TOOLCHAIN_CMAKE_DIR;
@@ -568,6 +584,11 @@ static QFileInfoList targetDescriptionFiles(const Utils::FilePath &dir)
 
 static PackageDescription parsePackage(const QJsonObject &cmakeEntry)
 {
+    const QVariantList versionsVariantList = cmakeEntry["versions"].toArray().toVariantList();
+    const auto versions = Utils::transform<QStringList>(versionsVariantList,
+                                                        [&](const QVariant &version) {
+                                                            return version.toString();
+                                                        });
     return {cmakeEntry["label"].toString(),
             cmakeEntry["envVar"].toString(),
             cmakeEntry["cmakeVar"].toString(),
@@ -575,7 +596,7 @@ static PackageDescription parsePackage(const QJsonObject &cmakeEntry)
             cmakeEntry["setting"].toString(),
             FilePath::fromString(cmakeEntry["defaultValue"].toString()),
             FilePath::fromString(cmakeEntry["validation"].toString()),
-            {},
+            versions,
             false};
 }
 

src/plugins/mcusupport/mcusupportsdk.h

@@ -65,12 +65,14 @@ Utils::FilePath kitsPath(const Utils::FilePath &dir);
 McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &,
                                                     const Utils::FilePath &qtMcuSdkPath);
 McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &);
-McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &);
+McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &);
+McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &);
+McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &,
-McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &);
+                                                    const QStringList &);
-McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &);
+McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &, const QStringList &);
-McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &);
+McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
+McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &,
+                                                    const QStringList &);
 
 McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &, const McuTargetDescription &);
 McuPackagePtr createFreeRTOSSourcesPackage(const SettingsHandler::Ptr &settingsHandler,

src/plugins/mcusupport/mcutargetdescription.h

@@ -42,7 +42,7 @@ struct PackageDescription
     QString setting;
     Utils::FilePath defaultPath;
     Utils::FilePath validationPath;
-    QList<QVersionNumber> versions;
+    QStringList versions;
     bool shouldAddToSystemPath;
 }; //struct PackageDescription
 

src/plugins/mcusupport/mcutargetfactory.cpp

@@ -124,6 +124,7 @@ McuPackagePtr McuTargetFactory::createPackage(const PackageDescription &pkgDesc)
         pkgDesc.setting,
         pkgDesc.cmakeVar,
         pkgDesc.envVar,
+        pkgDesc.versions,
     }};
 }
 
@@ -136,7 +137,14 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
         = toolchainTypeMapping.value(toolchain.id, McuToolChainPackage::ToolChainType::Unsupported);
 
     if (isDesktopToolchain(toolchainType))
-        return new McuToolChainPackage{settingsHandler, {}, {}, {}, {}, toolchainType};
+        return new McuToolChainPackage{settingsHandler,
+                                       {},
+                                       {},
+                                       {},
+                                       {},
+                                       toolchainType,
+                                       toolchain.versions,
+                                       compilerDescription.cmakeVar};
     else if (!isToolchainDescriptionValid(toolchain))
         toolchainType = McuToolChainPackage::ToolChainType::Unsupported;
 
@@ -147,6 +155,7 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
         compilerDescription.validationPath,
         compilerDescription.setting,
         toolchainType,
+        toolchain.versions,
         compilerDescription.cmakeVar,
         compilerDescription.envVar,
         nullptr, // McuPackageVersionDetector

src/plugins/mcusupport/mcutargetfactorylegacy.cpp

@@ -78,7 +78,6 @@ QPair<Targets, Packages> McuTargetFactoryLegacy::createTargets(const Sdk::McuTar
                 boardSdkPkgs.insert(desc.boardSdk.envVar, boardSdkPkg);
             }
             McuPackagePtr boardSdkPkg{boardSdkPkgs.value(desc.boardSdk.envVar)};
-            boardSdkPkg->setVersions(desc.boardSdk.versions);
             boardSdkDefaultPath = boardSdkPkg->defaultPath();
             required3rdPartyPkgs.insert(boardSdkPkg);
         }
@@ -119,11 +118,10 @@ McuAbstractTargetFactory::AdditionalPackages McuTargetFactoryLegacy::getAddition
 McuToolChainPackagePtr McuTargetFactoryLegacy::getToolchainCompiler(
     const Sdk::McuTargetDescription::Toolchain &desc) const
 {
-    auto compilerCreator = toolchainCreators.value(desc.id, [this] {
+    auto compilerCreator = toolchainCreators.value(desc.id, [this](const QStringList & /*versions*/) {
         return McuToolChainPackagePtr{Sdk::createUnsupportedToolChainPackage(settingsHandler)};
     });
-    McuToolChainPackagePtr toolchainPackage = compilerCreator();
+    McuToolChainPackagePtr toolchainPackage = compilerCreator(desc.versions);
-    toolchainPackage->setVersions(desc.versions);
     return toolchainPackage;
 }
 

src/plugins/mcusupport/mcutargetfactorylegacy.h

@@ -37,7 +37,7 @@ namespace McuSupport::Internal {
 
 class McuPackage;
 
-using ToolchainCompilerCreator = std::function<McuToolChainPackagePtr()>;
+using ToolchainCompilerCreator = std::function<McuToolChainPackagePtr(const QStringList &version)>;
 
 class McuTargetFactoryLegacy : public McuAbstractTargetFactory
 {

src/plugins/mcusupport/test/armgcc_nxp_1050_json.h

@@ -61,7 +61,8 @@ constexpr auto armgcc_nxp_1050_json = R"({
   "toolchain": {
     "id": "armgcc",
     "versions": [
-      "9.3.1"
+      "9.3.1",
+      "10.3.1"
     ],
     "compiler": {
         "id": "ARMGCC_DIR",
@@ -85,13 +86,18 @@ constexpr auto armgcc_nxp_1050_json = R"({
   "boardSdk": {
     "envVar": "EVKB_IMXRT1050_SDK_PATH",
     "versions": [
-      "2.10.0"
+      "2.11.0"
     ],
     "cmakeEntries": [
       {
         "id": "NXP_SDK_DIR",
         "label": "Board SDK for MIMXRT1050-EVK",
         "cmakeVar": "QUL_BOARD_SDK_DIR",
+        "envVar": "EVKB_IMXRT1050_SDK_PATH",
+        "setting": "EVKB_IMXRT1050_SDK_PATH",
+        "versions": [
+          "2.11.0"
+        ],
         "type": "path",
         "optional": false
       }

src/plugins/mcusupport/test/armgcc_stm32f769i_freertos_json.h

@@ -61,7 +61,8 @@ constexpr auto armgcc_stm32f769i_freertos_json = R"({
   "toolchain": {
     "id": "armgcc",
     "versions": [
-      "9.3.1"
+      "9.3.1",
+      "10.3.1"
     ],
     "compiler": {
         "id": "ARMGCC_DIR",

src/plugins/mcusupport/test/packagemock.h

@@ -50,7 +50,7 @@ public:
     MOCK_METHOD(QString, environmentVariableName, (), (const));
     MOCK_METHOD(bool, isAddToSystemPath, (), (const));
     MOCK_METHOD(bool, writeToSettings, (), (const));
-    MOCK_METHOD(void, setVersions, (const QStringList &) );
+    MOCK_METHOD(QStringList, versions, (), (const));
 
     MOCK_METHOD(QWidget *, widget, ());
 }; // class PackageMock

src/plugins/mcusupport/test/unittest.cpp

@@ -73,6 +73,9 @@ const char armGccEnvVar[]{"ARMGCC_DIR"};
 const char armGccLabel[]{"GNU Arm Embedded Toolchain"};
 const char armGccToolchainFilePath[]{"/opt/qtformcu/2.2/lib/cmake/Qul/toolchain/armgcc.cmake"};
 const char armGcc[]{"armgcc"};
+const char armGccVersion[]{"9.3.1"};
+const char armGccNewVersion[]{"10.3.1"};
+const QStringList boardSdkVersions{{"2.11.0"}};
 const char cmakeToolchainLabel[]{"CMake Toolchain File"};
 const char fallbackDir[]{"/abc/def/fallback"};
 const char freeRtosCMakeVar[]{"FREERTOS_DIR"};
@@ -84,11 +87,13 @@ const char freeRtosSetting[]{"Freertos"};
 const char greenhillToolchainFilePath[]{"/opt/qtformcu/2.2/lib/cmake/Qul/toolchain/ghs.cmake"};
 const char greenhillCompilerDir[]{"/abs/ghs"};
 const char greenhillSetting[]{"GHSToolchain"};
+const QStringList greenhillVersions{{"2018.1.5"}};
 const char iarDir[]{"/opt/iar/compiler"};
 const char iarEnvVar[]{"IAR_ARM_COMPILER_DIR"};
 const char iarLabel[]{"IAR ARM Compiler"};
 const char iarSetting[]{"IARToolchain"};
 const char iarToolchainFilePath[]{"/opt/qtformcu/2.2/lib/cmake/Qul/toolchain/iar.cmake"};
+const QStringList iarVersions{{"8.50.9"}};
 const char iar[]{"iar"};
 const char id[]{"target_id"};
 const char name[]{"target_name"};
@@ -157,7 +162,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
     QCOMPARE(iarToolchain->detection(), ToolChain::UninitializedDetection);
 }
 
-void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage)
+void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QStringList &versions)
 {
     //Fake register and fake detect compiler.
     Id armGccId{ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID};
@@ -173,13 +178,14 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage)
     QCOMPARE(armGccPackage->toolChainName(), armGcc);
     QCOMPARE(armGccPackage->toolchainType(), McuToolChainPackage::ToolChainType::ArmGcc);
     QCOMPARE(armGccPackage->settingsKey(), armGccDirectorySetting);
+    QCOMPARE(armGccPackage->versions(), versions);
 
     // FIXME(piotr.mucko): Re-enable when toolchains retrieval from McuToolChainPackage is unified for arm and iar.
     // armToolchain = armGccPackage->toolChain(cxxLanguageId);
     // QVERIFY(armToolchain != nullptr);
 }
 
-void verifyGccToolchain(const McuToolChainPackagePtr &gccPackage)
+void verifyGccToolchain(const McuToolChainPackagePtr &gccPackage, const QStringList &versions)
 {
     QVERIFY(gccPackage != nullptr);
     QCOMPARE(gccPackage->cmakeVariableName(), "");
@@ -187,12 +193,14 @@ void verifyGccToolchain(const McuToolChainPackagePtr &gccPackage)
     QCOMPARE(gccPackage->isDesktopToolchain(), true);
     QCOMPARE(gccPackage->toolChainName(), unsupported);
     QCOMPARE(gccPackage->toolchainType(), McuToolChainPackage::ToolChainType::GCC);
+    QCOMPARE(gccPackage->versions(), versions);
 }
 
 void verifyTargetToolchains(const Targets &targets,
                             const QString &toolchainFilePath,
                             const QString &compilerPath,
-                            const QString &compilerSetting)
+                            const QString &compilerSetting,
+                            const QStringList &versions)
 {
     QCOMPARE(targets.size(), 1);
     const auto &target{targets.first()};
@@ -208,6 +216,7 @@ void verifyTargetToolchains(const Targets &targets,
     QCOMPARE(toolchainCompiler->cmakeVariableName(), Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE);
     QCOMPARE(toolchainCompiler->path().toString(), compilerPath);
     QCOMPARE(toolchainCompiler->settingsKey(), compilerSetting);
+    QCOMPARE(toolchainCompiler->versions(), versions);
 }
 
 McuSupportTest::McuSupportTest()
@@ -227,6 +236,7 @@ McuSupportTest::McuSupportTest()
                                                         {}, // validation path
                                                         armGccDirectorySetting,
                                                         McuToolChainPackage::ToolChainType::ArmGcc,
+                                                        {armGccVersion},
                                                         Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE,
                                                         armGccEnvVar}}
     , iarToolchainPackagePtr{new McuToolChainPackage{settingsMockPtr,
@@ -235,6 +245,7 @@ McuSupportTest::McuSupportTest()
                                                      {}, // validation path
                                                      iarSetting,
                                                      McuToolChainPackage::ToolChainType::IAR,
+                                                     {armGccVersion},
                                                      Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE,
                                                      iarEnvVar}}
     , platform{id, name, vendor}
@@ -371,7 +382,8 @@ void McuSupportTest::test_parseToolchainFromJSON()
 
 void McuSupportTest::test_legacy_createIarToolchain()
 {
-    McuToolChainPackagePtr iarToolchainPackage = Sdk::createIarToolChainPackage(settingsMockPtr);
+    McuToolChainPackagePtr iarToolchainPackage = Sdk::createIarToolChainPackage(settingsMockPtr,
+                                                                                iarVersions);
     verifyIarToolchain(iarToolchainPackage);
 }
 
@@ -385,30 +397,34 @@ void McuSupportTest::test_createIarToolchain()
 
 void McuSupportTest::test_legacy_createDesktopGccToolchain()
 {
-    McuToolChainPackagePtr gccPackage = Sdk::createGccToolChainPackage(settingsMockPtr);
+    McuToolChainPackagePtr gccPackage = Sdk::createGccToolChainPackage(settingsMockPtr,
-    verifyGccToolchain(gccPackage);
+                                                                       {armGccNewVersion});
+    verifyGccToolchain(gccPackage, {armGccNewVersion});
 }
 
 void McuSupportTest::test_createDesktopGccToolchain()
 {
     const auto description = Sdk::parseDescriptionJson(gcc_desktop_json);
     McuToolChainPackagePtr gccPackage{targetFactory.createToolchain(description.toolchain)};
-    verifyGccToolchain(gccPackage);
+    verifyGccToolchain(gccPackage, {});
 }
 
 void McuSupportTest::test_verifyManuallyCreatedArmGccToolchain()
 {
-    verifyArmGccToolchain(armGccToolchainPackagePtr);
+    verifyArmGccToolchain(armGccToolchainPackagePtr, {armGccVersion});
 }
 
 void McuSupportTest::test_legacy_createArmGccToolchain()
 {
-    McuToolChainPackagePtr armGccPackage = Sdk::createArmGccToolchainPackage(settingsMockPtr);
+    McuToolChainPackagePtr armGccPackage = Sdk::createArmGccToolchainPackage(settingsMockPtr,
-    verifyArmGccToolchain(armGccPackage);
+                                                                             {armGccVersion});
+    verifyArmGccToolchain(armGccPackage, {armGccVersion});
 }
 
 void McuSupportTest::test_createArmGccToolchain_data()
 {
+    QStringList versions{armGccVersion, armGccNewVersion};
+
     QTest::addColumn<QString>("json");
     QTest::newRow("armgcc_nxp_1050_json") << armgcc_nxp_1050_json;
     QTest::newRow("armgcc_stm32f769i_freertos_json") << armgcc_stm32f769i_freertos_json;
@@ -423,7 +439,7 @@ void McuSupportTest::test_createArmGccToolchain()
 
     const auto description = Sdk::parseDescriptionJson(json.toLocal8Bit());
     McuToolChainPackagePtr armGccPackage{targetFactory.createToolchain(description.toolchain)};
-    verifyArmGccToolchain(armGccPackage);
+    verifyArmGccToolchain(armGccPackage, description.toolchain.versions);
 }
 
 void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType_data()
@@ -681,7 +697,7 @@ void McuSupportTest::test_getFullToolchainFilePathFromTarget()
 void McuSupportTest::test_legacy_getPredefinedToolchainFilePackage()
 {
     QHash<QString, ToolchainCompilerCreator> toolchainCreators{
-        {armGcc, [this] { return armGccToolchainPackagePtr; }}};
+        {armGcc, [this](const QStringList & /*versions*/) { return armGccToolchainPackagePtr; }}};
     McuTargetFactoryLegacy legacyTargetFactory{toolchainCreators,
                                                {{armGcc, armGccToolchainFilePackagePtr}},
                                                {},
@@ -694,7 +710,7 @@ void McuSupportTest::test_legacy_getPredefinedToolchainFilePackage()
 void McuSupportTest::test_legacy_createUnsupportedToolchainFilePackage()
 {
     QHash<QString, ToolchainCompilerCreator> toolchainCreators{
-        {armGcc, [this] { return armGccToolchainPackagePtr; }}};
+        {armGcc, [this](const QStringList & /*versions*/) { return armGccToolchainPackagePtr; }}};
     McuTargetFactoryLegacy legacyTargetFactory{toolchainCreators,
                                                {{armGcc, armGccToolchainFilePackagePtr}},
                                                {},
@@ -713,20 +729,26 @@ void McuSupportTest::test_legacy_createTargetWithToolchainPackages_data()
     QTest::addColumn<QString>("toolchainFilePath");
     QTest::addColumn<QString>("compilerPath");
     QTest::addColumn<QString>("compilerSetting");
+    QTest::addColumn<QStringList>("versions");
 
     QTest::newRow("nxp1050") << armgcc_nxp_1050_json << armGccToolchainFilePath << armGccDir
-                             << armGccDirectorySetting;
+                             << armGccDirectorySetting
+                             << QStringList{armGccVersion, armGccNewVersion};
     QTest::newRow("stm32h750b") << armgcc_stm32h750b_metal_json << armGccToolchainFilePath
-                                << armGccDir << armGccDirectorySetting;
+                                << armGccDir << armGccDirectorySetting
+                                << QStringList{armGccVersion};
     QTest::newRow("stm32f769i") << armgcc_stm32f769i_freertos_json << armGccToolchainFilePath
-                                << armGccDir << armGccDirectorySetting;
+                                << armGccDir << armGccDirectorySetting
+                                << QStringList{armGccVersion, armGccNewVersion};
     QTest::newRow("stm32f469i") << iar_stm32f469i_metal_json << iarToolchainFilePath << iarDir
-                                << iarSetting;
+                                << iarSetting << iarVersions;
-    QTest::newRow("nxp1064") << iar_nxp_1064_json << iarToolchainFilePath << iarDir << iarSetting;
+    QTest::newRow("nxp1064") << iar_nxp_1064_json << iarToolchainFilePath << iarDir << iarSetting
-    QTest::newRow("nxp1064") << iar_nxp_1064_json << iarToolchainFilePath << iarDir << iarSetting;
+                             << iarVersions;
+    QTest::newRow("nxp1064") << iar_nxp_1064_json << iarToolchainFilePath << iarDir << iarSetting
+                             << iarVersions;
     QTest::newRow("ghs_rh850_d1m1a_baremetal_json")
         << ghs_rh850_d1m1a_baremetal_json << greenhillToolchainFilePath << greenhillCompilerDir
-        << greenhillSetting;
+        << greenhillSetting << greenhillVersions;
 }
 
 void McuSupportTest::test_legacy_createTargetWithToolchainPackages()
@@ -735,6 +757,7 @@ void McuSupportTest::test_legacy_createTargetWithToolchainPackages()
     QFETCH(QString, toolchainFilePath);
     QFETCH(QString, compilerPath);
     QFETCH(QString, compilerSetting);
+    QFETCH(QStringList, versions);
 
     const Sdk::McuTargetDescription description = Sdk::parseDescriptionJson(json.toLocal8Bit());
 
@@ -748,7 +771,7 @@ void McuSupportTest::test_legacy_createTargetWithToolchainPackages()
         Sdk::targetsFromDescriptions({description}, settingsMockPtr, qtForMcuSdkPath, runLegacy)};
     Q_UNUSED(packages);
 
-    verifyTargetToolchains(targets, toolchainFilePath, compilerPath, compilerSetting);
+    verifyTargetToolchains(targets, toolchainFilePath, compilerPath, compilerSetting, versions);
 }
 
 void McuSupportTest::test_createTargetWithToolchainPackages_data()
@@ -762,6 +785,10 @@ void McuSupportTest::test_createTargetWithToolchainPackages()
     QFETCH(QString, toolchainFilePath);
     QFETCH(QString, compilerPath);
     QFETCH(QString, compilerSetting);
+    QFETCH(QStringList, versions);
+
+    EXPECT_CALL(*settingsMockPtr, getPath(compilerSetting, _, _))
+        .WillRepeatedly(Return(FilePath::fromString(compilerPath)));
 
     EXPECT_CALL(*settingsMockPtr, getPath(compilerSetting, _, _))
         .WillRepeatedly(Return(FilePath::fromString(compilerPath)));
@@ -771,7 +798,7 @@ void McuSupportTest::test_createTargetWithToolchainPackages()
         Sdk::targetsFromDescriptions({description}, settingsMockPtr, qtForMcuSdkPath, !runLegacy)};
     Q_UNUSED(packages);
 
-    verifyTargetToolchains(targets, toolchainFilePath, compilerPath, compilerSetting);
+    verifyTargetToolchains(targets, toolchainFilePath, compilerPath, compilerSetting, versions);
 }
 
 void McuSupportTest::test_addToolchainFileInfoToKit()