Loader: Make Item::Module::LoadingItemInfo a proper class

To be extended in follow-up patches.
Also makes for more readable code.

Change-Id: I7a4841789fc8670d5509f912b70b35cc66c3ddeb
Reviewed-by: Ivan Komissarov <ABBAPOH@gmail.com>

3 files changed, 34 insertions, 17 deletions

diff --git a/src/lib/corelib/language/item.h b/src/lib/corelib/language/item.h
index aadf2516b..93b1f963a 100644
--- a/src/lib/corelib/language/item.h
+++ b/src/lib/corelib/language/item.h
@@ -85,11 +85,25 @@ public:
         Item *item = nullptr;
         ProductContext *product = nullptr; // Set if and only if the dep is a product.
 
-        // All items that declared an explicit dependency on this module. Can contain any
+        // All the sites that declared an explicit dependency on this module. Can contain any
         // number of module instances and at most one product.
         using ParametersWithPriority = std::pair<QVariantMap, int>;
-        using LoadingItemInfo = std::pair<Item *, ParametersWithPriority>;
-        std::vector<LoadingItemInfo> loadingItems;
+        struct LoadContext {
+            LoadContext(Item *loadingItem,
+                        const ParametersWithPriority &parameters)
+                : loadingItem(loadingItem), parameters(parameters) {}
+            LoadContext(Item *loadingItem, ParametersWithPriority &&parameters)
+                : loadingItem(loadingItem), parameters(std::move(parameters)) {}
+
+            LoadContext(const LoadContext &) = default;
+            LoadContext(LoadContext &&) = default;
+            LoadContext &operator=(const LoadContext &) = default;
+            LoadContext &operator=(LoadContext &&) = default;
+
+            Item *loadingItem;
+            ParametersWithPriority parameters;
+        };
+        std::vector<LoadContext> loadContexts;
 
         QVariantMap parameters;
         VersionRange versionRange;
diff --git a/src/lib/corelib/loader/dependenciesresolver.cpp b/src/lib/corelib/loader/dependenciesresolver.cpp
index 431abc9fe..f03988e5f 100644
--- a/src/lib/corelib/loader/dependenciesresolver.cpp
+++ b/src/lib/corelib/loader/dependenciesresolver.cpp
@@ -411,7 +411,7 @@ LoadModuleResult DependenciesResolver::loadModule(
     Item *moduleItem = nullptr;
 
     const auto addLoadingItem = [&](Item::Module &module, Item &loadingItem) {
-        module.loadingItems.emplace_back(&loadingItem,
+        module.loadContexts.emplace_back(&loadingItem,
                                          std::make_pair(dependency.parameters,
                                                         INT_MAX - dependsChainLength()));
     };
@@ -427,15 +427,16 @@ LoadModuleResult DependenciesResolver::loadModule(
 
         QBS_CHECK(existingModule->item);
         moduleItem = existingModule->item;
-        const auto matcher = [loadingItem](const Item::Module::LoadingItemInfo &info) {
-            return info.first == loadingItem;
+        const auto matcher = [loadingItem](const Item::Module::LoadContext &context) {
+            return context.loadingItem == loadingItem;
         };
-        const auto it = std::find_if(existingModule->loadingItems.begin(),
-                                     existingModule->loadingItems.end(), matcher);
-        if (it == existingModule->loadingItems.end())
+        const auto it = std::find_if(existingModule->loadContexts.begin(),
+                                     existingModule->loadContexts.end(), matcher);
+        if (it == existingModule->loadContexts.end())
             addLoadingItem(*existingModule, *loadingItem);
         else
-            it->second.first = mergeDependencyParameters(it->second.first, dependency.parameters);
+            it->parameters.first = mergeDependencyParameters(it->parameters.first,
+                                                             dependency.parameters);
     } else if (dependency.product) {
         productDep = dependency.product; // We have already done the look-up.
     } else if (!(productDep = findMatchingProduct(dependency))) {
diff --git a/src/lib/corelib/loader/productresolver.cpp b/src/lib/corelib/loader/productresolver.cpp
index f27e1bf37..a8d8adf2a 100644
--- a/src/lib/corelib/loader/productresolver.cpp
+++ b/src/lib/corelib/loader/productresolver.cpp
@@ -339,8 +339,8 @@ void ProductResolverStage1::updateModulePresentState(const Item::Module &module)
     if (!module.item->isPresentModule())
         return;
     bool hasPresentLoadingItem = false;
-    for (const auto &loadingItemInfo : module.loadingItems) {
-        const Item * const loadingItem = loadingItemInfo.first;
+    for (const Item::Module::LoadContext &loadContext : module.loadContexts) {
+        const Item * const loadingItem = loadContext.loadingItem;
         if (loadingItem == m_product.item) {
             hasPresentLoadingItem = true;
             break;
@@ -421,21 +421,23 @@ void ProductResolverStage1::mergeDependencyParameters()
                 ? module.product->defaultParameters
                 : m_loaderState.topLevelProject().parameters(module.item->prototype());
         priorityList.emplace_back(defaultParameters, INT_MIN);
-        for (const Item::Module::LoadingItemInfo &info : module.loadingItems) {
-            const QVariantMap &parameters = info.second.first;
+        for (const Item::Module::LoadContext &context : module.loadContexts) {
+            const QVariantMap &parameters = context.parameters.first;
 
             // Empty parameter maps and inactive loading modules do not contribute to the
             // final parameter map.
             if (parameters.isEmpty())
                 continue;
-            if (info.first->type() == ItemType::ModuleInstance && !info.first->isPresentModule())
+            if (context.loadingItem->type() == ItemType::ModuleInstance
+                    && !context.loadingItem->isPresentModule()) {
                 continue;
+            }
 
             // Build a list sorted by priority.
             static const auto cmp = [](const PP &elem, int prio) { return elem.second < prio; };
             const auto it = std::lower_bound(priorityList.begin(), priorityList.end(),
-                                             info.second.second, cmp);
-            priorityList.insert(it, info.second);
+                                             context.parameters.second, cmp);
+            priorityList.insert(it, context.parameters);
         }
 
         module.parameters = qbs::Internal::mergeDependencyParameters(std::move(priorityList));