diff options
Diffstat (limited to 'src/lib/corelib/language')
39 files changed, 5280 insertions, 4832 deletions
diff --git a/src/lib/corelib/language/astpropertiesitemhandler.cpp b/src/lib/corelib/language/astpropertiesitemhandler.cpp index b28fe7d76..cc4c02232 100644 --- a/src/lib/corelib/language/astpropertiesitemhandler.cpp +++ b/src/lib/corelib/language/astpropertiesitemhandler.cpp @@ -140,7 +140,7 @@ private: value->setFile(conditionalValue->file()); item->setProperty(propertyName, value); value->setSourceCode(StringConstants::baseVar()); - value->setSourceUsesBaseFlag(); + value->setSourceUsesBase(); } m_alternative.value = conditionalValue; value->addAlternative(m_alternative); diff --git a/src/lib/corelib/language/evaluator.cpp b/src/lib/corelib/language/evaluator.cpp index 5252f06be..fe3ee9db2 100644 --- a/src/lib/corelib/language/evaluator.cpp +++ b/src/lib/corelib/language/evaluator.cpp @@ -70,10 +70,9 @@ public: mutable QHash<QString, JSValue> valueCache; }; -static void convertToPropertyType_impl(ScriptEngine *engine, - const QString &pathPropertiesBaseDir, const Item *item, - const PropertyDeclaration& decl, - const CodeLocation &location, JSValue &v); +static void convertToPropertyType_impl( + ScriptEngine *engine, const QString &pathPropertiesBaseDir, const Item *item, + const PropertyDeclaration& decl, const Value *value, const CodeLocation &location, JSValue &v); static int getEvalPropertyNames(JSContext *ctx, JSPropertyEnum **ptab, uint32_t *plen, JSValueConst obj); static int getEvalProperty(JSContext *ctx, JSPropertyDescriptor *desc, @@ -202,7 +201,7 @@ bool Evaluator::isNonDefaultValue(const Item *item, const QString &name) const void Evaluator::convertToPropertyType(const PropertyDeclaration &decl, const CodeLocation &loc, JSValue &v) { - convertToPropertyType_impl(engine(), QString(), nullptr, decl, loc, v); + convertToPropertyType_impl(engine(), QString(), nullptr, decl, nullptr, loc, v); } JSValue Evaluator::scriptValue(const Item *item) @@ -223,7 +222,7 @@ JSValue Evaluator::scriptValue(const Item *item) return scriptValue; } -void Evaluator::onItemPropertyChanged(Item *item) +void Evaluator::clearCache(const Item *item) { const auto data = attachedPointer<EvaluationData>(m_scriptValueMap.value(item), m_scriptEngine->dataWithPtrClass()); @@ -309,13 +308,14 @@ static QString overriddenSourceDirectory(const Item *item, const QString &defaul static void convertToPropertyType_impl(ScriptEngine *engine, const QString &pathPropertiesBaseDir, const Item *item, const PropertyDeclaration& decl, - const CodeLocation &location, JSValue &v) + const Value *value, const CodeLocation &location, JSValue &v) { JSContext * const ctx = engine->context(); if (JS_IsUndefined(v) || JS_IsError(ctx, v) || JS_IsException(v)) return; QString srcDir; QString actualBaseDir; + const Item * const srcDirItem = value && value->scope() ? value->scope() : item; if (item && !pathPropertiesBaseDir.isEmpty()) { const VariantValueConstPtr itemSourceDir = item->variantProperty(QStringLiteral("sourceDirectory")); @@ -339,8 +339,8 @@ static void convertToPropertyType_impl(ScriptEngine *engine, makeTypeError(engine, decl, location, v); break; } - const QString srcDir = item ? overriddenSourceDirectory(item, actualBaseDir) - : pathPropertiesBaseDir; + const QString srcDir = srcDirItem ? overriddenSourceDirectory(srcDirItem, actualBaseDir) + : pathPropertiesBaseDir; if (!srcDir.isEmpty()) { v = engine->toScriptValue(QDir::cleanPath(FileInfo::resolvePath(srcDir, getJsString(ctx, v)))); @@ -353,8 +353,8 @@ static void convertToPropertyType_impl(ScriptEngine *engine, makeTypeError(engine, decl, location, v); break; case PropertyDeclaration::PathList: - srcDir = item ? overriddenSourceDirectory(item, actualBaseDir) - : pathPropertiesBaseDir; + srcDir = srcDirItem ? overriddenSourceDirectory(srcDirItem, actualBaseDir) + : pathPropertiesBaseDir; // Fall-through. case PropertyDeclaration::StringList: { @@ -565,56 +565,52 @@ private: setupConvenienceProperty(StringConstants::outerVar(), &extraScope, v); } if (value->sourceUsesOriginal()) { - JSValue originalValue = JS_UNDEFINED; + JSValue originalJs = JS_UNDEFINED; ScopedJsValue originalMgr(engine->context(), JS_UNDEFINED); if (data->item->propertyDeclaration(*propertyName).isScalar()) { const Item *item = itemOfProperty; - if (item->type() == ItemType::Module || item->type() == ItemType::Export) { - const QString errorMessage = Tr::tr("The special value 'original' cannot " - "be used on the right-hand side of a property declaration."); + + if (item->type() != ItemType::ModuleInstance) { + const QString errorMessage = Tr::tr("The special value 'original' can only " + "be used with module properties."); extraScope = throwError(engine->context(), errorMessage); result.second = false; return result; } - // TODO: Provide a dedicated item type for not-yet-instantiated things that - // look like module instances in the AST visitor. - if (item->type() == ItemType::ModuleInstance - && !item->hasProperty(StringConstants::presentProperty())) { - const QString errorMessage = Tr::tr("Trying to assign property '%1' " - "on something that is not a module.").arg(*propertyName); + if (!value->scope()) { + const QString errorMessage = Tr::tr("The special value 'original' cannot " + "be used on the right-hand side of a property declaration."); extraScope = throwError(engine->context(), errorMessage); result.second = false; return result; } - while (item->type() == ItemType::ModuleInstance) - item = item->prototype(); - if (item->type() != ItemType::Module && item->type() != ItemType::Export) { - const QString errorMessage = Tr::tr("The special value 'original' can only " - "be used with module properties."); - extraScope = throwError(engine->context(), errorMessage); - result.second = false; - return result; + ValuePtr original; + for (const ValuePtr &v : value->candidates()) { + if (!v->scope()) { + original = v; + break; + } } - const ValuePtr v = item->property(*propertyName); // This can happen when resolving shadow products. The error will be ignored // in that case. - if (!v) { + if (!original) { const QString errorMessage = Tr::tr("Error setting up 'original'."); extraScope = throwError(engine->context(), errorMessage); result.second = false; return result; } - SVConverter converter(engine, object, v, item, propertyName, data, &originalValue); + SVConverter converter(engine, object, original, item, propertyName, data, + &originalJs); converter.start(); } else { - originalValue = engine->newArray(0, JsValueOwner::Caller); - originalMgr.setValue(originalValue); + originalJs = engine->newArray(0, JsValueOwner::Caller); + originalMgr.setValue(originalJs); } - setupConvenienceProperty(StringConstants::originalVar(), &extraScope, originalValue); + setupConvenienceProperty(StringConstants::originalVar(), &extraScope, originalJs); } return result; } @@ -627,6 +623,13 @@ private: } } + void pushScopeRecursively(const Item *scope) + { + if (scope) { + pushScopeRecursively(scope->scope()); + pushScope(data->evaluator->scriptValue(scope)); + } + } void pushItemScopes(const Item *item) { const Item *scope = item->scope(); @@ -698,12 +701,11 @@ private: } pushScope(fileCtxScopes.fileScope); pushItemScopes(data->item); - if (itemOfProperty->type() != ItemType::ModuleInstance) { - // Own properties of module instances must not have the instance itself in the scope. + if ((itemOfProperty->type() != ItemType::ModuleInstance + && itemOfProperty->type() != ItemType::ModuleInstancePlaceholder) || !value->scope()) { pushScope(*object); } - if (value->definingItem()) - pushItemScopes(value->definingItem()); + pushScopeRecursively(value->scope()); pushScope(maybeExtraScope.first); pushScope(fileCtxScopes.importScope); if (alternative) { @@ -756,6 +758,16 @@ private: } }; +static void convertToPropertyType(ScriptEngine *engine, const Item *item, + const PropertyDeclaration& decl, const Value *value, JSValue &v) +{ + if (value->type() == Value::VariantValueType && JS_IsUndefined(v) && !decl.isScalar()) { + v = engine->newArray(0, JsValueOwner::ScriptEngine); // QTBUG-51237 + return; + } + convertToPropertyType_impl(engine, engine->evaluator()->pathPropertiesBaseDir(), item, decl, + value, value->location(), v); +} static QString resultToString(JSContext *ctx, const JSValue &scriptValue) { @@ -770,19 +782,15 @@ static QString resultToString(JSContext *ctx, const JSValue &scriptValue) return getJsVariant(ctx, scriptValue).toString(); } -static void collectValuesFromNextChain(ScriptEngine *engine, const EvaluationData *data, - JSValue *result, const QString &propertyName, - const ValuePtr &value) +static void collectValuesFromNextChain( + ScriptEngine *engine, JSValue obj, const ValuePtr &value, const Item *itemOfProperty, const QString &name, + const EvaluationData *data, JSValue *result) { JSValueList lst; - Set<Value *> ¤tNextChain = data->evaluator->currentNextChain(); - Set<Value *> oldNextChain = currentNextChain; - for (ValuePtr next = value; next; next = next->next()) - currentNextChain.insert(next.get()); - for (ValuePtr next = value; next; next = next->next()) { - ScopedJsValue v(engine->context(), - data->evaluator->property(next->definingItem(), propertyName)); + JSValue v = JS_UNDEFINED; + SVConverter svc(engine, &obj, next, itemOfProperty, &name, data, &v); + svc.start(); if (JsException ex = engine->checkAndClearException({})) { const ScopedJsValueList l(engine->context(), lst); *result = engine->throwError(ex.toErrorInfo().toString()); @@ -790,7 +798,9 @@ static void collectValuesFromNextChain(ScriptEngine *engine, const EvaluationDat } if (JS_IsUndefined(v)) continue; - lst.push_back(v.release()); + const PropertyDeclaration decl = data->item->propertyDeclaration(name); + convertToPropertyType(engine, data->item, decl, next.get(), v); + lst.push_back(JS_DupValue(engine->context(), v)); if (next->type() == Value::JSSourceValueType && std::static_pointer_cast<JSSourceValue>(next)->isExclusiveListValue()) { // TODO: Why on earth do we keep the last _2_ elements? @@ -803,7 +813,6 @@ static void collectValuesFromNextChain(ScriptEngine *engine, const EvaluationDat break; } } - currentNextChain = oldNextChain; *result = engine->newArray(int(lst.size()), JsValueOwner::ScriptEngine); quint32 k = 0; @@ -822,23 +831,17 @@ static void collectValuesFromNextChain(ScriptEngine *engine, const EvaluationDat setJsProperty(ctx, *result, StringConstants::lengthProperty(), JS_NewInt32(ctx, k)); } -static void convertToPropertyType(ScriptEngine *engine, const Item *item, - const PropertyDeclaration& decl, const Value *value, JSValue &v) -{ - if (value->type() == Value::VariantValueType && JS_IsUndefined(v) && !decl.isScalar()) { - v = engine->newArray(0, JsValueOwner::ScriptEngine); // QTBUG-51237 - return; - } - convertToPropertyType_impl(engine, engine->evaluator()->pathPropertiesBaseDir(), item, decl, - value->location(), v); -} - struct EvalResult { JSValue v = JS_UNDEFINED; bool found = false; }; static EvalResult getEvalProperty(ScriptEngine *engine, JSValue obj, const Item *item, const QString &name, const EvaluationData *data) { Evaluator * const evaluator = data->evaluator; + const bool isModuleInstance = item->type() == ItemType::ModuleInstance; for (; item; item = item->prototype()) { + if (isModuleInstance + && (item->type() == ItemType::Module || item->type() == ItemType::Export)) { + break; // There's no property in a prototype that's not also in the instance. + } const ValuePtr value = item->ownProperty(name); if (!value) continue; @@ -857,8 +860,8 @@ static EvalResult getEvalProperty(ScriptEngine *engine, JSValue obj, const Item } } - if (value->next() && !evaluator->currentNextChain().contains(value.get())) { - collectValuesFromNextChain(engine, data, &result, name, value); + if (value->next()) { + collectValuesFromNextChain(engine, obj, value, itemOfProperty, name, data, &result); } else { SVConverter converter(engine, &obj, value, itemOfProperty, &name, data, &result); converter.start(); diff --git a/src/lib/corelib/language/evaluator.h b/src/lib/corelib/language/evaluator.h index f7aee8e46..d791a4c5d 100644 --- a/src/lib/corelib/language/evaluator.h +++ b/src/lib/corelib/language/evaluator.h @@ -98,12 +98,12 @@ public: void setCachingEnabled(bool enabled) { m_valueCacheEnabled = enabled; } bool cachingEnabled() const { return m_valueCacheEnabled; } + void clearCache(const Item *item); PropertyDependencies &propertyDependencies() { return m_propertyDependencies; } void clearPropertyDependencies() { m_propertyDependencies.clear(); } std::stack<QualifiedId> &requestedProperties() { return m_requestedProperties; } - Set<Value *> ¤tNextChain() { return m_currentNextChain; } void handleEvaluationError(const Item *item, const QString &name); @@ -113,7 +113,7 @@ public: bool isNonDefaultValue(const Item *item, const QString &name) const; private: - void onItemPropertyChanged(Item *item) override; + void onItemPropertyChanged(Item *item) override { clearCache(item); } bool evaluateProperty(JSValue *result, const Item *item, const QString &name, bool *propertyWasSet); @@ -124,7 +124,6 @@ private: QString m_pathPropertiesBaseDir; PropertyDependencies m_propertyDependencies; std::stack<QualifiedId> m_requestedProperties; - Set<Value *> m_currentNextChain; bool m_valueCacheEnabled = false; }; @@ -134,12 +133,17 @@ void throwOnEvaluationError(ScriptEngine *engine, class EvalCacheEnabler { public: - EvalCacheEnabler(Evaluator *evaluator) : m_evaluator(evaluator) + EvalCacheEnabler(Evaluator *evaluator, const QString &baseDir) : m_evaluator(evaluator) { m_evaluator->setCachingEnabled(true); + m_evaluator->setPathPropertiesBaseDir(baseDir); } - ~EvalCacheEnabler() { m_evaluator->setCachingEnabled(false); } + ~EvalCacheEnabler() + { + m_evaluator->setCachingEnabled(false); + m_evaluator->clearPathPropertiesBaseDir(); + } private: Evaluator * const m_evaluator; diff --git a/src/lib/corelib/language/groupshandler.cpp b/src/lib/corelib/language/groupshandler.cpp new file mode 100644 index 000000000..b9acfc553 --- /dev/null +++ b/src/lib/corelib/language/groupshandler.cpp @@ -0,0 +1,320 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "groupshandler.h" + +#include "evaluator.h" +#include "item.h" +#include "moduleinstantiator.h" +#include "value.h" + +#include <logging/translator.h> +#include <tools/profiling.h> +#include <tools/setupprojectparameters.h> +#include <tools/stringconstants.h> + +namespace qbs::Internal { +class GroupsHandler::Private +{ +public: + Private(const SetupProjectParameters ¶meters, ModuleInstantiator &instantiator, + Evaluator &evaluator, Logger &logger) + : parameters(parameters), moduleInstantiator(instantiator), evaluator(evaluator), + logger(logger) {} + + void gatherAssignedProperties(ItemValue *iv, const QualifiedId &prefix, + QualifiedIdSet &properties); + void markModuleTargetGroups(Item *group, const Item::Module &module); + void moveGroupsFromModuleToProduct(Item *product, Item *productScope, + const Item::Module &module); + void moveGroupsFromModulesToProduct(Item *product, Item *productScope); + void propagateModulesFromParent(Item *group); + void handleGroup(Item *product, Item *group); + void adjustScopesInGroupModuleInstances(Item *groupItem, const Item::Module &module); + QualifiedIdSet gatherModulePropertiesSetInGroup(const Item *group); + + const SetupProjectParameters ¶meters; + ModuleInstantiator &moduleInstantiator; + Evaluator &evaluator; + Logger &logger; + std::unordered_map<const Item *, QualifiedIdSet> modulePropsSetInGroups; + Set<Item *> disabledGroups; + qint64 elapsedTime = 0; +}; + +GroupsHandler::GroupsHandler(const SetupProjectParameters ¶meters, + ModuleInstantiator &instantiator, Evaluator &evaluator, Logger &logger) + : d(new Private(parameters, instantiator, evaluator, logger)) {} +GroupsHandler::~GroupsHandler() { delete d; } + +void GroupsHandler::setupGroups(Item *product, Item *productScope) +{ + AccumulatingTimer timer(d->parameters.logElapsedTime() ? &d->elapsedTime : nullptr); + + d->modulePropsSetInGroups.clear(); + d->disabledGroups.clear(); + d->moveGroupsFromModulesToProduct(product, productScope); + for (Item * const child : product->children()) { + if (child->type() == ItemType::Group) + d->handleGroup(product, child); + } +} + +std::unordered_map<const Item *, QualifiedIdSet> GroupsHandler::modulePropertiesSetInGroups() const +{ + return d->modulePropsSetInGroups; +} + +Set<Item *> GroupsHandler::disabledGroups() const +{ + return d->disabledGroups; +} + +void GroupsHandler::printProfilingInfo(int indent) +{ + if (!d->parameters.logElapsedTime()) + return; + d->logger.qbsLog(LoggerInfo, true) << QByteArray(indent, ' ') + << Tr::tr("Setting up Groups took %1.") + .arg(elapsedTimeString(d->elapsedTime)); +} + +void GroupsHandler::Private::gatherAssignedProperties(ItemValue *iv, const QualifiedId &prefix, + QualifiedIdSet &properties) +{ + const Item::PropertyMap &props = iv->item()->properties(); + for (auto it = props.cbegin(); it != props.cend(); ++it) { + switch (it.value()->type()) { + case Value::JSSourceValueType: + properties << (QualifiedId(prefix) << it.key()); + break; + case Value::ItemValueType: + if (iv->item()->type() == ItemType::ModulePrefix) { + gatherAssignedProperties(std::static_pointer_cast<ItemValue>(it.value()).get(), + QualifiedId(prefix) << it.key(), properties); + } + break; + default: + break; + } + } +} + +void GroupsHandler::Private::markModuleTargetGroups(Item *group, const Item::Module &module) +{ + QBS_CHECK(group->type() == ItemType::Group); + if (evaluator.boolValue(group, StringConstants::filesAreTargetsProperty())) { + group->setProperty(StringConstants::modulePropertyInternal(), + VariantValue::create(module.name.toString())); + } + for (Item * const child : group->children()) + markModuleTargetGroups(child, module); +} + +void GroupsHandler::Private::moveGroupsFromModuleToProduct(Item *product, Item *productScope, + const Item::Module &module) +{ + if (!module.item->isPresentModule()) + return; + for (auto it = module.item->children().begin(); it != module.item->children().end();) { + Item * const child = *it; + if (child->type() != ItemType::Group) { + ++it; + continue; + } + child->setScope(productScope); + setScopeForDescendants(child, productScope); + Item::addChild(product, child); + markModuleTargetGroups(child, module); + it = module.item->children().erase(it); + } +} + +void GroupsHandler::Private::moveGroupsFromModulesToProduct(Item *product, Item *productScope) +{ + for (const Item::Module &module : product->modules()) + moveGroupsFromModuleToProduct(product, productScope, module); +} + +// TODO: I don't completely understand this function, and I suspect we do both too much +// and too little here. In particular, I'm not sure why we should even have to do anything +// with groups that don't attach properties. +// Set aside a day or two at some point to fully grasp all the details and rewrite accordingly. +void GroupsHandler::Private::propagateModulesFromParent(Item *group) +{ + QBS_CHECK(group->type() == ItemType::Group); + QHash<QualifiedId, Item *> moduleInstancesForGroup; + + // Step 1: "Instantiate" the product's modules for the group. + for (Item::Module m : group->parent()->modules()) { + Item * const targetItem = moduleInstantiator.retrieveModuleInstanceItem(group, m.name); + QBS_CHECK(targetItem->type() == ItemType::ModuleInstancePlaceholder); + targetItem->setPrototype(m.item); + + Item * const moduleScope = Item::create(targetItem->pool(), ItemType::Scope); + moduleScope->setFile(group->file()); + moduleScope->setProperties(m.item->scope()->properties()); // "project", "product", ids + moduleScope->setScope(group); + targetItem->setScope(moduleScope); + + targetItem->setFile(m.item->file()); + + // "parent" should point to the group/artifact parent + targetItem->setParent(group->parent()); + + targetItem->setOuterItem(m.item); + + m.item = targetItem; + group->addModule(m); + moduleInstancesForGroup.insert(m.name, targetItem); + } + + // Step 2: Make the inter-module references point to the instances created in step 1. + for (const Item::Module &module : group->modules()) { + Item::Modules adaptedModules; + const Item::Modules &oldModules = module.item->prototype()->modules(); + for (Item::Module depMod : oldModules) { + depMod.item = moduleInstancesForGroup.value(depMod.name); + adaptedModules << depMod; + if (depMod.name.front() == module.name.front()) + continue; + const ItemValuePtr &modulePrefix = group->itemProperty(depMod.name.front()); + QBS_CHECK(modulePrefix); + module.item->setProperty(depMod.name.front(), modulePrefix); + } + module.item->setModules(adaptedModules); + } + + const QualifiedIdSet &propsSetInGroup = gatherModulePropertiesSetInGroup(group); + if (propsSetInGroup.empty()) + return; + modulePropsSetInGroups.insert(std::make_pair(group, propsSetInGroup)); + + // Step 3: Adapt scopes in values. This is potentially necessary if module properties + // get assigned on the group level. + for (const Item::Module &module : group->modules()) + adjustScopesInGroupModuleInstances(group, module); +} + +void GroupsHandler::Private::handleGroup(Item *product, Item *group) +{ + propagateModulesFromParent(group); + if (!evaluator.boolValue(group, StringConstants::conditionProperty())) + disabledGroups << group; + for (Item * const child : group->children()) { + if (child->type() == ItemType::Group) + handleGroup(product, child); + } +} + +void GroupsHandler::Private::adjustScopesInGroupModuleInstances(Item *groupItem, + const Item::Module &module) +{ + if (!module.item->isPresentModule()) + return; + + Item *modulePrototype = module.item->rootPrototype(); + QBS_CHECK(modulePrototype->type() == ItemType::Module + || modulePrototype->type() == ItemType::Export); + + const Item::PropertyDeclarationMap &propDecls = modulePrototype->propertyDeclarations(); + for (const auto &decl : propDecls) { + const QString &propName = decl.name(); + + // Nothing gets inherited for module properties assigned directly in the group. + // In particular, setting a list property overwrites the value from the product's + // (or parent group's) instance completely, rather than appending to it + // (concatenation happens via outer.concat()). + ValuePtr propValue = module.item->ownProperty(propName); + if (propValue) { + propValue->setScope(module.item->scope(), {}); + continue; + } + + // Find the nearest prototype instance that has the value assigned. + // The result is either an instance of a parent group (or the parent group's + // parent group and so on) or the instance of the product or the module prototype. + // In the latter case, we don't have to do anything. + const Item *instanceWithProperty = module.item; + do { + instanceWithProperty = instanceWithProperty->prototype(); + QBS_CHECK(instanceWithProperty); + propValue = instanceWithProperty->ownProperty(propName); + } while (!propValue); + QBS_CHECK(propValue); + + if (propValue->type() != Value::JSSourceValueType) + continue; + + if (propValue->scope()) + module.item->setProperty(propName, propValue->clone()); + } + + for (const ValuePtr &prop : module.item->properties()) { + if (prop->type() != Value::JSSourceValueType) { + QBS_CHECK(!prop->next()); + continue; + } + for (ValuePtr v = prop; v; v = v->next()) { + if (!v->scope()) + continue; + for (const Item::Module &module : groupItem->modules()) { + if (v->scope() == module.item->prototype()) { + v->setScope(module.item, {}); + break; + } + } + } + } +} + +QualifiedIdSet GroupsHandler::Private::gatherModulePropertiesSetInGroup(const Item *group) +{ + QualifiedIdSet propsSetInGroup; + const Item::PropertyMap &props = group->properties(); + for (auto it = props.cbegin(); it != props.cend(); ++it) { + if (it.value()->type() == Value::ItemValueType) { + gatherAssignedProperties(std::static_pointer_cast<ItemValue>(it.value()).get(), + QualifiedId(it.key()), propsSetInGroup); + } + } + return propsSetInGroup; +} + +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/modulemerger.h b/src/lib/corelib/language/groupshandler.h index 469dc86c4..d3948cbef 100644 --- a/src/lib/corelib/language/modulemerger.h +++ b/src/lib/corelib/language/groupshandler.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2023 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of Qbs. @@ -37,53 +37,48 @@ ** ****************************************************************************/ -#ifndef QBS_MODULEMERGER_H -#define QBS_MODULEMERGER_H +#pragma once -#include "item.h" #include "qualifiedid.h" -#include <logging/logger.h> #include <tools/set.h> -#include <tools/version.h> -#include <QtCore/qhash.h> +#include <unordered_map> +#include <utility> namespace qbs { +class SetupProjectParameters; namespace Internal { +class Evaluator; +class Item; +class Logger; +class ModuleInstantiator; -class ModuleMerger { +// Sets up Group items for the actual resolving stage. Responsibilities: +// - Moving Group items located in modules over to the product. +// - Identifying groups declaring target artifacts and marking them accordingly. +// - Setting up group-level module instances to ensure proper resolving of per-group module +// properties. +// - As a side effect of the above point, collecting all properties set on the Group level +// to help the ProjectResolver decide which properties need to be re-evaluated at all, +// which is an important optimization (see commit 9cd8653eef). +class GroupsHandler +{ public: - static void merge(Logger &logger, Item *productItem, const QString &productName, - Item::Modules *topSortedModules); + GroupsHandler(const SetupProjectParameters ¶meters, ModuleInstantiator &instantiator, + Evaluator &evaluator, Logger &logger); + ~GroupsHandler(); -private: - ModuleMerger(Logger &logger, Item *productItem, const QString &productName, - const Item::Modules::iterator &modulesBegin, - const Item::Modules::iterator &modulesEnd); - - void appendPrototypeValueToNextChain(Item *moduleProto, const QString &propertyName, - const ValuePtr &sv); - void mergeModule(Item::PropertyMap *props, const Item::Module &m); - void replaceItemInValues(QualifiedId moduleName, Item *containerItem, Item *toReplace); - void start(); + void setupGroups(Item *product, Item *productScope); + std::unordered_map<const Item *, QualifiedIdSet> modulePropertiesSetInGroups() const; + Set<Item *> disabledGroups() const; - static ValuePtr lastInNextChain(const ValuePtr &v); - static const Item::Module *findModule(const Item *item, const QualifiedId &name); + void printProfilingInfo(int indent); - Logger &m_logger; - Item * const m_productItem; - Item::Module &m_mergedModule; - Item *m_clonedModulePrototype = nullptr; - Set<const Item *> m_seenInstances; - Set<Item *> m_moduleInstanceContainers; - const bool m_isBaseModule; - const bool m_isShadowProduct; - const Item::Modules::iterator m_modulesBegin; - const Item::Modules::iterator m_modulesEnd; +private: + class Private; + Private * const d; }; } // namespace Internal } // namespace qbs - -#endif // QBS_MODULEMERGER_H diff --git a/src/lib/corelib/language/item.cpp b/src/lib/corelib/language/item.cpp index c58d2058d..aa4f2ce00 100644 --- a/src/lib/corelib/language/item.cpp +++ b/src/lib/corelib/language/item.cpp @@ -47,6 +47,7 @@ #include "value.h" #include <api/languageinfo.h> +#include <logging/categories.h> #include <logging/logger.h> #include <logging/translator.h> #include <tools/error.h> @@ -103,11 +104,20 @@ Item *Item::clone() const return dup; } +Item *Item::rootPrototype() +{ + Item *proto = this; + while (proto->prototype()) + proto = proto->prototype(); + return proto; +} + QString Item::typeName() const { switch (type()) { case ItemType::IdScope: return QStringLiteral("[IdScope]"); case ItemType::ModuleInstance: return QStringLiteral("[ModuleInstance]"); + case ItemType::ModuleInstancePlaceholder: return QStringLiteral("[ModuleInstancePlaceholder]"); case ItemType::ModuleParameters: return QStringLiteral("[ModuleParametersInstance]"); case ItemType::ModulePrefix: return QStringLiteral("[ModulePrefix]"); case ItemType::Outer: return QStringLiteral("[Outer]"); @@ -216,9 +226,23 @@ PropertyDeclaration Item::propertyDeclaration(const QString &name, bool allowExp void Item::addModule(const Item::Module &module) { - const auto it = std::lower_bound(m_modules.begin(), m_modules.end(), module); - QBS_CHECK(it == m_modules.end() || (module.name != it->name && module.item != it->item)); - m_modules.insert(it, module); + if (!qEnvironmentVariableIsEmpty("QBS_SANITY_CHECKS")) { + QBS_CHECK(none_of(m_modules, [&](const Module &m) { + if (m.name != module.name) + return false; + if (!!module.productInfo != !!m.productInfo) + return true; + if (!module.productInfo) + return true; + if (module.productInfo->multiplexId == m.productInfo->multiplexId + && module.productInfo->profile == m.productInfo->profile) { + return true; + } + return false; + })); + } + + m_modules.push_back(module); } void Item::setObserver(ItemObserver *observer) const @@ -275,6 +299,15 @@ void Item::copyProperty(const QString &propertyName, Item *target) const target->setProperty(propertyName, property(propertyName)); } +void Item::overrideProperties(const QVariantMap &config, const QString &key, + const SetupProjectParameters ¶meters, Logger &logger) +{ + const QVariant configMap = config.value(key); + if (configMap.isNull()) + return; + overrideProperties(configMap.toMap(), QualifiedId(key), parameters, logger); +} + static const char *valueType(const Value *v) { switch (v->type()) { @@ -390,9 +423,37 @@ void Item::overrideProperties( handlePropertyError(error, parameters, logger); continue; } - setProperty(it.key(), - VariantValue::create(PropertyDeclaration::convertToPropertyType( - it.value(), decl.type(), namePrefix, it.key()))); + const auto overridenValue = VariantValue::create(PropertyDeclaration::convertToPropertyType( + it.value(), decl.type(), namePrefix, it.key())); + overridenValue->markAsSetByCommandLine(); + setProperty(it.key(), overridenValue); + } +} + +void Item::setModules(const Modules &modules) +{ + m_modules = modules; +} + +Item *createNonPresentModule(ItemPool &pool, const QString &name, const QString &reason, Item *module) +{ + qCDebug(lcModuleLoader) << "Non-required module '" << name << "' not loaded (" << reason << ")." + << "Creating dummy module for presence check."; + if (!module) { + module = Item::create(&pool, ItemType::ModuleInstance); + module->setFile(FileContext::create()); + module->setProperty(StringConstants::nameProperty(), VariantValue::create(name)); + } + module->setType(ItemType::ModuleInstance); + module->setProperty(StringConstants::presentProperty(), VariantValue::falseValue()); + return module; +} + +void setScopeForDescendants(Item *item, Item *scope) +{ + for (Item * const child : item->children()) { + child->setScope(scope); + setScopeForDescendants(child, scope); } } diff --git a/src/lib/corelib/language/item.h b/src/lib/corelib/language/item.h index 60d74a3f4..337cad78a 100644 --- a/src/lib/corelib/language/item.h +++ b/src/lib/corelib/language/item.h @@ -53,6 +53,7 @@ #include <QtCore/qlist.h> #include <QtCore/qmap.h> +#include <optional> #include <vector> namespace qbs { @@ -75,18 +76,29 @@ class QBS_AUTOTEST_EXPORT Item : public QbsQmlJS::Managed public: struct Module { - Module() - : item(nullptr), isProduct(false), required(true) - {} - QualifiedId name; - Item *item; - bool isProduct; - bool requiredValue = true; // base value of the required prop - bool required; - bool fallbackEnabled = true; + Item *item = nullptr; + struct ProductInfo { + ProductInfo(Item *i, const QString &m, const QString &p) + : item(i), multiplexId(m), profile(p) {} + Item *item = nullptr; + QString multiplexId; + QString profile; + }; + std::optional<ProductInfo> productInfo; // Set if and only if the dep is a product. + + // All items that declared an explicit dependency on this module. Can contain any + // number of module instances and at most one product. + std::vector<Item *> loadingItems; + QVariantMap parameters; VersionRange versionRange; + + // The shorter this value, the "closer to the product" we consider the module, + // and the higher its precedence is when merging property values. + int maxDependsChainLength = 0; + + bool required = true; }; using Modules = std::vector<Module>; using PropertyDeclarationMap = QMap<QString, PropertyDeclaration>; @@ -99,19 +111,27 @@ public: const QString &id() const { return m_id; } const CodeLocation &location() const { return m_location; } Item *prototype() const { return m_prototype; } + Item *rootPrototype(); Item *scope() const { return m_scope; } Item *outerItem() const { return m_outerItem; } Item *parent() const { return m_parent; } const FileContextPtr &file() const { return m_file; } const QList<Item *> &children() const { return m_children; } + QList<Item *> &children() { return m_children; } Item *child(ItemType type, bool checkForMultiple = true) const; const PropertyMap &properties() const { return m_properties; } + PropertyMap &properties() { return m_properties; } const PropertyDeclarationMap &propertyDeclarations() const { return m_propertyDeclarations; } PropertyDeclaration propertyDeclaration(const QString &name, bool allowExpired = true) const; + + // The list of modules is ordered such that dependencies appear before the modules + // depending on them. const Modules &modules() const { return m_modules; } + Modules &modules() { return m_modules; } + void addModule(const Module &module); void removeModules() { m_modules.clear(); } - void setModules(const Modules &modules) { m_modules = modules; } + void setModules(const Modules &modules); ItemType type() const { return m_type; } void setType(ItemType type) { m_type = type; } @@ -149,6 +169,11 @@ public: void copyProperty(const QString &propertyName, Item *target) const; void overrideProperties( const QVariantMap &config, + const QString &key, + const SetupProjectParameters ¶meters, + Logger &logger); + void overrideProperties( + const QVariantMap &config, const QualifiedId &namePrefix, const SetupProjectParameters ¶meters, Logger &logger); @@ -178,6 +203,10 @@ private: inline bool operator<(const Item::Module &m1, const Item::Module &m2) { return m1.name < m2.name; } +Item *createNonPresentModule(ItemPool &pool, const QString &name, const QString &reason, + Item *module); +void setScopeForDescendants(Item *item, Item *scope); + } // namespace Internal } // namespace qbs diff --git a/src/lib/corelib/language/itemreader.cpp b/src/lib/corelib/language/itemreader.cpp index a29b36320..8fcda8f24 100644 --- a/src/lib/corelib/language/itemreader.cpp +++ b/src/lib/corelib/language/itemreader.cpp @@ -39,9 +39,14 @@ #include "itemreader.h" +#include "deprecationinfo.h" +#include "evaluator.h" +#include "item.h" #include "itemreadervisitorstate.h" +#include "value.h" #include <tools/profiling.h> +#include <tools/stringconstants.h> #include <tools/stlutils.h> #include <QtCore/qfileinfo.h> @@ -148,5 +153,72 @@ void ItemReader::setDeprecationWarningMode(DeprecationWarningMode mode) m_visitorState->setDeprecationWarningMode(mode); } +void ItemReader::handlePropertyOptions(Item *optionsItem, Evaluator &evaluator) +{ + const QString name = evaluator.stringValue(optionsItem, StringConstants::nameProperty()); + if (name.isEmpty()) { + throw ErrorInfo(Tr::tr("PropertyOptions item needs a name property"), + optionsItem->location()); + } + const QString description = evaluator.stringValue( + optionsItem, StringConstants::descriptionProperty()); + const auto removalVersion = Version::fromString( + evaluator.stringValue(optionsItem, StringConstants::removalVersionProperty())); + const auto allowedValues = evaluator.stringListValue( + optionsItem, StringConstants::allowedValuesProperty()); + + PropertyDeclaration decl = optionsItem->parent()->propertyDeclaration(name); + if (!decl.isValid()) { + decl.setName(name); + decl.setType(PropertyDeclaration::Variant); + } + decl.setDescription(description); + if (removalVersion.isValid()) { + DeprecationInfo di(removalVersion, description); + decl.setDeprecationInfo(di); + } + decl.setAllowedValues(allowedValues); + const ValuePtr property = optionsItem->parent()->property(name); + if (!property && !decl.isExpired()) { + throw ErrorInfo(Tr::tr("PropertyOptions item refers to non-existing property '%1'") + .arg(name), optionsItem->location()); + } + if (property && decl.isExpired()) { + ErrorInfo e(Tr::tr("Property '%1' was scheduled for removal in version %2, but " + "is still present.") + .arg(name, removalVersion.toString()), + property->location()); + e.append(Tr::tr("Removal version for '%1' specified here.").arg(name), + optionsItem->location()); + m_visitorState->logger().printWarning(e); + } + optionsItem->parent()->setPropertyDeclaration(name, decl); +} + +void ItemReader::handleAllPropertyOptionsItems(Item *item, Evaluator &evaluator) +{ + QList<Item *> childItems = item->children(); + auto childIt = childItems.begin(); + while (childIt != childItems.end()) { + Item * const child = *childIt; + if (child->type() == ItemType::PropertyOptions) { + handlePropertyOptions(child, evaluator); + childIt = childItems.erase(childIt); + } else { + handleAllPropertyOptionsItems(child, evaluator); + ++childIt; + } + } + item->setChildren(childItems); +} + +Item *ItemReader::setupItemFromFile( + const QString &filePath, const CodeLocation &referencingLocation, Evaluator &evaluator) +{ + Item *item = readFile(filePath, referencingLocation); + handleAllPropertyOptionsItems(item, evaluator); + return item; +} + } // namespace Internal } // namespace qbs diff --git a/src/lib/corelib/language/itemreader.h b/src/lib/corelib/language/itemreader.h index 6b2531cf2..0ca845a00 100644 --- a/src/lib/corelib/language/itemreader.h +++ b/src/lib/corelib/language/itemreader.h @@ -50,7 +50,7 @@ namespace qbs { namespace Internal { - +class Evaluator; class Item; class ItemPool; class ItemReaderVisitorState; @@ -79,8 +79,10 @@ public: void clearExtraSearchPathsStack(); const QStringList &allSearchPaths() const; - Item *readFile(const QString &filePath); - Item *readFile(const QString &filePath, const CodeLocation &referencingLocation); + // Parses a file, creates an item for it, generates PropertyDeclarations from + // PropertyOptions items and removes said items from the item tree. + Item *setupItemFromFile(const QString &filePath, const CodeLocation &referencingLocation, + Evaluator &evaluator); Set<QString> filesRead() const; @@ -90,6 +92,11 @@ public: void setDeprecationWarningMode(DeprecationWarningMode mode); private: + Item *readFile(const QString &filePath); + Item *readFile(const QString &filePath, const CodeLocation &referencingLocation); + void handlePropertyOptions(Item *optionsItem, Evaluator &evaluator); + void handleAllPropertyOptionsItems(Item *item, Evaluator &evaluator); + ItemPool *m_pool = nullptr; QStringList m_searchPaths; std::vector<QStringList> m_extraSearchPaths; diff --git a/src/lib/corelib/language/itemreaderastvisitor.cpp b/src/lib/corelib/language/itemreaderastvisitor.cpp index 721f24079..f43104836 100644 --- a/src/lib/corelib/language/itemreaderastvisitor.cpp +++ b/src/lib/corelib/language/itemreaderastvisitor.cpp @@ -268,7 +268,7 @@ bool ItemReaderASTVisitor::handleBindingRhs(AST::Statement *statement, QBS_CHECK(value); if (AST::cast<AST::Block *>(statement)) - value->m_flags |= JSSourceValue::HasFunctionForm; + value->setHasFunctionForm(); value->setFile(m_file); value->setSourceCode(textViewOf(m_file->content(), statement)); @@ -282,11 +282,11 @@ bool ItemReaderASTVisitor::handleBindingRhs(AST::Statement *statement, idsearch.add(StringConstants::originalVar(), &usesOriginal); idsearch.start(statement); if (usesBase) - value->m_flags |= JSSourceValue::SourceUsesBase; + value->setSourceUsesBase(); if (usesOuter) - value->m_flags |= JSSourceValue::SourceUsesOuter; + value->setSourceUsesOuter(); if (usesOriginal) - value->m_flags |= JSSourceValue::SourceUsesOriginal; + value->setSourceUsesOriginal(); return false; } diff --git a/src/lib/corelib/language/itemreaderastvisitor.h b/src/lib/corelib/language/itemreaderastvisitor.h index 963b78471..e8522efd6 100644 --- a/src/lib/corelib/language/itemreaderastvisitor.h +++ b/src/lib/corelib/language/itemreaderastvisitor.h @@ -88,7 +88,7 @@ private: Logger &m_logger; QHash<QStringList, QString> m_typeNameToFile; Item *m_item = nullptr; - ItemType m_instanceItemType = ItemType::ModuleInstance; + ItemType m_instanceItemType = ItemType::ModuleInstancePlaceholder; }; } // namespace Internal diff --git a/src/lib/corelib/language/itemreadervisitorstate.h b/src/lib/corelib/language/itemreadervisitorstate.h index 90f88cd5e..dc22cfb42 100644 --- a/src/lib/corelib/language/itemreadervisitorstate.h +++ b/src/lib/corelib/language/itemreadervisitorstate.h @@ -39,7 +39,6 @@ #ifndef QBS_ITEMREADERVISITORSTATE_H #define QBS_ITEMREADERVISITORSTATE_H -#include <logging/logger.h> #include <tools/deprecationwarningmode.h> #include <tools/set.h> @@ -51,6 +50,7 @@ namespace qbs { namespace Internal { class Item; class ItemPool; +class Logger; class ItemReaderVisitorState { @@ -58,6 +58,7 @@ public: ItemReaderVisitorState(Logger &logger); ~ItemReaderVisitorState(); + Logger &logger() { return m_logger; } Set<QString> filesRead() const { return m_filesRead; } Item *readFile(const QString &filePath, const QStringList &searchPaths, ItemPool *itemPool); diff --git a/src/lib/corelib/language/itemtype.h b/src/lib/corelib/language/itemtype.h index 465396f45..7e9900a5b 100644 --- a/src/lib/corelib/language/itemtype.h +++ b/src/lib/corelib/language/itemtype.h @@ -74,6 +74,7 @@ enum class ItemType { // Internal items created mainly by the module loader. IdScope, ModuleInstance, + ModuleInstancePlaceholder, ModuleParameters, ModulePrefix, Outer, diff --git a/src/lib/corelib/language/language.cpp b/src/lib/corelib/language/language.cpp index ecfe09d71..fe92caba9 100644 --- a/src/lib/corelib/language/language.cpp +++ b/src/lib/corelib/language/language.cpp @@ -41,6 +41,7 @@ #include "artifactproperties.h" #include "builtindeclarations.h" +#include "productitemmultiplexer.h" #include "propertymapinternal.h" #include "scriptengine.h" @@ -60,6 +61,7 @@ #include <tools/qbsassert.h> #include <tools/qttools.h> #include <tools/scripttools.h> +#include <tools/setupprojectparameters.h> #include <tools/stlutils.h> #include <tools/stringconstants.h> @@ -423,18 +425,9 @@ QString ResolvedProduct::uniqueName() const return uniqueName(name, multiplexConfigurationId); } -QString ResolvedProduct::fullDisplayName(const QString &name, - const QString &multiplexConfigurationId) -{ - QString result = name; - if (!multiplexConfigurationId.isEmpty()) - result.append(QLatin1Char(' ')).append(multiplexIdToString(multiplexConfigurationId)); - return result; -} - QString ResolvedProduct::fullDisplayName() const { - return fullDisplayName(name, multiplexConfigurationId); + return ProductItemMultiplexer::fullProductDisplayName(name, multiplexConfigurationId); } QString ResolvedProduct::profile() const @@ -617,6 +610,16 @@ void TopLevelProject::makeModuleProvidersNonTransient() m.transientOutput = false; } +QVariantMap TopLevelProject::fullProfileConfigsTree() const +{ + QVariantMap tree; + for (auto it = profileConfigs.cbegin(); it != profileConfigs.cend(); ++it) { + tree.insert(it.key(), SetupProjectParameters::finalBuildConfigurationTree( + it.value().toMap(), overriddenValues)); + } + return tree; +} + QString TopLevelProject::buildGraphFilePath() const { return ProjectBuildData::deriveBuildGraphFilePath(buildDirectory, id()); @@ -913,11 +916,6 @@ bool artifactPropertyListsAreEqual(const std::vector<ArtifactPropertiesPtr> &l1, return listsAreEqual(l1, l2); } -QString multiplexIdToString(const QString &id) -{ - return QString::fromUtf8(QByteArray::fromBase64(id.toUtf8())); -} - bool operator==(const PrivateScriptFunction &a, const PrivateScriptFunction &b) { return equals(a.m_sharedData.get(), b.m_sharedData.get()); diff --git a/src/lib/corelib/language/language.h b/src/lib/corelib/language/language.h index a1115519d..1dae572a1 100644 --- a/src/lib/corelib/language/language.h +++ b/src/lib/corelib/language/language.h @@ -361,7 +361,7 @@ public: static ResolvedModulePtr create() { return ResolvedModulePtr(new ResolvedModule); } QString name; - QStringList moduleDependencies; + QStringList moduleDependencies; // TODO: Still needed? PrivateScriptFunction setupBuildEnvironmentScript; PrivateScriptFunction setupRunEnvironmentScript; ResolvedProduct *product = nullptr; @@ -597,7 +597,6 @@ public: static QString uniqueName(const QString &name, const QString &multiplexConfigurationId); QString uniqueName() const; - static QString fullDisplayName(const QString &name, const QString &multiplexConfigurationId); QString fullDisplayName() const; QString profile() const; @@ -707,6 +706,7 @@ public: QString id() const { return m_id; } QString profile() const; void makeModuleProvidersNonTransient(); + QVariantMap fullProfileConfigsTree() const; // Tree-ified + overridden values QVariantMap profileConfigs; QVariantMap overriddenValues; @@ -737,8 +737,6 @@ private: bool artifactPropertyListsAreEqual(const std::vector<ArtifactPropertiesPtr> &l1, const std::vector<ArtifactPropertiesPtr> &l2); -QString multiplexIdToString(const QString &id); - } // namespace Internal } // namespace qbs diff --git a/src/lib/corelib/language/loader.cpp b/src/lib/corelib/language/loader.cpp index 1156b138b..00d944e5f 100644 --- a/src/lib/corelib/language/loader.cpp +++ b/src/lib/corelib/language/loader.cpp @@ -40,9 +40,10 @@ #include "loader.h" #include "evaluator.h" +#include "itempool.h" #include "language.h" -#include "moduleloader.h" #include "projectresolver.h" +#include "projecttreebuilder.h" #include "scriptengine.h" #include <logging/translator.h> @@ -149,15 +150,16 @@ TopLevelProjectPtr Loader::loadProject(const SetupProjectParameters &_parameters const FileTime resolveTime = FileTime::currentTime(); Evaluator evaluator(m_engine); - ModuleLoader moduleLoader(&evaluator, m_logger); - moduleLoader.setProgressObserver(m_progressObserver); - moduleLoader.setSearchPaths(m_searchPaths); - moduleLoader.setOldProjectProbes(m_oldProjectProbes); - moduleLoader.setOldProductProbes(m_oldProductProbes); - moduleLoader.setLastResolveTime(m_lastResolveTime); - moduleLoader.setStoredProfiles(m_storedProfiles); - moduleLoader.setStoredModuleProviderInfo(m_storedModuleProviderInfo); - const ModuleLoaderResult loadResult = moduleLoader.load(parameters); + ItemPool pool; + ProjectTreeBuilder projectTreeBuilder(parameters, pool, evaluator, m_logger); + projectTreeBuilder.setProgressObserver(m_progressObserver); + projectTreeBuilder.setSearchPaths(m_searchPaths); + projectTreeBuilder.setOldProjectProbes(m_oldProjectProbes); + projectTreeBuilder.setOldProductProbes(m_oldProductProbes); + projectTreeBuilder.setLastResolveTime(m_lastResolveTime); + projectTreeBuilder.setStoredProfiles(m_storedProfiles); + projectTreeBuilder.setStoredModuleProviderInfo(m_storedModuleProviderInfo); + const ProjectTreeBuilder::Result loadResult = projectTreeBuilder.load(); ProjectResolver resolver(&evaluator, loadResult, std::move(parameters), m_logger); resolver.setProgressObserver(m_progressObserver); TopLevelProjectPtr project = resolver.resolve(); diff --git a/src/lib/corelib/language/localprofiles.cpp b/src/lib/corelib/language/localprofiles.cpp new file mode 100644 index 000000000..1571ee15e --- /dev/null +++ b/src/lib/corelib/language/localprofiles.cpp @@ -0,0 +1,164 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "localprofiles.h" + +#include "evaluator.h" +#include "item.h" +#include "qualifiedid.h" +#include "scriptengine.h" +#include "value.h" + +#include <logging/translator.h> +#include <tools/profile.h> +#include <tools/scripttools.h> +#include <tools/stringconstants.h> + +namespace qbs::Internal { +class LocalProfiles::Private +{ +public: + Private(const SetupProjectParameters ¶meters, Evaluator &evaluator, Logger &logger) + : parameters(parameters), evaluator(evaluator), logger(logger) {} + + void handleProfile(Item *profileItem); + void evaluateProfileValues(const QualifiedId &namePrefix, Item *item, Item *profileItem, + QVariantMap &values); + void collectProfiles(Item *productOrProject, Item *projectScope); + + const SetupProjectParameters ¶meters; + Evaluator &evaluator; + Logger &logger; + QVariantMap profiles; +}; + +LocalProfiles::LocalProfiles(const SetupProjectParameters ¶meters, Evaluator &evaluator, + Logger &logger) + : d(new Private(parameters, evaluator, logger)) {} +LocalProfiles::~LocalProfiles() { delete d; } + +void LocalProfiles::collectProfilesFromItems(Item *productOrProject, Item *projectScope) +{ + d->collectProfiles(productOrProject, projectScope); +} + +const QVariantMap &LocalProfiles::profiles() const +{ + return d->profiles; +} + +void LocalProfiles::Private::handleProfile(Item *profileItem) +{ + QVariantMap values; + evaluateProfileValues(QualifiedId(), profileItem, profileItem, values); + const bool condition = values.take(StringConstants::conditionProperty()).toBool(); + if (!condition) + return; + const QString profileName = values.take(StringConstants::nameProperty()).toString(); + if (profileName.isEmpty()) + throw ErrorInfo(Tr::tr("Every Profile item must have a name"), profileItem->location()); + if (profileName == Profile::fallbackName()) { + throw ErrorInfo(Tr::tr("Reserved name '%1' cannot be used for an actual profile.") + .arg(profileName), profileItem->location()); + } + if (profiles.contains(profileName)) { + throw ErrorInfo(Tr::tr("Local profile '%1' redefined.").arg(profileName), + profileItem->location()); + } + profiles.insert(profileName, values); +} + +void LocalProfiles::Private::evaluateProfileValues(const QualifiedId &namePrefix, Item *item, + Item *profileItem, QVariantMap &values) +{ + const Item::PropertyMap &props = item->properties(); + for (auto it = props.begin(); it != props.end(); ++it) { + QualifiedId name = namePrefix; + name << it.key(); + switch (it.value()->type()) { + case Value::ItemValueType: + evaluateProfileValues(name, std::static_pointer_cast<ItemValue>(it.value())->item(), + profileItem, values); + break; + case Value::VariantValueType: + values.insert(name.join(QLatin1Char('.')), + std::static_pointer_cast<VariantValue>(it.value())->value()); + break; + case Value::JSSourceValueType: + if (item != profileItem) + item->setScope(profileItem); + const ScopedJsValue sv(evaluator.engine()->context(), + evaluator.value(item, it.key())); + values.insert(name.join(QLatin1Char('.')), + getJsVariant(evaluator.engine()->context(), sv)); + break; + } + } +} + +void LocalProfiles::Private::collectProfiles(Item *productOrProject, Item *projectScope) +{ + Item * scope = productOrProject->type() == ItemType::Project ? projectScope : nullptr; + for (auto it = productOrProject->children().begin(); + it != productOrProject->children().end();) { + Item * const childItem = *it; + if (childItem->type() == ItemType::Profile) { + if (!scope) { + const ItemValuePtr itemValue = ItemValue::create(productOrProject); + scope = Item::create(productOrProject->pool(), ItemType::Scope); + scope->setProperty(StringConstants::productVar(), itemValue); + scope->setFile(productOrProject->file()); + scope->setScope(projectScope); + } + childItem->setScope(scope); + try { + handleProfile(childItem); + } catch (const ErrorInfo &e) { + handlePropertyError(e, parameters, logger); + } + it = productOrProject->children().erase(it); // TODO: delete item and scope + } else { + if (childItem->type() == ItemType::Product) + collectProfiles(childItem, projectScope); + ++it; + } + } +} + +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/localprofiles.h b/src/lib/corelib/language/localprofiles.h new file mode 100644 index 000000000..3e6b77f4d --- /dev/null +++ b/src/lib/corelib/language/localprofiles.h @@ -0,0 +1,68 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#pragma once + +#include <QVariantMap> + +namespace qbs { +class SetupProjectParameters; +namespace Internal { +class Evaluator; +class Item; +class Logger; + +// This class evaluates all Profile items encountered in the project tree and holds the results. +class LocalProfiles +{ +public: + LocalProfiles(const SetupProjectParameters ¶meters, Evaluator &evaluator, Logger &logger); + ~LocalProfiles(); + + void collectProfilesFromItems(Item *productOrProject, Item *projectScope); + const QVariantMap &profiles() const; + +private: + class Private; + Private * const d; +}; + +} // namespace Internal +} // namespace qbs + diff --git a/src/lib/corelib/language/moduleinstantiator.cpp b/src/lib/corelib/language/moduleinstantiator.cpp new file mode 100644 index 000000000..91776213a --- /dev/null +++ b/src/lib/corelib/language/moduleinstantiator.cpp @@ -0,0 +1,337 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "moduleinstantiator.h" + +#include "item.h" +#include "itempool.h" +#include "modulepropertymerger.h" +#include "qualifiedid.h" +#include "value.h" + +#include <logging/logger.h> +#include <logging/translator.h> +#include <tools/profiling.h> +#include <tools/setupprojectparameters.h> +#include <tools/stringconstants.h> + +#include <utility> + +namespace qbs::Internal { +class ModuleInstantiator::Private +{ +public: + Private(const SetupProjectParameters ¶meters, ItemPool &itemPool, + ModulePropertyMerger &propertyMerger, Logger &logger) + : parameters(parameters), itemPool(itemPool), propertyMerger(propertyMerger), + logger(logger) {} + + void overrideProperties(const Context &context); + void setupScope(const Context &context); + void exchangePlaceholderItem(Item *product, Item *loadingItem, const QString &loadingName, + Item *moduleItemForItemValues, const QualifiedId &moduleName, const QString &id, + bool isProductDependency, bool alreadyLoaded); + std::pair<const Item *, Item *> + getOrSetModuleInstanceItem(Item *container, Item *moduleItem, const QualifiedId &moduleName, + const QString &id, bool replace); + + const SetupProjectParameters ¶meters; + ItemPool &itemPool; + ModulePropertyMerger &propertyMerger; + Logger &logger; + qint64 elapsedTime = 0; +}; + +ModuleInstantiator::ModuleInstantiator( + const SetupProjectParameters ¶meters, ItemPool &itemPool, + ModulePropertyMerger &propertyMerger, Logger &logger) + : d(new Private(parameters, itemPool, propertyMerger, logger)) {} +ModuleInstantiator::~ModuleInstantiator() { delete d; } + +void ModuleInstantiator::instantiate(const Context &context) +{ + AccumulatingTimer timer(d->parameters.logElapsedTime() ? &d->elapsedTime : nullptr); + + // This part needs to be done only once per module and product, and only if the module + // was successfully loaded. + if (context.module && !context.alreadyLoaded) { + context.module->setType(ItemType::ModuleInstance); + d->overrideProperties(context); + d->setupScope(context); + } + + // This strange-looking code deals with the fact that our syntax cannot properly handle + // dependencies on several multiplexed variants of the same product. + // See getOrSetModuleInstanceItem() below for details. + Item * const moduleItemForItemValues + = context.moduleWithSameName ? context.moduleWithSameName + : context.module; + + // Now attach the module instance as an item value to the loading item, potentially + // evicting a previously attached placeholder item and merging its values into the instance. + // Note that we potentially do this twice, once for the actual loading item and once + // for the product item, if the two are different. The reason is this: + // For convenience, in the product item we allow attaching to properties from indirectly + // loaded modules. For instance: + // Product { + // Depends { name: "Qt.core" } + // cpp.cxxLanguageVersion: "c++20" // Works even though there is no Depends item for cpp + // } + // It's debatable whether that's a good feature, but it has been working (accidentally?) + // for a long time, and removing it now would break a lot of existing projects. + d->exchangePlaceholderItem( + context.product, context.loadingItem, context.loadingName, moduleItemForItemValues, + context.moduleName, context.id, context.exportingProduct, context.alreadyLoaded); + + if (!context.alreadyLoaded && context.product && context.product != context.loadingItem) { + d->exchangePlaceholderItem( + context.product, context.product, context.productName, moduleItemForItemValues, + context.moduleName, context.id, context.exportingProduct, context.alreadyLoaded); + } +} + +void ModuleInstantiator::Private::exchangePlaceholderItem( + Item *product, Item *loadingItem, const QString &loadingName, Item *moduleItemForItemValues, + const QualifiedId &moduleName, const QString &id, bool isProductModule, bool alreadyLoaded) +{ + // If we have a module item, set an item value pointing to it as a property on the loading item. + // Evict a possibly existing placeholder item, and return it to us, so we can merge its values + // into the instance. + const auto &[oldItem, newItem] = getOrSetModuleInstanceItem( + loadingItem, moduleItemForItemValues, moduleName, id, true); + + // The new item always exists, even if we don't have a module item. In that case, the + // function created a placeholder item for us, which we then have to turn into a + // non-present module. + QBS_CHECK(newItem); + if (!moduleItemForItemValues) { + createNonPresentModule(itemPool, moduleName.toString(), QLatin1String("not found"), + newItem); + return; + } + + // If the old and the new items are the same, it means the existing item value already + // pointed to a module instance (rather than a placeholder). + // This can happen in two cases: + // a) Multiple identical Depends items on the same level (easily possible with inheritance). + // b) Dependencies to multiplexed variants of the same product + // (see getOrSetModuleInstanceItem() below for details). + if (oldItem == newItem) { + QBS_CHECK(oldItem->type() == ItemType::ModuleInstance); + QBS_CHECK(alreadyLoaded || isProductModule); + return; + } + + // In all other cases, our request to set the module instance item must have been honored. + QBS_CHECK(newItem == moduleItemForItemValues); + + // If there was no placeholder item, we don't have to merge any values and are done. + if (!oldItem) + return; + + // If an item was replaced, then it must have been a placeholder. + QBS_CHECK(oldItem->type() == ItemType::ModuleInstancePlaceholder); + + // Prevent setting read-only properties. + for (auto it = oldItem->properties().cbegin(); it != oldItem->properties().cend(); ++it) { + const PropertyDeclaration &pd = moduleItemForItemValues->propertyDeclaration(it.key()); + if (pd.flags().testFlag(PropertyDeclaration::ReadOnlyFlag)) { + throw ErrorInfo(Tr::tr("Cannot set read-only property '%1'.").arg(pd.name()), + it.value()->location()); + } + } + + // Now merge the locally attached values into the actual module instance. + propertyMerger.mergeFromLocalInstance(product, loadingItem, loadingName, + oldItem, moduleItemForItemValues); + + // TODO: We'd like to delete the placeholder item here, because it's not + // being referenced anymore and there's a lot of them. However, this + // is not supported by ItemPool. Investigate the use of std::pmr. +} + +Item *ModuleInstantiator::retrieveModuleInstanceItem(Item *containerItem, const QualifiedId &name) +{ + return d->getOrSetModuleInstanceItem(containerItem, nullptr, name, {}, false).second; +} + +Item *ModuleInstantiator::retrieveQbsItem(Item *containerItem) +{ + return retrieveModuleInstanceItem(containerItem, StringConstants::qbsModule()); +} + +// This important function deals with retrieving and setting (pseudo-)module instances from/on +// items. +// Use case 1: Suppose we resolve the dependency cpp in module Qt.core, which also contains +// property bindings for cpp such as "cpp.defines: [...]". +// The "cpp" part of this binding is represented by an ItemValue whose +// item is of type ModuleInstancePlaceholder, originally set up by ItemReaderASTVisitor. +// This function will be called with the actual cpp module item and will +// replace the placeholder item in the item value. It will also return +// the placeholder item for subsequent merging of its properties with the +// ones of the actual module (in ModulePropertyMerger::mergeFromLocalInstance()). +// If there were no cpp property bindings defined in Qt.core, then we'd still +// have to replace the placeholder item, because references to "cpp" on the +// right-hand-side of other properties must refer to the module item. +// This is the common use of this function as employed by resolveProdsucDependencies(). +// Note that if a product has dependencies on more than one variant of a multiplexed +// product, these dependencies are competing for the item value property name, +// i.e. this case is not properly supported by the syntax. You must therefore not +// export properties from multiplexed products that will be different between the +// variants. In this function, the condition manifests itself by a module instance +// being encountered instead of a module instance placeholder, in which case +// nothing is done at all. +// Use case 2: We inject a fake qbs module into a project item, so qbs properties set in profiles +// can be accessed in the project level. Doing this is discouraged, and the +// functionality is kept mostly for backwards compatibility. The moduleItem +// parameter is null in this case, and the item will be created by the function itself. +// Use case 3: A temporary qbs module is attached to a product during low-level setup, namely +// in product multiplexing and setting qbs.profile. +// Use case 4: Module propagation to the the Group level. +// In all cases, the first returned item is the existing one, and the second returned item +// is the new one. Depending on the use case, they might be null and might also be the same item. +std::pair<const Item *, Item *> ModuleInstantiator::Private::getOrSetModuleInstanceItem( + Item *container, Item *moduleItem, const QualifiedId &moduleName, const QString &id, + bool replace) +{ + Item *instance = container; + const QualifiedId itemValueName + = !id.isEmpty() ? QualifiedId::fromString(id) : moduleName; + for (int i = 0; i < itemValueName.size(); ++i) { + const QString &moduleNameSegment = itemValueName.at(i); + const ValuePtr v = instance->ownProperty(itemValueName.at(i)); + if (v && v->type() == Value::ItemValueType) { + ItemValue * const itemValue = std::static_pointer_cast<ItemValue>(v).get(); + instance = itemValue->item(); + if (i == itemValueName.size() - 1) { + if (replace && instance != moduleItem + && instance->type() == ItemType::ModuleInstancePlaceholder) { + if (!moduleItem) + moduleItem = Item::create(&itemPool, ItemType::ModuleInstancePlaceholder); + itemValue->setItem(moduleItem); + } + return {instance, itemValue->item()}; + } + } else { + Item *newItem = i < itemValueName.size() - 1 + ? Item::create(&itemPool, ItemType::ModulePrefix) : moduleItem + ? moduleItem : Item::create(&itemPool, ItemType::ModuleInstancePlaceholder); + instance->setProperty(moduleNameSegment, ItemValue::create(newItem)); + instance = newItem; + } + } + return {nullptr, instance}; +} + +void ModuleInstantiator::printProfilingInfo(int indent) +{ + if (!d->parameters.logElapsedTime()) + return; + d->logger.qbsLog(LoggerInfo, true) << QByteArray(indent, ' ') + << Tr::tr("Instantiating modules took %1.") + .arg(elapsedTimeString(d->elapsedTime)); +} + +void ModuleInstantiator::Private::overrideProperties(const ModuleInstantiator::Context &context) +{ + // Users can override module properties on the command line with the + // modules.<module-name>.<property-name>:<value> syntax. + // For simplicity and backwards compatibility, qbs properties can also be given without + // the "modules." prefix, i.e. just qbs.<property-name>:<value>. + // In addition, users can override module properties just for certain products + // using the products.<product-name>.<module-name>.<property-name>:<value> syntax. + // Such product-specific overrides have higher precedence. + const QString fullName = context.moduleName.toString(); + const QString generalOverrideKey = QStringLiteral("modules.") + fullName; + const QString perProductOverrideKey = StringConstants::productsOverridePrefix() + + context.productName + QLatin1Char('.') + fullName; + context.module->overrideProperties(parameters.overriddenValuesTree(), generalOverrideKey, + parameters, logger); + if (fullName == StringConstants::qbsModule()) { + context.module->overrideProperties(parameters.overriddenValuesTree(), fullName, parameters, + logger); + } + context.module->overrideProperties(parameters.overriddenValuesTree(), perProductOverrideKey, + parameters, logger); +} + +void ModuleInstantiator::Private::setupScope(const ModuleInstantiator::Context &context) +{ + Item * const scope = Item::create(&itemPool, ItemType::Scope); + QBS_CHECK(context.module->file()); + scope->setFile(context.module->file()); + QBS_CHECK(context.projectScope); + context.projectScope->copyProperty(StringConstants::projectVar(), scope); + if (context.productScope) + context.productScope->copyProperty(StringConstants::productVar(), scope); + else + QBS_CHECK(context.moduleName.toString() == StringConstants::qbsModule()); // Dummy product. + + if (!context.module->id().isEmpty()) + scope->setProperty(context.module->id(), ItemValue::create(context.module)); + for (Item * const child : context.module->children()) { + child->setScope(scope); + if (!child->id().isEmpty()) + scope->setProperty(child->id(), ItemValue::create(child)); + } + context.module->setScope(scope); + + if (context.exportingProduct) { + QBS_CHECK(context.exportingProduct->type() == ItemType::Product); + + const auto exportingProductItemValue = ItemValue::create(context.exportingProduct); + scope->setProperty(QStringLiteral("exportingProduct"), exportingProductItemValue); + + const auto importingProductItemValue = ItemValue::create(context.product); + scope->setProperty(QStringLiteral("importingProduct"), importingProductItemValue); + + // FIXME: This looks wrong. Introduce exportingProject variable? + scope->setProperty(StringConstants::projectVar(), + ItemValue::create(context.exportingProduct->parent())); + + PropertyDeclaration pd(StringConstants::qbsSourceDirPropertyInternal(), + PropertyDeclaration::String, QString(), + PropertyDeclaration::PropertyNotAvailableInConfig); + context.module->setPropertyDeclaration(pd.name(), pd); + context.module->setProperty(pd.name(), context.exportingProduct->property( + StringConstants::sourceDirectoryProperty())); + } +} + +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/moduleinstantiator.h b/src/lib/corelib/language/moduleinstantiator.h new file mode 100644 index 000000000..f235b83fa --- /dev/null +++ b/src/lib/corelib/language/moduleinstantiator.h @@ -0,0 +1,101 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#pragma once + +#include <QtGlobal> + +QT_BEGIN_NAMESPACE +class QString; +QT_END_NAMESPACE + +namespace qbs { +class SetupProjectParameters; +namespace Internal { +class Item; +class ItemPool; +class Logger; +class ModulePropertyMerger; +class QualifiedId; + +// This class is responsible for setting up a proper module instance from a bunch of items: +// - Set the item type to ItemType::ModuleInstance (from Module or Export). +// - Apply possible command-line overrides for module properties. +// - Replace a possible module instance placeholder in the loading item with the actual instance +// and merge their values employing the ModulePropertyMerger. +// - Setting up the module instance scope. +// In addition, it also provides helper functions for retrieving/setting module instance items +// for special purposes. +class ModuleInstantiator +{ +public: + ModuleInstantiator(const SetupProjectParameters ¶meters, ItemPool &itemPool, + ModulePropertyMerger &propertyMerger, Logger &logger); + ~ModuleInstantiator(); + + struct Context { + Item * const product; + const QString &productName; + Item * const loadingItem; + const QString &loadingName; + Item * const module; + Item * const moduleWithSameName; + Item * const exportingProduct; + Item * const productScope; + Item * const projectScope; + const QualifiedId &moduleName; + const QString &id; + const bool alreadyLoaded; + }; + void instantiate(const Context &context); + + // Note that these will also create the respective item value if it does not exist yet. + Item *retrieveModuleInstanceItem(Item *containerItem, const QualifiedId &name); + Item *retrieveQbsItem(Item *containerItem); + + void printProfilingInfo(int indent); + +private: + class Private; + Private * const d; +}; + +} // namespace Internal +} // namespace qbs + diff --git a/src/lib/corelib/language/moduleloader.cpp b/src/lib/corelib/language/moduleloader.cpp index 1663fccac..6efb2ab4d 100644 --- a/src/lib/corelib/language/moduleloader.cpp +++ b/src/lib/corelib/language/moduleloader.cpp @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2023 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of Qbs. @@ -39,1490 +39,218 @@ #include "moduleloader.h" -#include "builtindeclarations.h" #include "evaluator.h" -#include "filecontext.h" -#include "item.h" #include "itemreader.h" -#include "language.h" -#include "modulemerger.h" -#include "moduleproviderloader.h" -#include "probesresolver.h" -#include "qualifiedid.h" -#include "scriptengine.h" #include "value.h" #include <api/languageinfo.h> -#include <language/language.h> #include <logging/categories.h> -#include <logging/logger.h> #include <logging/translator.h> #include <tools/error.h> -#include <tools/fileinfo.h> -#include <tools/preferences.h> -#include <tools/profile.h> -#include <tools/profiling.h> -#include <tools/progressobserver.h> -#include <tools/qbsassert.h> -#include <tools/qttools.h> -#include <tools/scripttools.h> -#include <tools/settings.h> -#include <tools/stlutils.h> +#include <tools/hostosinfo.h> +#include <tools/setupprojectparameters.h> #include <tools/stringconstants.h> -#include <QtCore/qdebug.h> -#include <QtCore/qdir.h> -#include <QtCore/qglobalstatic.h> -#include <QtCore/qdiriterator.h> -#include <QtCore/qjsondocument.h> -#include <QtCore/qjsonobject.h> -#include <QtCore/qtextstream.h> -#include <QtCore/qthreadstorage.h> - -#include <algorithm> -#include <memory> +#include <unordered_map> #include <utility> -namespace qbs { -namespace Internal { - -using MultiplexConfigurationByIdTable = QThreadStorage<QHash<QString, QVariantMap> >; -Q_GLOBAL_STATIC(MultiplexConfigurationByIdTable, multiplexConfigurationsById); - -static bool multiplexConfigurationIntersects(const QVariantMap &lhs, const QVariantMap &rhs) -{ - QBS_CHECK(!lhs.isEmpty() && !rhs.isEmpty()); - - for (auto lhsProperty = lhs.constBegin(); lhsProperty != lhs.constEnd(); lhsProperty++) { - const auto rhsProperty = rhs.find(lhsProperty.key()); - const bool isCommonProperty = rhsProperty != rhs.constEnd(); - if (isCommonProperty && lhsProperty.value() != rhsProperty.value()) - return false; - } - - return true; -} - -class ModuleLoader::ItemModuleList : public QList<Item::Module> {}; +namespace qbs::Internal { -class ModuleLoader::ProductSortByDependencies +class ModuleLoader::Private { public: - ProductSortByDependencies(TopLevelProjectContext &tlp) : m_tlp(tlp) - { - } - - void apply() - { - QHash<QString, std::vector<ProductContext *>> productsMap; - QList<ProductContext *> allProducts; - for (ProjectContext * const projectContext : qAsConst(m_tlp.projects)) { - for (auto &product : projectContext->products) { - allProducts.push_back(&product); - productsMap[product.name].push_back(&product); - } - } - Set<ProductContext *> allDependencies; - for (auto productContext : qAsConst(allProducts)) { - auto &productDependencies = m_dependencyMap[productContext]; - for (const auto &dep : qAsConst(productContext->info.usedProducts)) { - QBS_CHECK(!dep.name.isEmpty()); - const auto &deps = productsMap.value(dep.name); - if (dep.profile == StringConstants::star()) { - QBS_CHECK(!deps.empty()); - for (ProductContext *depProduct : deps) { - if (depProduct == productContext) - continue; - productDependencies.push_back(depProduct); - allDependencies << depProduct; - } - } else { - auto it = std::find_if(deps.begin(), deps.end(), [&dep] (ProductContext *p) { - return p->multiplexConfigurationId == dep.multiplexConfigurationId; - }); - if (it == deps.end()) { - QBS_CHECK(!productContext->multiplexConfigurationId.isEmpty()); - const QString productName = ResolvedProduct::fullDisplayName( - productContext->name, productContext->multiplexConfigurationId); - const QString depName = ResolvedProduct::fullDisplayName( - dep.name, dep.multiplexConfigurationId); - throw ErrorInfo(Tr::tr("Dependency from product '%1' to product '%2' not " - "fulfilled.").arg(productName, depName), - productContext->item->location()); - } - productDependencies.push_back(*it); - allDependencies << *it; - } - } - } - const Set<ProductContext *> rootProducts - = rangeTo<Set<ProductContext *>>(allProducts) - allDependencies; - for (ProductContext * const rootProduct : rootProducts) - traverse(rootProduct); - if (m_sortedProducts.size() < allProducts.size()) { - for (auto const product : qAsConst(allProducts)) { - QList<ModuleLoader::ProductContext *> path; - findCycle(product, path); - } - } - QBS_CHECK(m_sortedProducts.size() == allProducts.size()); - } - - // No product at position i has dependencies to a product at position j > i. - const QList<ProductContext *> &sortedProducts() const - { - return m_sortedProducts; - } - -private: - void traverse(ModuleLoader::ProductContext *product) - { - if (!m_seenProducts.insert(product).second) - return; - for (const auto &dependency : m_dependencyMap.value(product)) - traverse(dependency); - m_sortedProducts << product; - } - - void findCycle(ModuleLoader::ProductContext *product, - QList<ModuleLoader::ProductContext *> &path) - { - if (path.contains(product)) { - ErrorInfo error(Tr::tr("Cyclic dependencies detected.")); - for (const auto * const p : path) - error.append(p->name, p->item->location()); - error.append(product->name, product->item->location()); - throw error; - } - path << product; - for (auto const dep : m_dependencyMap.value(product)) - findCycle(dep, path); - path.removeLast(); - } - - TopLevelProjectContext &m_tlp; - QHash<ProductContext *, std::vector<ProductContext *>> m_dependencyMap; - Set<ProductContext *> m_seenProducts; - QList<ProductContext *> m_sortedProducts; -}; - -class SearchPathsManager { -public: - explicit SearchPathsManager(ItemReader *itemReader) - : m_itemReader(itemReader) - , m_oldSize(itemReader->extraSearchPathsStack().size()) - { - } - SearchPathsManager(ItemReader *itemReader, const QStringList &extraSearchPaths) - : SearchPathsManager(itemReader) - { - m_itemReader->pushExtraSearchPaths(extraSearchPaths); - } - ~SearchPathsManager() - { - reset(); - } - void reset() - { - while (m_itemReader->extraSearchPathsStack().size() > m_oldSize) - m_itemReader->popExtraSearchPaths(); - } - -private: - ItemReader * const m_itemReader; - size_t m_oldSize{0}; -}; - -ModuleLoader::ModuleLoader(Evaluator *evaluator, Logger &logger) - : m_pool(nullptr) - , m_logger(logger) - , m_progressObserver(nullptr) - , m_reader(std::make_unique<ItemReader>(logger)) - , m_evaluator(evaluator) - , m_probesResolver(std::make_unique<ProbesResolver>(m_evaluator, m_logger)) - , m_moduleProviderLoader( - std::make_unique<ModuleProviderLoader>(m_reader.get(), m_evaluator, m_probesResolver.get(), - m_logger)) -{ -} - -ModuleLoader::~ModuleLoader() = default; - -void ModuleLoader::setProgressObserver(ProgressObserver *progressObserver) -{ - m_progressObserver = progressObserver; -} - -void ModuleLoader::setSearchPaths(const QStringList &searchPaths) -{ - m_reader->setSearchPaths(searchPaths); - qCDebug(lcModuleLoader) << "initial search paths:" << searchPaths; -} - -void ModuleLoader::setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes) -{ - m_probesResolver->setOldProjectProbes(oldProbes); -} - -void ModuleLoader::setOldProductProbes(const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes) -{ - m_probesResolver->setOldProductProbes(oldProbes); -} - -void ModuleLoader::setStoredProfiles(const QVariantMap &profiles) -{ - m_storedProfiles = profiles; -} - -void ModuleLoader::setStoredModuleProviderInfo(const StoredModuleProviderInfo &moduleProviderInfo) -{ - m_moduleProviderLoader->setStoredModuleProviderInfo(moduleProviderInfo); -} - -ModuleLoaderResult ModuleLoader::load(const SetupProjectParameters ¶meters) -{ - TimedActivityLogger moduleLoaderTimer(m_logger, Tr::tr("ModuleLoader"), - parameters.logElapsedTime()); - qCDebug(lcModuleLoader) << "load" << parameters.projectFilePath(); - m_parameters = parameters; - m_modulePrototypes.clear(); - m_modulePrototypeEnabledInfo.clear(); - m_parameterDeclarations.clear(); - m_disabledItems.clear(); - m_reader->setDeprecationWarningMode(parameters.deprecationWarningMode()); - m_reader->clearExtraSearchPathsStack(); - m_reader->setEnableTiming(parameters.logElapsedTime()); - m_moduleProviderLoader->setProjectParameters(m_parameters); - m_probesResolver->setProjectParameters(m_parameters); - m_elapsedTimePrepareProducts = m_elapsedTimeHandleProducts - = m_elapsedTimeProductDependencies = m_elapsedTimeTransitiveDependencies - = m_elapsedTimePropertyChecking = 0; - m_elapsedTimeModuleProviders = 0; - m_settings = std::make_unique<Settings>(parameters.settingsDirectory()); - - const auto keys = m_parameters.overriddenValues().keys(); - for (const QString &key : keys) { - static const QStringList prefixes({ StringConstants::projectPrefix(), - QStringLiteral("projects"), - QStringLiteral("products"), QStringLiteral("modules"), - StringConstants::moduleProviders(), - StringConstants::qbsModule()}); - bool ok = false; - for (const auto &prefix : prefixes) { - if (key.startsWith(prefix + QLatin1Char('.'))) { - ok = true; - break; - } - } - if (ok) { - collectNameFromOverride(key); - continue; - } - ErrorInfo e(Tr::tr("Property override key '%1' not understood.").arg(key)); - e.append(Tr::tr("Please use one of the following:")); - e.append(QLatin1Char('\t') + Tr::tr("projects.<project-name>.<property-name>:value")); - e.append(QLatin1Char('\t') + Tr::tr("products.<product-name>.<property-name>:value")); - e.append(QLatin1Char('\t') + Tr::tr("modules.<module-name>.<property-name>:value")); - e.append(QLatin1Char('\t') + Tr::tr("products.<product-name>.<module-name>." - "<property-name>:value")); - e.append(QLatin1Char('\t') + Tr::tr("moduleProviders.<provider-name>." - "<property-name>:value")); - handlePropertyError(e, m_parameters, m_logger); - } - - ModuleLoaderResult result; - result.profileConfigs = m_storedProfiles; - m_pool = result.itemPool.get(); - m_reader->setPool(m_pool); - - const QStringList topLevelSearchPaths = parameters.finalBuildConfigurationTree() - .value(StringConstants::projectPrefix()).toMap() - .value(StringConstants::qbsSearchPathsProperty()).toStringList(); - Item *root; - { - SearchPathsManager searchPathsManager(m_reader.get(), topLevelSearchPaths); - root = loadItemFromFile(parameters.projectFilePath(), CodeLocation()); - if (!root) - return ModuleLoaderResult(); - } - - switch (root->type()) { - case ItemType::Product: - root = wrapInProjectIfNecessary(root); - break; - case ItemType::Project: - break; - default: - throw ErrorInfo(Tr::tr("The top-level item must be of type 'Project' or 'Product', but it" - " is of type '%1'.").arg(root->typeName()), root->location()); - } - - const QString buildDirectory = TopLevelProject::deriveBuildDirectory(parameters.buildRoot(), - TopLevelProject::deriveId(parameters.finalBuildConfigurationTree())); - root->setProperty(StringConstants::sourceDirectoryProperty(), - VariantValue::create(QFileInfo(root->file()->filePath()).absolutePath())); - root->setProperty(StringConstants::buildDirectoryProperty(), - VariantValue::create(buildDirectory)); - root->setProperty(StringConstants::profileProperty(), - VariantValue::create(m_parameters.topLevelProfile())); - handleTopLevelProject(&result, root, buildDirectory, - Set<QString>() << QDir::cleanPath(parameters.projectFilePath())); - result.root = root; - result.qbsFiles = m_reader->filesRead() - m_moduleProviderLoader->tempQbsFiles(); - for (auto it = m_localProfiles.cbegin(); it != m_localProfiles.cend(); ++it) - result.profileConfigs.remove(it.key()); - printProfilingInfo(); - return result; -} - -class PropertyDeclarationCheck : public ValueHandler -{ - const Set<Item *> &m_disabledItems; - Set<Item *> m_handledItems; - std::vector<Item *> m_parentItems; - Item *m_currentModuleInstance = nullptr; - QualifiedId m_currentModuleName; - QString m_currentName; - SetupProjectParameters m_params; - Logger &m_logger; -public: - PropertyDeclarationCheck(const Set<Item *> &disabledItems, - SetupProjectParameters params, Logger &logger) - : m_disabledItems(disabledItems) - , m_params(std::move(params)) - , m_logger(logger) - { - } - - void operator()(Item *item) - { - handleItem(item); - } - -private: - void handle(JSSourceValue *value) override - { - if (!value->createdByPropertiesBlock()) { - const ErrorInfo error(Tr::tr("Property '%1' is not declared.") - .arg(m_currentName), value->location()); - handlePropertyError(error, m_params, m_logger); - } - } - - void handle(ItemValue *value) override - { - if (checkItemValue(value)) - handleItem(value->item()); - } - - bool checkItemValue(ItemValue *value) - { - // TODO: Remove once QBS-1030 is fixed. - if (parentItem()->type() == ItemType::Artifact) - return false; - - if (parentItem()->type() == ItemType::Properties) - return false; - - if (parentItem()->isOfTypeOrhasParentOfType(ItemType::Export)) { - // Export item prototypes do not have instantiated modules. - // The module instances are where the Export is used. - QBS_ASSERT(m_currentModuleInstance, return false); - auto hasCurrentModuleName = [this](const Item::Module &m) { - return m.name == m_currentModuleName; - }; - if (any_of(m_currentModuleInstance->modules(), hasCurrentModuleName)) - return true; - } - - // TODO: We really should have a dedicated item type for "pre-instantiated" item values - // and only use ModuleInstance for actual module instances. - const bool itemIsModuleInstance = value->item()->type() == ItemType::ModuleInstance - && value->item()->hasProperty(StringConstants::presentProperty()); - - if (!itemIsModuleInstance - && value->item()->type() != ItemType::ModulePrefix - && (!parentItem()->file() || !parentItem()->file()->idScope() - || !parentItem()->file()->idScope()->hasProperty(m_currentName)) - && !value->createdByPropertiesBlock()) { - CodeLocation location = value->location(); - for (int i = int(m_parentItems.size() - 1); !location.isValid() && i >= 0; --i) - location = m_parentItems.at(i)->location(); - const ErrorInfo error(Tr::tr("Item '%1' is not declared. " - "Did you forget to add a Depends item?") - .arg(m_currentModuleName.toString()), location); - handlePropertyError(error, m_params, m_logger); - return false; - } - - return true; - } - - void handleItem(Item *item) - { - if (!m_handledItems.insert(item).second) - return; - if (m_disabledItems.contains(item) - || (item->type() == ItemType::ModuleInstance && !item->isPresentModule()) - || item->type() == ItemType::Properties - - // The Properties child of a SubProject item is not a regular item. - || item->type() == ItemType::PropertiesInSubProject) { - return; - } - - // If a module was found but its validate script failed, only the canonical - // module instance will have the "non-present" flag set, so we need to locate it. - if (item->type() == ItemType::ModuleInstance) { - const Item *productItem = nullptr; - for (auto it = m_parentItems.rbegin(); it != m_parentItems.rend(); ++it) { - if ((*it)->type() == ItemType::Product) { - productItem = *it; - break; - } - } - if (productItem) { - for (const Item::Module &m : productItem->modules()) { - if (m.name == m_currentModuleName) { - if (!m.item->isPresentModule()) - return; - break; - } - } - } - } - - m_parentItems.push_back(item); - for (Item::PropertyMap::const_iterator it = item->properties().constBegin(); - it != item->properties().constEnd(); ++it) { - if (item->type() == ItemType::Product && it.key() == StringConstants::moduleProviders() - && it.value()->type() == Value::ItemValueType) - continue; - const PropertyDeclaration decl = item->propertyDeclaration(it.key()); - if (decl.isValid()) { - const ErrorInfo deprecationError = decl.checkForDeprecation( - m_params.deprecationWarningMode(), it.value()->location(), m_logger); - if (deprecationError.hasError()) - handlePropertyError(deprecationError, m_params, m_logger); - continue; - } - m_currentName = it.key(); - const QualifiedId oldModuleName = m_currentModuleName; - if (parentItem()->type() != ItemType::ModulePrefix) - m_currentModuleName.clear(); - m_currentModuleName.push_back(m_currentName); - it.value()->apply(this); - m_currentModuleName = oldModuleName; - } - m_parentItems.pop_back(); - for (Item * const child : item->children()) { - switch (child->type()) { - case ItemType::Export: - case ItemType::Depends: - case ItemType::Parameter: - case ItemType::Parameters: - break; - case ItemType::Group: - if (item->type() == ItemType::Module || item->type() == ItemType::ModuleInstance) - break; - Q_FALLTHROUGH(); - default: - handleItem(child); - } - } - - // Properties that don't refer to an existing module with a matching Depends item - // only exist in the prototype of an Export item, not in the instance. - // Example 1 - setting a property of an unknown module: Export { abc.def: true } - // Example 2 - setting a non-existing Export property: Export { blubb: true } - if (item->type() == ItemType::ModuleInstance && item->prototype()) { - Item *oldInstance = m_currentModuleInstance; - m_currentModuleInstance = item; - handleItem(item->prototype()); - m_currentModuleInstance = oldInstance; - } - } - - void handle(VariantValue *) override { /* only created internally - no need to check */ } - - Item *parentItem() const { return m_parentItems.back(); } + Private(const SetupProjectParameters &setupParameters, ItemReader &itemReader, + Evaluator &evaluator, Logger &logger) + : setupParameters(setupParameters), itemReader(itemReader), evaluator(evaluator), + logger(logger) {} + + std::pair<Item *, bool> getModulePrototype(const ModuleLoader::ProductContext &product, + const QString &moduleName, const QString &filePath); + bool evaluateModuleCondition(const ModuleLoader::ProductContext &product, Item *module, + const QString &fullModuleName); + void forwardParameterDeclarations(const QualifiedId &moduleName, Item *item, + const Item::Modules &modules); + + const SetupProjectParameters &setupParameters; + ItemReader &itemReader; + Evaluator &evaluator; + Logger &logger; + + // The keys are file paths, the values are module prototype items accompanied by a profile. + std::unordered_map<QString, std::vector<std::pair<Item *, QString>>> modulePrototypes; + + // The keys are module prototypes and products, the values specify whether the module's + // condition is true for that product. + std::unordered_map<std::pair<Item *, const Item *>, bool> modulePrototypeEnabledInfo; + + std::unordered_map<const Item *, std::vector<ErrorInfo>> unknownProfilePropertyErrors; + std::unordered_map<const Item *, Item::PropertyDeclarationMap> parameterDeclarations; }; -void ModuleLoader::handleTopLevelProject(ModuleLoaderResult *loadResult, Item *projectItem, - const QString &buildDirectory, const Set<QString> &referencedFilePaths) -{ - TopLevelProjectContext tlp; - tlp.buildDirectory = buildDirectory; - handleProject(loadResult, &tlp, projectItem, referencedFilePaths); - checkProjectNamesInOverrides(tlp); - collectProductsByName(tlp); - checkProductNamesInOverrides(); - - adjustDependenciesForMultiplexing(tlp); - - m_dependencyResolvingPass = 1; - for (ProjectContext * const projectContext : qAsConst(tlp.projects)) { - m_reader->setExtraSearchPathsStack(projectContext->searchPathsStack); - for (ProductContext &productContext : projectContext->products) { - try { - setupProductDependencies(&productContext, Set<DeferredDependsContext>()); - } catch (const ErrorInfo &err) { - if (productContext.name.isEmpty()) - throw err; - handleProductError(err, &productContext); - } - // extraSearchPathsStack is changed during dependency resolution, check - // that we've rolled back all the changes - QBS_CHECK(m_reader->extraSearchPathsStack() == projectContext->searchPathsStack); - } - } - if (!m_productsWithDeferredDependsItems.empty() || !m_exportsWithDeferredDependsItems.empty()) { - collectProductsByType(tlp); - m_dependencyResolvingPass = 2; - - // Doing the normalization for the Export items themselves (as opposed to doing it only - // for the corresponding module instances) serves two purposes: - // (1) It makes recursive use of Depends.productTypes via Export items work; otherwise, - // we'd need an additional dependency resolving pass for every export level. - // (2) The "expanded" Depends items are available to the Exporter.qbs module. - for (Item * const exportItem : m_exportsWithDeferredDependsItems) - normalizeDependencies(nullptr, DeferredDependsContext(nullptr, exportItem)); - - for (const auto &deferredDependsData : m_productsWithDeferredDependsItems) { - ProductContext * const productContext = deferredDependsData.first; - m_reader->setExtraSearchPathsStack(productContext->project->searchPathsStack); - try { - setupProductDependencies(productContext, deferredDependsData.second); - } catch (const ErrorInfo &err) { - handleProductError(err, productContext); - } - } - } - - ProductSortByDependencies productSorter(tlp); - productSorter.apply(); - for (ProductContext * const p : productSorter.sortedProducts()) { - try { - handleProduct(p); - if (p->name.startsWith(StringConstants::shadowProductPrefix())) - tlp.probes << p->info.probes; - } catch (const ErrorInfo &err) { - handleProductError(err, p); - } - } +ModuleLoader::ModuleLoader(const SetupProjectParameters &setupParameters, ItemReader &itemReader, + Evaluator &evaluator, Logger &logger) + : d(new Private(setupParameters, itemReader, evaluator, logger)) { } - loadResult->projectProbes = tlp.probes; - loadResult->storedModuleProviderInfo = m_moduleProviderLoader->storedModuleProviderInfo(); - - m_reader->clearExtraSearchPathsStack(); - AccumulatingTimer timer(m_parameters.logElapsedTime() - ? &m_elapsedTimePropertyChecking : nullptr); - PropertyDeclarationCheck check(m_disabledItems, m_parameters, m_logger); - check(projectItem); -} +ModuleLoader::~ModuleLoader() { delete d; } -void ModuleLoader::handleProject(ModuleLoaderResult *loadResult, - TopLevelProjectContext *topLevelProjectContext, Item *projectItem, - const Set<QString> &referencedFilePaths) +std::pair<Item *, bool> ModuleLoader::loadModuleFile( + const ProductContext &product, const QString &moduleName, const QString &filePath) { - auto p = std::make_unique<ProjectContext>(); - auto &projectContext = *p; - projectContext.topLevelProject = topLevelProjectContext; - projectContext.result = loadResult; - ItemValuePtr itemValue = ItemValue::create(projectItem); - projectContext.scope = Item::create(m_pool, ItemType::Scope); - projectContext.scope->setFile(projectItem->file()); - projectContext.scope->setProperty(StringConstants::projectVar(), itemValue); - ProductContext dummyProductContext; - dummyProductContext.project = &projectContext; - dummyProductContext.moduleProperties = m_parameters.finalBuildConfigurationTree(); - projectItem->addModule(loadBaseModule(&dummyProductContext, projectItem)); - overrideItemProperties(projectItem, StringConstants::projectPrefix(), - m_parameters.overriddenValuesTree()); - projectContext.name = m_evaluator->stringValue(projectItem, - StringConstants::nameProperty()); - if (projectContext.name.isEmpty()) { - projectContext.name = FileInfo::baseName(projectItem->location().filePath()); - projectItem->setProperty(StringConstants::nameProperty(), - VariantValue::create(projectContext.name)); - } - overrideItemProperties(projectItem, - StringConstants::projectsOverridePrefix() + projectContext.name, - m_parameters.overriddenValuesTree()); - if (!checkItemCondition(projectItem)) { - m_disabledProjects.insert(projectContext.name); - return; - } - topLevelProjectContext->projects.push_back(p.release()); - SearchPathsManager searchPathsManager(m_reader.get(), readExtraSearchPaths(projectItem) - << projectItem->file()->dirPath()); - projectContext.searchPathsStack = m_reader->extraSearchPathsStack(); - projectContext.item = projectItem; - - const QString minVersionStr - = m_evaluator->stringValue(projectItem, StringConstants::minimumQbsVersionProperty(), - QStringLiteral("1.3.0")); - const Version minVersion = Version::fromString(minVersionStr); - if (!minVersion.isValid()) { - throw ErrorInfo(Tr::tr("The value '%1' of Project.minimumQbsVersion " - "is not a valid version string.").arg(minVersionStr), projectItem->location()); - } - if (!m_qbsVersion.isValid()) - m_qbsVersion = Version::fromString(QLatin1String(QBS_VERSION)); - if (m_qbsVersion < minVersion) { - throw ErrorInfo(Tr::tr("The project requires at least qbs version %1, but " - "this is qbs version %2.").arg(minVersion.toString(), - m_qbsVersion.toString())); - } - - for (Item * const child : projectItem->children()) - child->setScope(projectContext.scope); - - m_probesResolver->resolveProbes(&dummyProductContext, projectItem); - projectContext.topLevelProject->probes << dummyProductContext.info.probes; + qCDebug(lcModuleLoader) << "loadModuleFile" << moduleName << "from" << filePath; - handleProfileItems(projectItem, &projectContext); - - QList<Item *> multiplexedProducts; - for (Item * const child : projectItem->children()) { - if (child->type() == ItemType::Product) - multiplexedProducts << multiplexProductItem(&dummyProductContext, child); - } - for (Item * const additionalProductItem : qAsConst(multiplexedProducts)) - Item::addChild(projectItem, additionalProductItem); - - const QList<Item *> originalChildren = projectItem->children(); - for (Item * const child : originalChildren) { - switch (child->type()) { - case ItemType::Product: - prepareProduct(&projectContext, child); - break; - case ItemType::SubProject: - handleSubProject(&projectContext, child, referencedFilePaths); - break; - case ItemType::Project: - copyProperties(projectItem, child); - handleProject(loadResult, topLevelProjectContext, child, referencedFilePaths); - break; - default: - break; - } - } + const auto [module, triedToLoad] = + d->getModulePrototype(product, moduleName, filePath); + if (!module) + return {nullptr, triedToLoad}; - const QStringList refs = m_evaluator->stringListValue( - projectItem, StringConstants::referencesProperty()); - const CodeLocation referencingLocation - = projectItem->property(StringConstants::referencesProperty())->location(); - QList<Item *> additionalProjectChildren; - for (const QString &filePath : refs) { - try { - additionalProjectChildren << loadReferencedFile(filePath, referencingLocation, - referencedFilePaths, dummyProductContext); - } catch (const ErrorInfo &error) { - if (m_parameters.productErrorMode() == ErrorHandlingMode::Strict) - throw; - m_logger.printWarning(error); - } - } - for (Item * const subItem : qAsConst(additionalProjectChildren)) { - Item::addChild(projectContext.item, subItem); - switch (subItem->type()) { - case ItemType::Product: - prepareProduct(&projectContext, subItem); - break; - case ItemType::Project: - copyProperties(projectItem, subItem); - handleProject(loadResult, topLevelProjectContext, subItem, - Set<QString>(referencedFilePaths) << subItem->file()->filePath()); - break; - default: - break; - } + const auto key = std::make_pair(module, product.item); + const auto it = d->modulePrototypeEnabledInfo.find(key); + if (it != d->modulePrototypeEnabledInfo.end()) { + qCDebug(lcModuleLoader) << "prototype cache hit (level 2)"; + return {it->second ? module : nullptr, triedToLoad}; } -} -QString ModuleLoader::MultiplexInfo::toIdString(size_t row) const -{ - const auto &mprow = table.at(row); - QVariantMap multiplexConfiguration; - for (size_t column = 0; column < mprow.size(); ++column) { - const QString &propertyName = properties.at(column); - const VariantValuePtr &mpvalue = mprow.at(column); - multiplexConfiguration.insert(propertyName, mpvalue->value()); - } - QString id = QString::fromUtf8(QJsonDocument::fromVariant(multiplexConfiguration) - .toJson(QJsonDocument::Compact) - .toBase64()); - // Cache for later use in:multiplexIdToVariantMap() - multiplexConfigurationsById->localData().insert(id, multiplexConfiguration); - return id; -} - -QVariantMap ModuleLoader::MultiplexInfo::multiplexIdToVariantMap(const QString &multiplexId) -{ - if (multiplexId.isEmpty()) - return QVariantMap(); - - QVariantMap result = multiplexConfigurationsById->localData().value(multiplexId); - // We assume that MultiplexInfo::toIdString() has been called for this - // particular multiplex configuration. - QBS_CHECK(!result.isEmpty()); - return result; -} - -void qbs::Internal::ModuleLoader::ModuleLoader::dump(const ModuleLoader::MultiplexInfo &mpi) -{ - QStringList header; - for (const auto &str : mpi.properties) - header << str; - qDebug() << header; - - for (const auto &row : mpi.table) { - QVariantList values; - for (const auto &elem : row) { - values << elem->value(); - } - qDebug() << values; + if (!d->evaluateModuleCondition(product, module, moduleName)) { + qCDebug(lcModuleLoader) << "condition of module" << moduleName << "is false"; + d->modulePrototypeEnabledInfo.insert({key, false}); + return {nullptr, triedToLoad}; } -} -ModuleLoader::MultiplexTable ModuleLoader::combine(const MultiplexTable &table, - const MultiplexRow &values) -{ - MultiplexTable result; - if (table.empty()) { - result.resize(values.size()); - for (size_t i = 0; i < values.size(); ++i) { - MultiplexRow row; - row.resize(1); - row[0] = values.at(i); - result[i] = row; - } + if (moduleName == StringConstants::qbsModule()) { + module->setProperty(QStringLiteral("hostPlatform"), + VariantValue::create(HostOsInfo::hostOSIdentifier())); + module->setProperty(QStringLiteral("hostArchitecture"), + VariantValue::create(HostOsInfo::hostOSArchitecture())); + module->setProperty(QStringLiteral("libexecPath"), + VariantValue::create(d->setupParameters.libexecPath())); + + const Version qbsVersion = LanguageInfo::qbsVersion(); + module->setProperty(QStringLiteral("versionMajor"), + VariantValue::create(qbsVersion.majorVersion())); + module->setProperty(QStringLiteral("versionMinor"), + VariantValue::create(qbsVersion.minorVersion())); + module->setProperty(QStringLiteral("versionPatch"), + VariantValue::create(qbsVersion.patchLevel())); } else { - for (const auto &row : table) { - for (const auto &value : values) { - MultiplexRow newRow = row; - newRow.push_back(value); - result.push_back(newRow); - } - } - } - return result; -} - -ModuleLoader::MultiplexInfo ModuleLoader::extractMultiplexInfo(Item *productItem, - Item *qbsModuleItem) -{ - static const QString mpmKey = QStringLiteral("multiplexMap"); - - JSContext * const ctx = m_evaluator->engine()->context(); - const ScopedJsValue multiplexMap(ctx, m_evaluator->value(qbsModuleItem, mpmKey)); - const QStringList multiplexByQbsProperties = m_evaluator->stringListValue( - productItem, StringConstants::multiplexByQbsPropertiesProperty()); - - MultiplexInfo multiplexInfo; - multiplexInfo.aggregate = m_evaluator->boolValue( - productItem, StringConstants::aggregateProperty()); - - const QString multiplexedType = m_evaluator->stringValue( - productItem, StringConstants::multiplexedTypeProperty()); - if (!multiplexedType.isEmpty()) - multiplexInfo.multiplexedType = VariantValue::create(multiplexedType); - - Set<QString> uniqueMultiplexByQbsProperties; - for (const QString &key : multiplexByQbsProperties) { - const QString mappedKey = getJsStringProperty(ctx, multiplexMap, key); - if (mappedKey.isEmpty()) - throw ErrorInfo(Tr::tr("There is no entry for '%1' in 'qbs.multiplexMap'.").arg(key)); - - if (!uniqueMultiplexByQbsProperties.insert(mappedKey).second) { - throw ErrorInfo(Tr::tr("Duplicate entry '%1' in Product.%2.") - .arg(mappedKey, StringConstants::multiplexByQbsPropertiesProperty()), - productItem->location()); - } - - const ScopedJsValue arr(ctx, m_evaluator->value(qbsModuleItem, key)); - if (JS_IsUndefined(arr)) - continue; - if (!JS_IsArray(ctx, arr)) - throw ErrorInfo(Tr::tr("Property '%1' must be an array.").arg(key)); - - const quint32 arrlen = getJsIntProperty(ctx, arr, StringConstants::lengthProperty()); - if (arrlen == 0) - continue; - - MultiplexRow mprow; - mprow.resize(arrlen); - QVariantList entriesForKey; - for (quint32 i = 0; i < arrlen; ++i) { - const ScopedJsValue sv(ctx, JS_GetPropertyUint32(ctx, arr, i)); - const QVariant value = getJsVariant(ctx, sv); - if (entriesForKey.contains(value)) { - throw ErrorInfo(Tr::tr("Duplicate entry '%1' in qbs.%2.") - .arg(value.toString(), key), productItem->location()); - } - entriesForKey << value; - mprow[i] = VariantValue::create(value); - } - multiplexInfo.table = combine(multiplexInfo.table, mprow); - multiplexInfo.properties.push_back(mappedKey); - } - return multiplexInfo; -} - -template <typename T, typename F> -T ModuleLoader::callWithTemporaryBaseModule(ProductContext *productContext, const F &func) -{ - // Temporarily attach the qbs module here, in case we need to access one of its properties - // to evaluate properties. - const QString &qbsKey = StringConstants::qbsModule(); - Item *productItem = productContext->item; - ValuePtr qbsValue = productItem->property(qbsKey); // Retrieve now to restore later. - if (qbsValue) - qbsValue = qbsValue->clone(); - const Item::Module qbsModule = loadBaseModule(productContext, productItem); - productItem->addModule(qbsModule); - - auto &&result = func(qbsModule); - - // "Unload" the qbs module again. - if (qbsValue) - productItem->setProperty(qbsKey, qbsValue); - else - productItem->removeProperty(qbsKey); - productItem->removeModules(); - - return std::forward<T>(result); -} - -QList<Item *> ModuleLoader::multiplexProductItem(ProductContext *dummyContext, Item *productItem) -{ - QString productName; - dummyContext->item = productItem; - auto extractMultiplexInfoFromProduct - = [this, productItem, &productName](const Item::Module &qbsModule) { - // Overriding the product item properties must be done here already, because multiplexing - // properties might depend on product properties. - const QString &nameKey = StringConstants::nameProperty(); - productName = m_evaluator->stringValue(productItem, nameKey); - if (productName.isEmpty()) { - productName = FileInfo::completeBaseName(productItem->file()->filePath()); - productItem->setProperty(nameKey, VariantValue::create(productName)); - } - overrideItemProperties(productItem, StringConstants::productsOverridePrefix() + productName, - m_parameters.overriddenValuesTree()); - - return extractMultiplexInfo(productItem, qbsModule.item); - }; - const auto multiplexInfo - = callWithTemporaryBaseModule<const MultiplexInfo>(dummyContext, - extractMultiplexInfoFromProduct); - - if (multiplexInfo.table.size() > 1) - productItem->setProperty(StringConstants::multiplexedProperty(), VariantValue::trueValue()); - - VariantValuePtr productNameValue = VariantValue::create(productName); - - Item *aggregator = multiplexInfo.aggregate ? productItem->clone() : nullptr; - QList<Item *> additionalProductItems; - std::vector<VariantValuePtr> multiplexConfigurationIdValues; - for (size_t row = 0; row < multiplexInfo.table.size(); ++row) { - Item *item = productItem; - const auto &mprow = multiplexInfo.table.at(row); - QBS_CHECK(mprow.size() == multiplexInfo.properties.size()); - if (row > 0) { - item = productItem->clone(); - additionalProductItems.push_back(item); - } - const QString multiplexConfigurationId = multiplexInfo.toIdString(row); - const VariantValuePtr multiplexConfigurationIdValue - = VariantValue::create(multiplexConfigurationId); - if (multiplexInfo.table.size() > 1 || aggregator) { - multiplexConfigurationIdValues.push_back(multiplexConfigurationIdValue); - item->setProperty(StringConstants::multiplexConfigurationIdProperty(), - multiplexConfigurationIdValue); - } - if (multiplexInfo.multiplexedType) - item->setProperty(StringConstants::typeProperty(), multiplexInfo.multiplexedType); - for (size_t column = 0; column < mprow.size(); ++column) { - Item *qbsItem = moduleInstanceItem(item, StringConstants::qbsModule()); - const QString &propertyName = multiplexInfo.properties.at(column); - const VariantValuePtr &mpvalue = mprow.at(column); - qbsItem->setProperty(propertyName, mpvalue); - } - } - - if (aggregator) { - additionalProductItems << aggregator; - - // Add dependencies to all multiplexed instances. - for (const auto &v : multiplexConfigurationIdValues) { - Item *dependsItem = Item::create(aggregator->pool(), ItemType::Depends); - dependsItem->setProperty(StringConstants::nameProperty(), productNameValue); - dependsItem->setProperty(StringConstants::multiplexConfigurationIdProperty(), v); - dependsItem->setProperty(StringConstants::profilesProperty(), - VariantValue::create(QStringList())); - dependsItem->setFile(aggregator->file()); - dependsItem->setupForBuiltinType(m_parameters.deprecationWarningMode(), m_logger); - Item::addChild(aggregator, dependsItem); - } - } - - return additionalProductItems; -} - -void ModuleLoader::normalizeDependencies(ProductContext *product, - const DeferredDependsContext &dependsContext) -{ - std::vector<Item *> dependsItemsToAdd; - std::vector<Item *> dependsItemsToRemove; - std::vector<Item *> deferredDependsItems; - for (Item *dependsItem : dependsContext.parentItem->children()) { - if (dependsItem->type() != ItemType::Depends) - continue; - bool productTypesIsSet; - const FileTags productTypes = m_evaluator->fileTagsValue(dependsItem, - StringConstants::productTypesProperty(), &productTypesIsSet); - if (productTypesIsSet) { - bool nameIsSet; - m_evaluator->stringValue(dependsItem, StringConstants::nameProperty(), QString(), - &nameIsSet); - - // The second condition is for the case where the dependency comes from an Export item - // that has itself been normalized in the mean time. - if (nameIsSet && !dependsItem->variantProperty(StringConstants::nameProperty())) { - throw ErrorInfo(Tr::tr("The 'productTypes' and 'name' properties are mutually " - "exclusive."), dependsItem->location()); - } - - bool submodulesPropertySet; - m_evaluator->stringListValue( dependsItem, StringConstants::submodulesProperty(), - &submodulesPropertySet); - if (submodulesPropertySet) { - throw ErrorInfo(Tr::tr("The 'productTypes' and 'subModules' properties are " - "mutually exclusive."), dependsItem->location()); - } - - // We ignore the "limitToSubProject" property for dependencies from Export items, - // because we cannot make it work consistently, as the importing product is not - // yet known when normalizing via an Export item. - const bool limitToSubProject = dependsContext.parentItem->type() == ItemType::Product - && m_evaluator->boolValue(dependsItem, - StringConstants::limitToSubProjectProperty()); - static const auto hasSameSubProject - = [](const ProductContext &product, const ProductContext &other) { - for (const Item *otherParent = other.item->parent(); otherParent; - otherParent = otherParent->parent()) { - if (otherParent == product.item->parent()) - return true; - } - return false; - }; - std::vector<const ProductContext *> matchingProducts; - for (const FileTag &typeTag : productTypes) { - const auto range = m_productsByType.equal_range(typeTag); - for (auto it = range.first; it != range.second; ++it) { - if (it->second != product - && (!product || it->second->name != product->name) - && (!limitToSubProject || hasSameSubProject(*product, *it->second))) { - matchingProducts.push_back(it->second); - } - } - } - if (matchingProducts.empty()) { - qCDebug(lcModuleLoader) << "Depends.productTypes does not match anything." - << dependsItem->location(); - dependsItemsToRemove.push_back(dependsItem); + Item::PropertyDeclarationMap decls; + const auto &moduleChildren = module->children(); + for (Item *param : moduleChildren) { + if (param->type() != ItemType::Parameter) continue; - } - if (dependsContext.parentItem->type() != ItemType::Export) - deferredDependsItems.push_back(dependsItem); - for (std::size_t i = 1; i < matchingProducts.size(); ++i) { - Item * const dependsClone = dependsItem->clone(); - dependsClone->setProperty(StringConstants::nameProperty(), - VariantValue::create(matchingProducts.at(i)->name)); - dependsItemsToAdd.push_back(dependsClone); - if (dependsContext.parentItem->type() != ItemType::Export) - deferredDependsItems.push_back(dependsClone); - - } - dependsItem->setProperty(StringConstants::nameProperty(), - VariantValue::create(matchingProducts.front()->name)); + const auto ¶mDecls = param->propertyDeclarations(); + for (auto it = paramDecls.begin(); it != paramDecls.end(); ++it) + decls.insert(it.key(), it.value()); } + d->parameterDeclarations.insert({module, decls}); } - for (Item * const newDependsItem : dependsItemsToAdd) - Item::addChild(dependsContext.parentItem, newDependsItem); - for (Item * const dependsItem : dependsItemsToRemove) - Item::removeChild(dependsContext.parentItem, dependsItem); - if (!deferredDependsItems.empty()) { - auto &allDeferredDependsItems - = product->deferredDependsItems[dependsContext.exportingProductItem]; - allDeferredDependsItems.insert(allDeferredDependsItems.end(), deferredDependsItems.cbegin(), - deferredDependsItems.cend()); - } -} - -void ModuleLoader::adjustDependenciesForMultiplexing(const TopLevelProjectContext &tlp) -{ - for (const ProjectContext * const project : tlp.projects) { - for (const ProductContext &product : project->products) - adjustDependenciesForMultiplexing(product); - } -} -void ModuleLoader::adjustDependenciesForMultiplexing(const ModuleLoader::ProductContext &product) -{ - for (Item *dependsItem : product.item->children()) { - if (dependsItem->type() == ItemType::Depends) - adjustDependenciesForMultiplexing(product, dependsItem); - } -} - -void ModuleLoader::adjustDependenciesForMultiplexing(const ProductContext &product, - Item *dependsItem) -{ - const QString name = m_evaluator->stringValue(dependsItem, StringConstants::nameProperty()); - const bool productIsMultiplexed = !product.multiplexConfigurationId.isEmpty(); - if (name == product.name) { - QBS_CHECK(!productIsMultiplexed); // This product must be an aggregator. - return; - } - - bool profilesPropertyIsSet; - const QStringList profiles = m_evaluator->stringListValue(dependsItem, - StringConstants::profilesProperty(), &profilesPropertyIsSet); - - const auto productRange = m_productsByName.equal_range(name); - if (productRange.first == productRange.second) { - // Dependency is a module. Nothing to adjust. - return; - } - - std::vector<const ProductContext *> multiplexedDependencies; - bool hasNonMultiplexedDependency = false; - for (auto it = productRange.first; it != productRange.second; ++it) { - if (!it->second->multiplexConfigurationId.isEmpty()) - multiplexedDependencies.push_back(it->second); - else - hasNonMultiplexedDependency = true; - } - bool hasMultiplexedDependencies = !multiplexedDependencies.empty(); - - // These are the allowed cases: - // (1) Normal dependency with no multiplexing whatsoever. - // (2) Both product and dependency are multiplexed. - // (2a) The profiles property is not set, we want to depend on the best - // matching variant. - // (2b) The profiles property is set, we want to depend on all variants - // with a matching profile. - // (3) The product is not multiplexed, but the dependency is. - // (3a) The profiles property is not set, the dependency has an aggregator. - // We want to depend on the aggregator. - // (3b) The profiles property is not set, the dependency does not have an - // aggregator. We want to depend on all the multiplexed variants. - // (3c) The profiles property is set, we want to depend on all variants - // with a matching profile regardless of whether an aggregator exists or not. - // (4) The product is multiplexed, but the dependency is not. We don't have to adapt - // any Depends items. - // (5) The product is a "shadow product". In that case, we know which product - // it should have a dependency on, and we make sure we depend on that. - - // (1) and (4) - if (!hasMultiplexedDependencies) - return; - - // (3a) - if (!productIsMultiplexed && hasNonMultiplexedDependency && !profilesPropertyIsSet) - return; - - QStringList multiplexIds; - const ShadowProductInfo shadowProductInfo = getShadowProductInfo(product); - const bool isShadowProduct = shadowProductInfo.first && shadowProductInfo.second == name; - const auto productMultiplexConfig = - MultiplexInfo::multiplexIdToVariantMap(product.multiplexConfigurationId); - - for (const ProductContext *dependency : multiplexedDependencies) { - const bool depMatchesShadowProduct = isShadowProduct - && dependency->item == product.item->parent(); - const QString depMultiplexId = dependency->multiplexConfigurationId; - if (depMatchesShadowProduct) { // (5) - dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), - VariantValue::create(depMultiplexId)); - return; - } - if (productIsMultiplexed && !profilesPropertyIsSet) { // 2a - if (dependency->multiplexConfigurationId == product.multiplexConfigurationId) { - const ValuePtr &multiplexId = product.item->property( - StringConstants::multiplexConfigurationIdProperty()); - dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), - multiplexId); - return; - - } - // Otherwise collect partial matches and decide later - const auto dependencyMultiplexConfig = MultiplexInfo::multiplexIdToVariantMap( - dependency->multiplexConfigurationId); - - if (multiplexConfigurationIntersects(dependencyMultiplexConfig, productMultiplexConfig)) - multiplexIds << dependency->multiplexConfigurationId; - } else { - // (2b), (3b) or (3c) - const bool profileMatch = !profilesPropertyIsSet || profiles.empty() - || profiles.contains(dependency->profileName); - if (profileMatch) - multiplexIds << depMultiplexId; - } - } - if (multiplexIds.empty()) { - const QString productName = ResolvedProduct::fullDisplayName( - product.name, product.multiplexConfigurationId); - throw ErrorInfo(Tr::tr("Dependency from product '%1' to product '%2' not fulfilled. " - "There are no eligible multiplex candidates.").arg(productName, - name), - dependsItem->location()); - } - - // In case of (2a), at most 1 match is allowed - if (productIsMultiplexed && !profilesPropertyIsSet && multiplexIds.size() > 1) { - const QString productName = ResolvedProduct::fullDisplayName( - product.name, product.multiplexConfigurationId); - QStringList candidateNames; - for (const auto &id : qAsConst(multiplexIds)) - candidateNames << ResolvedProduct::fullDisplayName(name, id); - throw ErrorInfo(Tr::tr("Dependency from product '%1' to product '%2' is ambiguous. " - "Eligible multiplex candidates: %3.").arg( - productName, name, candidateNames.join(QLatin1String(", "))), - dependsItem->location()); - } - - dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), - VariantValue::create(multiplexIds)); + d->modulePrototypeEnabledInfo.insert({key, true}); + return {module, triedToLoad}; } -void ModuleLoader::prepareProduct(ProjectContext *projectContext, Item *productItem) +void ModuleLoader::checkProfileErrorsForModule( + Item *module, const QString &moduleName, const QString &productName, const QString &profileName) { - AccumulatingTimer timer(m_parameters.logElapsedTime() - ? &m_elapsedTimePrepareProducts : nullptr); - checkCancelation(); - qCDebug(lcModuleLoader) << "prepareProduct" << productItem->file()->filePath(); - - ProductContext productContext; - productContext.item = productItem; - productContext.project = projectContext; - productContext.name = m_evaluator->stringValue(productItem, StringConstants::nameProperty()); - QBS_CHECK(!productContext.name.isEmpty()); - const ItemValueConstPtr qbsItemValue = productItem->itemProperty(StringConstants::qbsModule()); - if (!!qbsItemValue && qbsItemValue->item()->hasProperty(StringConstants::profileProperty())) { - qbsItemValue->item()->setProperty(StringConstants::nameProperty(), - VariantValue::create(StringConstants::nameProperty())); - auto evaluateQbsProfileProperty = [this](const Item::Module &qbsModule) { - return m_evaluator->stringValue(qbsModule.item, - StringConstants::profileProperty(), QString()); - }; - productContext.profileName - = callWithTemporaryBaseModule<QString>(&productContext, - evaluateQbsProfileProperty); - } else { - productContext.profileName = m_parameters.topLevelProfile(); - } - productContext.multiplexConfigurationId = m_evaluator->stringValue( - productItem, StringConstants::multiplexConfigurationIdProperty()); - QBS_CHECK(!productContext.profileName.isEmpty()); - const auto it = projectContext->result->profileConfigs.constFind(productContext.profileName); - if (it == projectContext->result->profileConfigs.constEnd()) { - const Profile profile(productContext.profileName, m_settings.get(), m_localProfiles); - if (!profile.exists()) { - ErrorInfo error(Tr::tr("Profile '%1' does not exist.").arg(profile.name()), - productItem->location()); - handleProductError(error, &productContext); - return; - } - const QVariantMap buildConfig = SetupProjectParameters::expandedBuildConfiguration( - profile, m_parameters.configurationName()); - productContext.moduleProperties = SetupProjectParameters::finalBuildConfigurationTree( - buildConfig, m_parameters.overriddenValues()); - projectContext->result->profileConfigs.insert(productContext.profileName, - productContext.moduleProperties); - } else { - productContext.moduleProperties = it.value().toMap(); + const auto it = d->unknownProfilePropertyErrors.find(module); + if (it != d->unknownProfilePropertyErrors.cend()) { + ErrorInfo error(Tr::tr("Loading module '%1' for product '%2' failed due to invalid values " + "in profile '%3':").arg(moduleName, productName, profileName)); + for (const ErrorInfo &e : it->second) + error.append(e.toString()); + handlePropertyError(error, d->setupParameters, d->logger); } - initProductProperties(productContext); - - ItemValuePtr itemValue = ItemValue::create(productItem); - productContext.scope = Item::create(m_pool, ItemType::Scope); - productContext.scope->setProperty(StringConstants::productVar(), itemValue); - productContext.scope->setFile(productItem->file()); - productContext.scope->setScope(productContext.project->scope); - - const bool hasExportItems = mergeExportItems(productContext); - - setScopeForDescendants(productItem, productContext.scope); - - projectContext->products.push_back(productContext); - - if (!hasExportItems || getShadowProductInfo(productContext).first) - return; - - // This "shadow product" exists only to pull in a dependency on the actual product - // and nothing else, thus providing us with the pure environment that we need to - // evaluate the product's exported properties in isolation in the project resolver. - Item * const importer = Item::create(productItem->pool(), ItemType::Product); - importer->setProperty(QStringLiteral("name"), - VariantValue::create(StringConstants::shadowProductPrefix() - + productContext.name)); - importer->setFile(productItem->file()); - importer->setLocation(productItem->location()); - importer->setScope(projectContext->scope); - importer->setupForBuiltinType(m_parameters.deprecationWarningMode(), m_logger); - Item * const dependsItem = Item::create(productItem->pool(), ItemType::Depends); - dependsItem->setProperty(QStringLiteral("name"), VariantValue::create(productContext.name)); - dependsItem->setProperty(QStringLiteral("required"), VariantValue::create(false)); - dependsItem->setFile(importer->file()); - dependsItem->setLocation(importer->location()); - dependsItem->setupForBuiltinType(m_parameters.deprecationWarningMode(), m_logger); - Item::addChild(importer, dependsItem); - Item::addChild(productItem, importer); - prepareProduct(projectContext, importer); } -void ModuleLoader::setupProductDependencies(ProductContext *productContext, - const Set<DeferredDependsContext> &deferredDependsContext) +std::pair<Item *, bool> ModuleLoader::Private::getModulePrototype( + const ProductContext &product, const QString &moduleName, const QString &filePath) { - if (m_dependencyResolvingPass == 2) { - for (const DeferredDependsContext &ctx : deferredDependsContext) - normalizeDependencies(productContext, ctx); - for (const auto &deferralData : productContext->deferredDependsItems) { - for (Item * const deferredDependsItem : deferralData.second) { - - // Dependencies from Export items are handled in addProductModuleDependencies(). - if (deferredDependsItem->parent() == productContext->item) - adjustDependenciesForMultiplexing(*productContext, deferredDependsItem); - } + auto &prototypeList = modulePrototypes[filePath]; + for (const auto &prototype : prototypeList) { + if (prototype.second == product.profile) { + qCDebug(lcModuleLoader) << "prototype cache hit (level 1)"; + return {prototype.first, true}; } } - AccumulatingTimer timer(m_parameters.logElapsedTime() - ? &m_elapsedTimeProductDependencies : nullptr); - checkCancelation(); - Item *item = productContext->item; - qCDebug(lcModuleLoader) << "setupProductDependencies" << productContext->name - << productContext->item->location(); - - if (m_dependencyResolvingPass == 1) - setSearchPathsForProduct(productContext); - // Module providers may push some extra search paths which we will be cleared - // by this SearchPathsManager. However, they will be also added to productContext->searchPaths - // so second pass will take that into account - SearchPathsManager searchPathsManager(m_reader.get(), productContext->searchPaths); - - DependsContext dependsContext; - dependsContext.product = productContext; - dependsContext.productDependencies = &productContext->info.usedProducts; - resolveDependencies(&dependsContext, item, productContext); - if (m_dependencyResolvingPass == 2 - || !containsKey(m_productsWithDeferredDependsItems, productContext)) { - addProductModuleDependencies(productContext); + Item * const module = itemReader.setupItemFromFile(filePath, CodeLocation(), evaluator); + if (module->type() != ItemType::Module) { + qCDebug(lcModuleLoader).nospace() + << "Alleged module " << moduleName << " has type '" + << module->typeName() << "', so it's not a module after all."; + return {nullptr, false}; } - productContext->project->result->productInfos[item] = productContext->info; -} + prototypeList.emplace_back(module, product.profile); -// Leaf modules first. -// TODO: Can this be merged with addTransitiveDependencies? Looks suspiciously similar. -void ModuleLoader::createSortedModuleList(const Item::Module &parentModule, Item::Modules &modules) -{ - if (std::find_if(modules.cbegin(), modules.cend(), - [parentModule](const Item::Module &m) { return m.name == parentModule.name;}) - != modules.cend()) { - return; - } - for (const Item::Module &dep : parentModule.item->modules()) - createSortedModuleList(dep, modules); - modules.push_back(parentModule); -} - -Item::Modules ModuleLoader::modulesSortedByDependency(const Item *productItem) -{ - QBS_CHECK(productItem->type() == ItemType::Product); - Item::Modules sortedModules; - const Item::Modules &unsortedModules = productItem->modules(); - for (const Item::Module &module : unsortedModules) - createSortedModuleList(module, sortedModules); - QBS_CHECK(sortedModules.size() == unsortedModules.size()); - - // Make sure the top-level items stay the same. - for (Item::Module &s : sortedModules) { - for (const Item::Module &u : unsortedModules) { - if (s.name == u.name) { - s.item = u.item; - break; - } + // Module properties that are defined in the profile are used as default values. + // This is the reason we need to have different items per profile. + const QVariantMap profileModuleProperties + = product.profileModuleProperties.value(moduleName).toMap(); + for (auto it = profileModuleProperties.cbegin(); it != profileModuleProperties.cend(); ++it) { + if (Q_UNLIKELY(!module->hasProperty(it.key()))) { + unknownProfilePropertyErrors[module].emplace_back(Tr::tr("Unknown property: %1.%2") + .arg(moduleName, it.key())); + continue; } + const PropertyDeclaration decl = module->propertyDeclaration(it.key()); + VariantValuePtr v = VariantValue::create( + PropertyDeclaration::convertToPropertyType(it.value(), decl.type(), + QStringList(moduleName), it.key())); + v->markAsSetByProfile(); + module->setProperty(it.key(), v); } - return sortedModules; -} - - -template<typename T> bool insertIntoSet(Set<T> &set, const T &value) -{ - const auto insertionResult = set.insert(value); - return insertionResult.second; -} - -void ModuleLoader::setupReverseModuleDependencies(const Item::Module &module, - ModuleDependencies &deps, - QualifiedIdSet &seenModules) -{ - if (!insertIntoSet(seenModules, module.name)) - return; - for (const Item::Module &m : module.item->modules()) { - deps[m.name].insert(module.name); - setupReverseModuleDependencies(m, deps, seenModules); - } -} -ModuleLoader::ModuleDependencies ModuleLoader::setupReverseModuleDependencies(const Item *product) -{ - ModuleDependencies deps; - QualifiedIdSet seenModules; - for (const Item::Module &m : product->modules()) - setupReverseModuleDependencies(m, deps, seenModules); - return deps; + return {module, true}; } -void ModuleLoader::handleProduct(ModuleLoader::ProductContext *productContext) +bool ModuleLoader::Private::evaluateModuleCondition(const ProductContext &product, + Item *module, const QString &fullModuleName) { - AccumulatingTimer timer(m_parameters.logElapsedTime() ? &m_elapsedTimeHandleProducts : nullptr); - if (productContext->info.delayedError.hasError()) - return; - - Item * const item = productContext->item; - - m_reader->setExtraSearchPathsStack(productContext->project->searchPathsStack); - SearchPathsManager searchPathsManager(m_reader.get(), productContext->searchPaths); - addTransitiveDependencies(productContext); - - // It is important that dependent modules are merged after their dependency, because - // the dependent module's merger potentially needs to replace module items that were - // set by the dependency module's merger (namely, scopes of defining items; see - // ModuleMerger::replaceItemInScopes()). - Item::Modules topSortedModules = modulesSortedByDependency(item); - ModuleMerger::merge(m_logger, item, productContext->name, &topSortedModules); - - // Re-sort the modules by name. This is more stable; see QBS-818. - // The list of modules in the product now has the same order as before, - // only the items have been replaced by their merged counterparts. - Item::Modules lexicographicallySortedModules = topSortedModules; - std::sort(lexicographicallySortedModules.begin(), lexicographicallySortedModules.end()); - item->setModules(lexicographicallySortedModules); + // Evaluator reqires module name to be set. + module->setProperty(StringConstants::nameProperty(), VariantValue::create(fullModuleName)); - for (const Item::Module &module : topSortedModules) { - if (!module.item->isPresentModule()) - continue; - try { - m_probesResolver->resolveProbes(productContext, module.item); - if (module.versionRange.minimum.isValid() - || module.versionRange.maximum.isValid()) { - if (module.versionRange.maximum.isValid() - && module.versionRange.minimum >= module.versionRange.maximum) { - throw ErrorInfo(Tr::tr("Impossible version constraint [%1,%2) set for module " - "'%3'").arg(module.versionRange.minimum.toString(), - module.versionRange.maximum.toString(), - module.name.toString())); - } - const Version moduleVersion = Version::fromString( - m_evaluator->stringValue(module.item, - StringConstants::versionProperty())); - if (moduleVersion < module.versionRange.minimum) { - throw ErrorInfo(Tr::tr("Module '%1' has version %2, but it needs to be " - "at least %3.").arg(module.name.toString(), - moduleVersion.toString(), - module.versionRange.minimum.toString())); - } - if (module.versionRange.maximum.isValid() - && moduleVersion >= module.versionRange.maximum) { - throw ErrorInfo(Tr::tr("Module '%1' has version %2, but it needs to be " - "lower than %3.").arg(module.name.toString(), - moduleVersion.toString(), - module.versionRange.maximum.toString())); - } + // Temporarily make the product's qbs module instance available, so the condition + // can use qbs.targetOS etc. + class TempQbsModuleProvider { + public: + TempQbsModuleProvider(const ProductContext &product, + Item *module, const QString &moduleName) + : m_module(module), m_needsQbsItem(moduleName != StringConstants::qbsModule()) + { + if (m_needsQbsItem) { + m_prevQbsItemValue = module->property(StringConstants::qbsModule()); + module->setProperty(StringConstants::qbsModule(), + product.item->property(StringConstants::qbsModule())); } - } catch (const ErrorInfo &error) { - handleModuleSetupError(productContext, module, error); - if (productContext->info.delayedError.hasError()) - return; } - } - - m_probesResolver->resolveProbes(productContext, item); - - // Module validation must happen in an extra pass, after all Probes have been resolved. - EvalCacheEnabler cacheEnabler(m_evaluator); - for (const Item::Module &module : topSortedModules) { - if (!module.item->isPresentModule()) - continue; - try { - m_evaluator->boolValue(module.item, StringConstants::validateProperty()); - for (const auto &dep : module.item->modules()) { - if (dep.requiredValue && !dep.item->isPresentModule()) { - throw ErrorInfo(Tr::tr("Module '%1' depends on module '%2', which was not " - "loaded successfully") - .arg(module.name.toString(), dep.name.toString())); - } - } - } catch (const ErrorInfo &error) { - handleModuleSetupError(productContext, module, error); - if (productContext->info.delayedError.hasError()) + ~TempQbsModuleProvider() + { + if (!m_needsQbsItem) return; + if (m_prevQbsItemValue) + m_module->setProperty(StringConstants::qbsModule(), m_prevQbsItemValue); + else + m_module->removeProperty(StringConstants::qbsModule()); } - } - - if (!checkItemCondition(item)) { - const auto &exportsData = productContext->project->topLevelProject->productModules; - for (auto it = exportsData.find(productContext->name); - it != exportsData.end() && it.key() == productContext->name; ++it) { - if (it.value().multiplexId == productContext->multiplexConfigurationId) { - createNonPresentModule(productContext->name, QStringLiteral("disabled"), - it.value().exportItem); - break; - } - } - } - - checkDependencyParameterDeclarations(productContext); - copyGroupsFromModulesToProduct(*productContext); - - ModuleDependencies reverseModuleDeps; - for (Item * const child : item->children()) { - if (child->type() == ItemType::Group) { - if (reverseModuleDeps.empty()) - reverseModuleDeps = setupReverseModuleDependencies(item); - handleGroup(productContext, child, reverseModuleDeps); - } - } - productContext->project->result->productInfos[item] = productContext->info; -} + private: + Item * const m_module; + ValuePtr m_prevQbsItemValue; + const bool m_needsQbsItem; + }; -static Item *rootPrototype(Item *item) -{ - Item *modulePrototype = item; - while (modulePrototype->prototype()) - modulePrototype = modulePrototype->prototype(); - return modulePrototype; + const TempQbsModuleProvider tempQbs(product, module, fullModuleName); + return evaluator.boolValue(module, StringConstants::conditionProperty()); } class DependencyParameterDeclarationCheck { public: - DependencyParameterDeclarationCheck(const QString &productName, const Item *productItem, - const QHash<const Item *, Item::PropertyDeclarationMap> &decls) + DependencyParameterDeclarationCheck( + const QString &productName, const Item *productItem, + const std::unordered_map<const Item *, Item::PropertyDeclarationMap> &decls) : m_productName(productName), m_productItem(productItem), m_parameterDeclarations(decls) - { - } + {} - void operator()(const QVariantMap ¶meters) const - { - check(parameters, QualifiedId()); - } + void operator()(const QVariantMap ¶meters) const { check(parameters, QualifiedId()); } private: void check(const QVariantMap ¶meters, const QualifiedId &moduleName) const @@ -1534,23 +262,22 @@ private: const auto &deps = m_productItem->modules(); auto m = std::find_if(deps.begin(), deps.end(), [&moduleName] (const Item::Module &module) { - return module.name == moduleName; - }); + return module.name == moduleName; + }); if (m == deps.end()) { const QualifiedId fullName = QualifiedId(moduleName) << it.key(); throw ErrorInfo(Tr::tr("Cannot set parameter '%1', " "because '%2' does not have a dependency on '%3'.") - .arg(fullName.toString(), m_productName, moduleName.toString()), + .arg(fullName.toString(), m_productName, moduleName.toString()), m_productItem->location()); } - auto decls = m_parameterDeclarations.value(rootPrototype(m->item)); - - if (!decls.contains(it.key())) { + const auto decls = m_parameterDeclarations.find(m->item->rootPrototype()); + if (decls == m_parameterDeclarations.end() || !decls->second.contains(it.key())) { const QualifiedId fullName = QualifiedId(moduleName) << it.key(); throw ErrorInfo(Tr::tr("Parameter '%1' is not declared.") - .arg(fullName.toString()), m_productItem->location()); + .arg(fullName.toString()), m_productItem->location()); } } } @@ -1565,1113 +292,39 @@ private: } const QString &m_productName; - const Item *m_productItem; - const QHash<const Item *, Item::PropertyDeclarationMap> &m_parameterDeclarations; + const Item * const m_productItem; + const std::unordered_map<const Item *, Item::PropertyDeclarationMap> &m_parameterDeclarations; }; -void ModuleLoader::checkDependencyParameterDeclarations(const ProductContext *productContext) const +void ModuleLoader::checkDependencyParameterDeclarations(const ProductContext &product) const { - DependencyParameterDeclarationCheck dpdc(productContext->name, productContext->item, - m_parameterDeclarations); - for (const Item::Module &dep : productContext->item->modules()) { + DependencyParameterDeclarationCheck dpdc(product.name, product.item, d->parameterDeclarations); + for (const Item::Module &dep : product.item->modules()) { if (!dep.parameters.empty()) dpdc(dep.parameters); } } -void ModuleLoader::handleModuleSetupError(ModuleLoader::ProductContext *productContext, - const Item::Module &module, const ErrorInfo &error) -{ - if (module.required) { - handleProductError(error, productContext); - } else { - qCDebug(lcModuleLoader()) << "non-required module" << module.name.toString() - << "found, but not usable in product" << productContext->name - << error.toString(); - createNonPresentModule(module.name.toString(), QStringLiteral("failed validation"), - module.item); - } -} - -void ModuleLoader::initProductProperties(const ProductContext &product) -{ - QString buildDir = ResolvedProduct::deriveBuildDirectoryName(product.name, - product.multiplexConfigurationId); - buildDir = FileInfo::resolvePath(product.project->topLevelProject->buildDirectory, buildDir); - product.item->setProperty(StringConstants::buildDirectoryProperty(), - VariantValue::create(buildDir)); - const QString sourceDir = QFileInfo(product.item->file()->filePath()).absolutePath(); - product.item->setProperty(StringConstants::sourceDirectoryProperty(), - VariantValue::create(sourceDir)); -} - -void ModuleLoader::handleSubProject(ModuleLoader::ProjectContext *projectContext, Item *projectItem, - const Set<QString> &referencedFilePaths) -{ - qCDebug(lcModuleLoader) << "handleSubProject" << projectItem->file()->filePath(); - - Item * const propertiesItem = projectItem->child(ItemType::PropertiesInSubProject); - if (!checkItemCondition(projectItem)) - return; - if (propertiesItem) { - propertiesItem->setScope(projectItem); - if (!checkItemCondition(propertiesItem)) - return; - } - - Item *loadedItem; - QString subProjectFilePath; - try { - const QString projectFileDirPath = FileInfo::path(projectItem->file()->filePath()); - const QString relativeFilePath - = m_evaluator->stringValue(projectItem, StringConstants::filePathProperty()); - subProjectFilePath = FileInfo::resolvePath(projectFileDirPath, relativeFilePath); - if (referencedFilePaths.contains(subProjectFilePath)) - throw ErrorInfo(Tr::tr("Cycle detected while loading subproject file '%1'.") - .arg(relativeFilePath), projectItem->location()); - loadedItem = loadItemFromFile(subProjectFilePath, projectItem->location()); - } catch (const ErrorInfo &error) { - if (m_parameters.productErrorMode() == ErrorHandlingMode::Strict) - throw; - m_logger.printWarning(error); - return; - } - - loadedItem = wrapInProjectIfNecessary(loadedItem); - const bool inheritProperties = m_evaluator->boolValue( - projectItem, StringConstants::inheritPropertiesProperty()); - - if (inheritProperties) - copyProperties(projectItem->parent(), loadedItem); - if (propertiesItem) { - const Item::PropertyMap &overriddenProperties = propertiesItem->properties(); - for (Item::PropertyMap::ConstIterator it = overriddenProperties.constBegin(); - it != overriddenProperties.constEnd(); ++it) { - loadedItem->setProperty(it.key(), it.value()); - } - } - - Item::addChild(projectItem, loadedItem); - projectItem->setScope(projectContext->scope); - handleProject(projectContext->result, projectContext->topLevelProject, loadedItem, - Set<QString>(referencedFilePaths) << subProjectFilePath); -} - -QList<Item *> ModuleLoader::loadReferencedFile(const QString &relativePath, - const CodeLocation &referencingLocation, - const Set<QString> &referencedFilePaths, - ModuleLoader::ProductContext &dummyContext) -{ - QString absReferencePath = FileInfo::resolvePath(FileInfo::path(referencingLocation.filePath()), - relativePath); - if (FileInfo(absReferencePath).isDir()) { - QString qbsFilePath; - - QDirIterator dit(absReferencePath, StringConstants::qbsFileWildcards()); - while (dit.hasNext()) { - if (!qbsFilePath.isEmpty()) { - throw ErrorInfo(Tr::tr("Referenced directory '%1' contains more than one " - "qbs file.").arg(absReferencePath), referencingLocation); - } - qbsFilePath = dit.next(); - } - if (qbsFilePath.isEmpty()) { - throw ErrorInfo(Tr::tr("Referenced directory '%1' does not contain a qbs file.") - .arg(absReferencePath), referencingLocation); - } - absReferencePath = qbsFilePath; - } - if (referencedFilePaths.contains(absReferencePath)) - throw ErrorInfo(Tr::tr("Cycle detected while referencing file '%1'.").arg(relativePath), - referencingLocation); - Item * const subItem = loadItemFromFile(absReferencePath, referencingLocation); - if (subItem->type() != ItemType::Project && subItem->type() != ItemType::Product) { - ErrorInfo error(Tr::tr("Item type should be 'Product' or 'Project', but is '%1'.") - .arg(subItem->typeName())); - error.append(Tr::tr("Item is defined here."), subItem->location()); - error.append(Tr::tr("File is referenced here."), referencingLocation); - throw error; - } - subItem->setScope(dummyContext.project->scope); - subItem->setParent(dummyContext.project->item); - QList<Item *> loadedItems; - loadedItems << subItem; - if (subItem->type() == ItemType::Product) { - handleProfileItems(subItem, dummyContext.project); - loadedItems << multiplexProductItem(&dummyContext, subItem); - } - return loadedItems; -} - -void ModuleLoader::handleGroup(ProductContext *productContext, Item *groupItem, - const ModuleDependencies &reverseDepencencies) -{ - checkCancelation(); - propagateModulesFromParent(productContext, groupItem, reverseDepencencies); - checkItemCondition(groupItem); - for (Item * const child : groupItem->children()) { - if (child->type() == ItemType::Group) - handleGroup(productContext, child, reverseDepencencies); - } -} - -void ModuleLoader::handleAllPropertyOptionsItems(Item *item) -{ - QList<Item *> childItems = item->children(); - auto childIt = childItems.begin(); - while (childIt != childItems.end()) { - Item * const child = *childIt; - if (child->type() == ItemType::PropertyOptions) { - handlePropertyOptions(child); - childIt = childItems.erase(childIt); - } else { - handleAllPropertyOptionsItems(child); - ++childIt; - } - } - item->setChildren(childItems); -} - -void ModuleLoader::handlePropertyOptions(Item *optionsItem) -{ - const QString name = m_evaluator->stringValue(optionsItem, StringConstants::nameProperty()); - if (name.isEmpty()) { - throw ErrorInfo(Tr::tr("PropertyOptions item needs a name property"), - optionsItem->location()); - } - const QString description = m_evaluator->stringValue( - optionsItem, StringConstants::descriptionProperty()); - const auto removalVersion = Version::fromString(m_evaluator->stringValue(optionsItem, - StringConstants::removalVersionProperty())); - const auto allowedValues = m_evaluator->stringListValue( - optionsItem, StringConstants::allowedValuesProperty()); - - PropertyDeclaration decl = optionsItem->parent()->propertyDeclaration(name); - if (!decl.isValid()) { - decl.setName(name); - decl.setType(PropertyDeclaration::Variant); - } - decl.setDescription(description); - if (removalVersion.isValid()) { - DeprecationInfo di(removalVersion, description); - decl.setDeprecationInfo(di); - } - decl.setAllowedValues(allowedValues); - const ValuePtr property = optionsItem->parent()->property(name); - if (!property && !decl.isExpired()) { - throw ErrorInfo(Tr::tr("PropertyOptions item refers to non-existing property '%1'") - .arg(name), optionsItem->location()); - } - if (property && decl.isExpired()) { - ErrorInfo e(Tr::tr("Property '%1' was scheduled for removal in version %2, but " - "is still present.") - .arg(name, removalVersion.toString()), - property->location()); - e.append(Tr::tr("Removal version for '%1' specified here.").arg(name), - optionsItem->location()); - m_logger.printWarning(e); - } - optionsItem->parent()->setPropertyDeclaration(name, decl); -} - -static void mergeProperty(Item *dst, const QString &name, const ValuePtr &value) -{ - if (value->type() == Value::ItemValueType) { - const ItemValueConstPtr itemValue = std::static_pointer_cast<ItemValue>(value); - const Item * const valueItem = itemValue->item(); - Item * const subItem = dst->itemProperty(name, itemValue)->item(); - for (QMap<QString, ValuePtr>::const_iterator it = valueItem->properties().constBegin(); - it != valueItem->properties().constEnd(); ++it) - mergeProperty(subItem, it.key(), it.value()); - } else { - // If the property already exists set up the base value. - if (value->type() == Value::JSSourceValueType) { - const auto jsValue = static_cast<JSSourceValue *>(value.get()); - if (jsValue->isBuiltinDefaultValue()) - return; - const ValuePtr baseValue = dst->property(name); - if (baseValue) { - QBS_CHECK(baseValue->type() == Value::JSSourceValueType); - const JSSourceValuePtr jsBaseValue = std::static_pointer_cast<JSSourceValue>( - baseValue->clone()); - jsValue->setBaseValue(jsBaseValue); - std::vector<JSSourceValue::Alternative> alternatives = jsValue->alternatives(); - jsValue->clearAlternatives(); - for (JSSourceValue::Alternative &a : alternatives) { - a.value->setBaseValue(jsBaseValue); - jsValue->addAlternative(a); - } - } - } - dst->setProperty(name, value); - } -} - -bool ModuleLoader::checkExportItemCondition(Item *exportItem, const ProductContext &productContext) -{ - class ScopeHandler { - public: - ScopeHandler(Item *exportItem, const ProductContext &productContext, Item **cachedScopeItem) - : m_exportItem(exportItem) - { - if (!*cachedScopeItem) - *cachedScopeItem = Item::create(exportItem->pool(), ItemType::Scope); - Item * const scope = *cachedScopeItem; - QBS_CHECK(productContext.item->file()); - scope->setFile(productContext.item->file()); - scope->setScope(productContext.item); - productContext.project->scope->copyProperty(StringConstants::projectVar(), scope); - productContext.scope->copyProperty(StringConstants::productVar(), scope); - QBS_CHECK(!exportItem->scope()); - exportItem->setScope(scope); - } - ~ScopeHandler() { m_exportItem->setScope(nullptr); } - - private: - Item * const m_exportItem; - } scopeHandler(exportItem, productContext, &m_tempScopeItem); - return checkItemCondition(exportItem); -} - -void ModuleLoader::printProfilingInfo() -{ - if (!m_parameters.logElapsedTime()) - return; - m_logger.qbsLog(LoggerInfo, true) << "\t" - << Tr::tr("Project file loading and parsing took %1.") - .arg(elapsedTimeString(m_reader->elapsedTime())); - m_logger.qbsLog(LoggerInfo, true) << "\t" - << Tr::tr("Preparing products took %1.") - .arg(elapsedTimeString(m_elapsedTimePrepareProducts)); - m_logger.qbsLog(LoggerInfo, true) << "\t" - << Tr::tr("Setting up product dependencies took %1.") - .arg(elapsedTimeString(m_elapsedTimeProductDependencies)); - m_logger.qbsLog(LoggerInfo, true) << "\t\t" - << Tr::tr("Running module providers took %1.") - .arg(elapsedTimeString(m_elapsedTimeModuleProviders)); - m_logger.qbsLog(LoggerInfo, true) << "\t\t" - << Tr::tr("Setting up transitive product dependencies took %1.") - .arg(elapsedTimeString(m_elapsedTimeTransitiveDependencies)); - m_logger.qbsLog(LoggerInfo, true) << "\t" - << Tr::tr("Handling products took %1.") - .arg(elapsedTimeString(m_elapsedTimeHandleProducts)); - m_probesResolver->printProfilingInfo(); - m_logger.qbsLog(LoggerInfo, true) << "\t" - << Tr::tr("Property checking took %1.") - .arg(elapsedTimeString(m_elapsedTimePropertyChecking)); -} - -static void mergeParameters(QVariantMap &dst, const QVariantMap &src) -{ - for (auto it = src.begin(); it != src.end(); ++it) { - if (it.value().userType() == QMetaType::QVariantMap) { - QVariant &vdst = dst[it.key()]; - QVariantMap mdst = vdst.toMap(); - mergeParameters(mdst, it.value().toMap()); - vdst = mdst; - } else { - dst[it.key()] = it.value(); - } - } -} - -static void adjustParametersScopes(Item *item, Item *scope) -{ - if (item->type() == ItemType::ModuleParameters) { - item->setScope(scope); - return; - } - - for (const auto &value : item->properties()) { - if (value->type() != Value::ItemValueType) - continue; - adjustParametersScopes(std::static_pointer_cast<ItemValue>(value)->item(), scope); - } -} - -bool ModuleLoader::mergeExportItems(const ProductContext &productContext) -{ - std::vector<Item *> exportItems; - QList<Item *> children = productContext.item->children(); - - auto isExport = [](Item *item) { return item->type() == ItemType::Export; }; - std::copy_if(children.cbegin(), children.cend(), std::back_inserter(exportItems), isExport); - qbs::Internal::removeIf(children, isExport); - - // Note that we do not return if there are no Export items: The "merged" item becomes the - // "product module", which always needs to exist, regardless of whether the product sources - // actually contain an Export item or not. - if (!exportItems.empty()) - productContext.item->setChildren(children); - - Item *merged = Item::create(productContext.item->pool(), ItemType::Export); - const QString &nameKey = StringConstants::nameProperty(); - const ValuePtr nameValue = VariantValue::create(productContext.name); - merged->setProperty(nameKey, nameValue); - Set<FileContextConstPtr> filesWithExportItem; - ProductModuleInfo pmi; - bool hasDependenciesOnProductType = false; - for (Item * const exportItem : qAsConst(exportItems)) { - checkCancelation(); - if (Q_UNLIKELY(filesWithExportItem.contains(exportItem->file()))) - throw ErrorInfo(Tr::tr("Multiple Export items in one product are prohibited."), - exportItem->location()); - exportItem->setProperty(nameKey, nameValue); - if (!checkExportItemCondition(exportItem, productContext)) - continue; - filesWithExportItem += exportItem->file(); - for (Item * const child : exportItem->children()) { - if (child->type() == ItemType::Parameters) { - adjustParametersScopes(child, child); - mergeParameters(pmi.defaultParameters, getJsVariant( - m_evaluator->engine()->context(), m_evaluator->scriptValue(child)).toMap()); - } else { - if (child->type() == ItemType::Depends) { - bool productTypesIsSet; - m_evaluator->stringValue(child, StringConstants::productTypesProperty(), - QString(), &productTypesIsSet); - if (productTypesIsSet) - hasDependenciesOnProductType = true; - } - Item::addChild(merged, child); - } - } - const Item::PropertyDeclarationMap &decls = exportItem->propertyDeclarations(); - for (auto it = decls.constBegin(); it != decls.constEnd(); ++it) { - const PropertyDeclaration &newDecl = it.value(); - const PropertyDeclaration &existingDecl = merged->propertyDeclaration(it.key()); - if (existingDecl.isValid() && existingDecl.type() != newDecl.type()) { - ErrorInfo error(Tr::tr("Export item in inherited item redeclares property " - "'%1' with different type.").arg(it.key()), exportItem->location()); - handlePropertyError(error, m_parameters, m_logger); - } - merged->setPropertyDeclaration(newDecl.name(), newDecl); - } - for (QMap<QString, ValuePtr>::const_iterator it = exportItem->properties().constBegin(); - it != exportItem->properties().constEnd(); ++it) { - mergeProperty(merged, it.key(), it.value()); - } - } - merged->setFile(exportItems.empty() - ? productContext.item->file() : exportItems.back()->file()); - merged->setLocation(exportItems.empty() - ? productContext.item->location() : exportItems.back()->location()); - Item::addChild(productContext.item, merged); - merged->setupForBuiltinType(m_parameters.deprecationWarningMode(), m_logger); - pmi.exportItem = merged; - pmi.multiplexId = productContext.multiplexConfigurationId; - productContext.project->topLevelProject->productModules.insert(productContext.name, pmi); - if (hasDependenciesOnProductType) - m_exportsWithDeferredDependsItems.insert(merged); - return !exportItems.empty(); -} - -Item *ModuleLoader::loadItemFromFile(const QString &filePath, - const CodeLocation &referencingLocation) -{ - Item *item = m_reader->readFile(filePath, referencingLocation); - handleAllPropertyOptionsItems(item); - return item; -} - -void ModuleLoader::handleProfileItems(Item *item, ProjectContext *projectContext) -{ - const std::vector<Item *> profileItems = collectProfileItems(item, projectContext); - for (Item * const profileItem : profileItems) { - try { - handleProfile(profileItem); - } catch (const ErrorInfo &e) { - handlePropertyError(e, m_parameters, m_logger); - } - } -} - -std::vector<Item *> ModuleLoader::collectProfileItems(Item *item, ProjectContext *projectContext) -{ - QList<Item *> childItems = item->children(); - std::vector<Item *> profileItems; - Item * scope = item->type() == ItemType::Project ? projectContext->scope : nullptr; - for (auto it = childItems.begin(); it != childItems.end();) { - Item * const childItem = *it; - if (childItem->type() == ItemType::Profile) { - if (!scope) { - const ItemValuePtr itemValue = ItemValue::create(item); - scope = Item::create(m_pool, ItemType::Scope); - scope->setProperty(StringConstants::productVar(), itemValue); - scope->setFile(item->file()); - scope->setScope(projectContext->scope); - } - childItem->setScope(scope); - profileItems.push_back(childItem); - it = childItems.erase(it); - } else { - if (childItem->type() == ItemType::Product) { - for (Item * const profileItem : collectProfileItems(childItem, projectContext)) - profileItems.push_back(profileItem); - } - ++it; - } - } - if (!profileItems.empty()) - item->setChildren(childItems); - return profileItems; -} - -void ModuleLoader::evaluateProfileValues(const QualifiedId &namePrefix, Item *item, - Item *profileItem, QVariantMap &values) -{ - const Item::PropertyMap &props = item->properties(); - for (auto it = props.begin(); it != props.end(); ++it) { - QualifiedId name = namePrefix; - name << it.key(); - switch (it.value()->type()) { - case Value::ItemValueType: - evaluateProfileValues(name, std::static_pointer_cast<ItemValue>(it.value())->item(), - profileItem, values); - break; - case Value::VariantValueType: - values.insert(name.join(QLatin1Char('.')), - std::static_pointer_cast<VariantValue>(it.value())->value()); - break; - case Value::JSSourceValueType: - item->setType(ItemType::ModulePrefix); // TODO: Introduce new item type - if (item != profileItem) - item->setScope(profileItem); - const ScopedJsValue sv(m_evaluator->engine()->context(), - m_evaluator->value(item, it.key())); - values.insert(name.join(QLatin1Char('.')), - getJsVariant(m_evaluator->engine()->context(), sv)); - break; - } - } -} - -void ModuleLoader::handleProfile(Item *profileItem) -{ - QVariantMap values; - evaluateProfileValues(QualifiedId(), profileItem, profileItem, values); - const bool condition = values.take(StringConstants::conditionProperty()).toBool(); - if (!condition) - return; - const QString profileName = values.take(StringConstants::nameProperty()).toString(); - if (profileName.isEmpty()) - throw ErrorInfo(Tr::tr("Every Profile item must have a name"), profileItem->location()); - if (profileName == Profile::fallbackName()) { - throw ErrorInfo(Tr::tr("Reserved name '%1' cannot be used for an actual profile.") - .arg(profileName), profileItem->location()); - } - if (m_localProfiles.contains(profileName)) { - throw ErrorInfo(Tr::tr("Local profile '%1' redefined.").arg(profileName), - profileItem->location()); - } - m_localProfiles.insert(profileName, values); -} - -void ModuleLoader::collectNameFromOverride(const QString &overrideString) -{ - static const auto extract = [](const QString &prefix, const QString &overrideString) { - if (!overrideString.startsWith(prefix)) - return QString(); - const int startPos = prefix.length(); - const int endPos = overrideString.lastIndexOf(StringConstants::dot()); - if (endPos == -1) - return QString(); - return overrideString.mid(startPos, endPos - startPos); - }; - const QString &projectName = extract(StringConstants::projectsOverridePrefix(), overrideString); - if (!projectName.isEmpty()) { - m_projectNamesUsedInOverrides.insert(projectName); - return; - } - const QString &productName = extract(StringConstants::productsOverridePrefix(), overrideString); - if (!productName.isEmpty()) { - m_productNamesUsedInOverrides.insert(productName.left( - productName.indexOf(StringConstants::dot()))); - return; - } -} - -void ModuleLoader::checkProjectNamesInOverrides(const ModuleLoader::TopLevelProjectContext &tlp) -{ - for (const QString &projectNameInOverride : m_projectNamesUsedInOverrides) { - if (m_disabledProjects.contains(projectNameInOverride)) - continue; - bool found = false; - for (const ProjectContext * const p : tlp.projects) { - if (p->name == projectNameInOverride) { - found = true; - break; - } - } - if (!found) { - handlePropertyError(Tr::tr("Unknown project '%1' in property override.") - .arg(projectNameInOverride), m_parameters, m_logger); - } - } -} - -void ModuleLoader::checkProductNamesInOverrides() -{ - for (const QString &productNameInOverride : m_productNamesUsedInOverrides) { - if (m_erroneousProducts.contains(productNameInOverride)) - continue; - bool found = false; - for (const auto &kv : m_productsByName) { - // In an override string such as "a.b.c:d, we cannot tell whether we have a product - // "a" and a module "b.c" or a product "a.b" and a module "c", so we need to take - // care not to emit false positives here. - if (kv.first == productNameInOverride - || kv.first.startsWith(productNameInOverride + StringConstants::dot())) { - found = true; - break; - } - } - if (!found) { - handlePropertyError(Tr::tr("Unknown product '%1' in property override.") - .arg(productNameInOverride), m_parameters, m_logger); - } - } -} - -void ModuleLoader::setSearchPathsForProduct(ModuleLoader::ProductContext *product) -{ - product->searchPaths = readExtraSearchPaths(product->item); - Settings settings(m_parameters.settingsDirectory()); - const QVariantMap profileContents = product->project->result->profileConfigs - .value(product->profileName).toMap(); - const QStringList prefsSearchPaths = Preferences(&settings, profileContents).searchPaths(); - const QStringList ¤tSearchPaths = m_reader->allSearchPaths(); - for (const QString &p : prefsSearchPaths) { - if (!currentSearchPaths.contains(p) && FileInfo(p).exists()) - product->searchPaths << p; - } -} - -ModuleLoader::ShadowProductInfo ModuleLoader::getShadowProductInfo( - const ModuleLoader::ProductContext &product) const -{ - const bool isShadowProduct = product.name.startsWith(StringConstants::shadowProductPrefix()); - return std::make_pair(isShadowProduct, isShadowProduct - ? product.name.mid(StringConstants::shadowProductPrefix().size()) - : QString()); -} - -void ModuleLoader::collectProductsByName(const TopLevelProjectContext &topLevelProject) -{ - for (ProjectContext * const project : topLevelProject.projects) { - for (ProductContext &product : project->products) - m_productsByName.insert({ product.name, &product }); - } -} - -void ModuleLoader::collectProductsByType(const ModuleLoader::TopLevelProjectContext &topLevelProject) -{ - for (ProjectContext * const project : topLevelProject.projects) { - for (ProductContext &product : project->products) { - try { - const FileTags productTags - = m_evaluator->fileTagsValue(product.item, StringConstants::typeProperty()); - for (const FileTag &tag : productTags) - m_productsByType.insert({ tag, &product}); - } catch (const ErrorInfo &) { - qCDebug(lcModuleLoader) << "product" << product.name << "has complex type " - " and won't get an entry in the type map"; - } - } - } -} - -void ModuleLoader::propagateModulesFromParent(ProductContext *productContext, Item *groupItem, - const ModuleDependencies &reverseDepencencies) -{ - QBS_CHECK(groupItem->type() == ItemType::Group); - QHash<QualifiedId, Item *> moduleInstancesForGroup; - - // Step 1: Instantiate the product's modules for the group. - for (Item::Module m : groupItem->parent()->modules()) { - Item *targetItem = moduleInstanceItem(groupItem, m.name); - targetItem->setPrototype(m.item); - - Item * const moduleScope = Item::create(targetItem->pool(), ItemType::Scope); - moduleScope->setFile(groupItem->file()); - moduleScope->setProperties(m.item->scope()->properties()); // "project", "product", ids - moduleScope->setScope(groupItem); - targetItem->setScope(moduleScope); - - targetItem->setFile(m.item->file()); - - // "parent" should point to the group/artifact parent - targetItem->setParent(groupItem->parent()); - - targetItem->setOuterItem(m.item); - - m.item = targetItem; - groupItem->addModule(m); - moduleInstancesForGroup.insert(m.name, targetItem); - } - - // Step 2: Make the inter-module references point to the instances created in step 1. - for (const Item::Module &module : groupItem->modules()) { - Item::Modules adaptedModules; - const Item::Modules &oldModules = module.item->prototype()->modules(); - for (Item::Module depMod : oldModules) { - depMod.item = moduleInstancesForGroup.value(depMod.name); - adaptedModules << depMod; - if (depMod.name.front() == module.name.front()) - continue; - const ItemValuePtr &modulePrefix = groupItem->itemProperty(depMod.name.front()); - QBS_CHECK(modulePrefix); - module.item->setProperty(depMod.name.front(), modulePrefix); - } - module.item->setModules(adaptedModules); - } - - const QualifiedIdSet &propsSetInGroup = gatherModulePropertiesSetInGroup(groupItem); - if (propsSetInGroup.empty()) - return; - productContext->info.modulePropertiesSetInGroups - .insert(std::make_pair(groupItem, propsSetInGroup)); - - // Step 3: Adapt defining items in values. This is potentially necessary if module properties - // get assigned on the group level. - for (const Item::Module &module : groupItem->modules()) { - const QualifiedIdSet &dependents = reverseDepencencies.value(module.name); - Item::Modules dependentModules; - dependentModules.reserve(int(dependents.size())); - for (const QualifiedId &depName : dependents) { - Item * const itemOfDependent = moduleInstancesForGroup.value(depName); - QBS_CHECK(itemOfDependent); - Item::Module depMod; - depMod.name = depName; - depMod.item = itemOfDependent; - dependentModules << depMod; - } - adjustDefiningItemsInGroupModuleInstances(module, dependentModules); - } -} - -static Item *createReplacementForDefiningItem(const Item *definingItem, ItemType type) -{ - Item *replacement = Item::create(definingItem->pool(), type); - replacement->setLocation(definingItem->location()); - definingItem->copyProperty(StringConstants::nameProperty(), replacement); - return replacement; -} - -void ModuleLoader::adjustDefiningItemsInGroupModuleInstances(const Item::Module &module, - const Item::Modules &dependentModules) -{ - if (!module.item->isPresentModule()) - return; - - // There are three cases: - // a) The defining item is the "main" module instance, i.e. the one instantiated in the - // product directly (or a parent group). - // b) The defining item refers to the module prototype (or the replacement of it - // created in the module merger [for products] or in this function [for parent groups]). - // c) The defining item is a different instance of the module, i.e. it was instantiated - // in some other module. - - std::unordered_map<Item *, Item *> definingItemReplacements; - - Item *modulePrototype = rootPrototype(module.item->prototype()); - QBS_CHECK(modulePrototype->type() == ItemType::Module - || modulePrototype->type() == ItemType::Export); - - const Item::PropertyDeclarationMap &propDecls = modulePrototype->propertyDeclarations(); - for (const auto &decl : propDecls) { - const QString &propName = decl.name(); - - // Module properties assigned in the group are not relevant here, as nothing - // gets inherited in that case. In particular, setting a list property - // overwrites the value from the product's (or parent group's) instance completely, - // rather than appending to it (concatenation happens via outer.concat()). - ValueConstPtr propValue = module.item->ownProperty(propName); - if (propValue) - continue; - - // Find the nearest prototype instance that has the value assigned. - // The result is either an instance of a parent group (or the parent group's - // parent group and so on) or the instance of the product or the module prototype. - // In the latter case, we don't have to do anything. - const Item *instanceWithProperty = module.item; - int prototypeChainLen = 0; - do { - instanceWithProperty = instanceWithProperty->prototype(); - QBS_CHECK(instanceWithProperty); - ++prototypeChainLen; - propValue = instanceWithProperty->ownProperty(propName); - } while (!propValue); - QBS_CHECK(propValue); - - if (propValue->type() != Value::JSSourceValueType) - continue; - - bool hasDefiningItem = false; - for (ValueConstPtr v = propValue; v && !hasDefiningItem; v = v->next()) - hasDefiningItem = v->definingItem(); - if (!hasDefiningItem) - continue; - - const ValuePtr clonedValue = propValue->clone(); - for (ValuePtr v = clonedValue; v; v = v->next()) { - QBS_CHECK(v->definingItem()); - - Item *& replacement = definingItemReplacements[v->definingItem()]; - static const QString caseA = QStringLiteral("__group_case_a"); - if (v->definingItem() == instanceWithProperty - || v->definingItem()->variantProperty(caseA)) { - // Case a) - // For values whose defining item is the product's (or parent group's) instance, - // we take its scope and replace references to module instances with those from the - // group's instance. This handles cases like the following: - // Product { - // name: "theProduct" - // aModule.listProp: [name, otherModule.stringProp] - // Group { name: "theGroup"; otherModule.stringProp: name } - // ... - // } - // In the above example, aModule.listProp is set to ["theProduct", "theGroup"] - // (plus potential values from the prototype and other module instances, - // which are different Value objects in the "next chain"). - if (!replacement) { - replacement = createReplacementForDefiningItem(v->definingItem(), - v->definingItem()->type()); - Item * const scope = Item::create(v->definingItem()->pool(), ItemType::Scope); - scope->setProperties(module.item->scope()->properties()); - Item * const scopeScope - = Item::create(v->definingItem()->pool(), ItemType::Scope); - scopeScope->setProperties(v->definingItem()->scope()->scope()->properties()); - scope->setScope(scopeScope); - replacement->setScope(scope); - const Item::PropertyMap &groupScopeProperties - = module.item->scope()->scope()->properties(); - for (auto propIt = groupScopeProperties.begin(); - propIt != groupScopeProperties.end(); ++propIt) { - if (propIt.value()->type() == Value::ItemValueType) - scopeScope->setProperty(propIt.key(), propIt.value()); - } - } - replacement->setPropertyDeclaration(propName, decl); - replacement->setProperty(propName, v); - replacement->setProperty(caseA, VariantValue::invalidValue()); - } else if (v->definingItem()->type() == ItemType::Module) { - // Case b) - // For values whose defining item is the module prototype, we change the scope to - // the group's instance, analogous to what we do in - // ModuleMerger::appendPrototypeValueToNextChain(). - QBS_CHECK(!decl.isScalar()); - QBS_CHECK(!v->next()); - Item *& replacement = definingItemReplacements[v->definingItem()]; - if (!replacement) { - replacement = createReplacementForDefiningItem(v->definingItem(), - ItemType::Module); - replacement->setScope(module.item); - } - QBS_CHECK(!replacement->hasOwnProperty(caseA)); - qCDebug(lcModuleLoader).noquote().nospace() - << "replacing defining item for prototype; module is " - << module.name.toString() << module.item - << ", property is " << propName - << ", old defining item was " << v->definingItem() - << " with scope" << v->definingItem()->scope() - << ", new defining item is" << replacement - << " with scope" << replacement->scope(); - if (v->type() == Value::JSSourceValueType) { - qCDebug(lcModuleLoader) << "value source code is" - << std::static_pointer_cast<JSSourceValue>(v)->sourceCode().toString(); - } - replacement->setPropertyDeclaration(propName, decl); - replacement->setProperty(propName, v); - } else { - // Look for instance scopes of other module instances in defining items and - // replace the affected values. - // This is case c) as introduced above. See ModuleMerger::replaceItemInScopes() - // for a detailed explanation. - - QBS_CHECK(v->definingItem()->scope() && v->definingItem()->scope()->scope()); - bool found = false; - for (const Item::Module &depMod : dependentModules) { - const Item *depModPrototype = depMod.item->prototype(); - for (int i = 1; i < prototypeChainLen; ++i) - depModPrototype = depModPrototype->prototype(); - if (v->definingItem()->scope()->scope() != depModPrototype) - continue; - - found = true; - Item *& replacement = definingItemReplacements[v->definingItem()]; - if (!replacement) { - replacement = createReplacementForDefiningItem(v->definingItem(), - v->definingItem()->type()); - replacement->setProperties(v->definingItem()->properties()); - for (const auto &decl : v->definingItem()->propertyDeclarations()) - replacement->setPropertyDeclaration(decl.name(), decl); - replacement->setPrototype(v->definingItem()->prototype()); - replacement->setScope(Item::create(v->definingItem()->pool(), - ItemType::Scope)); - replacement->scope()->setScope(depMod.item); - } - QBS_CHECK(!replacement->hasOwnProperty(caseA)); - qCDebug(lcModuleLoader) << "reset instance scope of module" - << depMod.name.toString() << "in property" - << propName << "of module" << module.name; - } - QBS_CHECK(found); - } - QBS_CHECK(replacement); - v->setDefiningItem(replacement); - } - module.item->setProperty(propName, clonedValue); - } -} - -void ModuleLoader::resolveDependencies(DependsContext *dependsContext, Item *item, - ProductContext *productContext) -{ - QBS_CHECK(m_dependencyResolvingPass == 1 || m_dependencyResolvingPass == 2); - - if (!productContext || m_dependencyResolvingPass == 1) { - const Item::Module baseModule = loadBaseModule(dependsContext->product, item); - item->addModule(baseModule); - } - - // Resolve all Depends items. - ItemModuleList loadedModules; - QList<Item *> dependsItemPerLoadedModule; - ProductDependencies productDependencies; - const auto handleDependsItem = [&](Item *child) { - if (child->type() != ItemType::Depends) - return; - - int lastModulesCount = loadedModules.size(); - try { - resolveDependsItem(dependsContext, child->parent(), child, &loadedModules, - &productDependencies); - } catch (const ErrorInfo &e) { - if (!productContext) - throw; - handleProductError(e, productContext); - } - for (int i = lastModulesCount; i < loadedModules.size(); ++i) - dependsItemPerLoadedModule.push_back(child); - - }; - if (productContext && m_dependencyResolvingPass == 2) { - for (const auto &deferData : productContext->deferredDependsItems) { - dependsContext->exportingProductItem = deferData.first; - for (Item * const dependsItem : deferData.second) - handleDependsItem(dependsItem); - } - } else { - for (Item * const child : item->children()) - handleDependsItem(child); - } - QBS_CHECK(loadedModules.size() == dependsItemPerLoadedModule.size()); - - Item *lastDependsItem = nullptr; - for (Item * const dependsItem : dependsItemPerLoadedModule) { - if (dependsItem == lastDependsItem) - continue; - adjustParametersScopes(dependsItem, dependsItem); - forwardParameterDeclarations(dependsItem, loadedModules); - lastDependsItem = dependsItem; - } - - for (int i = 0; i < loadedModules.size(); ++i) { - Item::Module &module = loadedModules[i]; - mergeParameters(module.parameters, extractParameters(dependsItemPerLoadedModule.at(i))); - item->addModule(module); - - const QString moduleName = module.name.toString(); - std::for_each(productDependencies.begin(), productDependencies.end(), - [&module, &moduleName] (ModuleLoaderResult::ProductInfo::Dependency &dep) { - if (dep.name == moduleName) - dep.parameters = module.parameters; - }); - } - - dependsContext->productDependencies->insert( - dependsContext->productDependencies->end(), - productDependencies.cbegin(), productDependencies.cend()); -} - -class RequiredChainManager -{ -public: - RequiredChainManager(std::vector<bool> &requiredChain, bool required) - : m_requiredChain(requiredChain) - { - m_requiredChain.push_back(required); - } - - ~RequiredChainManager() { m_requiredChain.pop_back(); } - -private: - std::vector<bool> &m_requiredChain; -}; - -void ModuleLoader::resolveDependsItem(DependsContext *dependsContext, Item *parentItem, - Item *dependsItem, ItemModuleList *moduleResults, - ProductDependencies *productResults) -{ - checkCancelation(); - if (!checkItemCondition(dependsItem)) { - qCDebug(lcModuleLoader) << "Depends item disabled, ignoring."; - return; - } - bool nameIsSet; - const QString name = m_evaluator->stringValue(dependsItem, StringConstants::nameProperty(), - QString(), &nameIsSet); - bool submodulesPropertySet; - const QStringList submodules = m_evaluator->stringListValue( - dependsItem, StringConstants::submodulesProperty(), &submodulesPropertySet); - if (submodules.empty() && submodulesPropertySet) { - qCDebug(lcModuleLoader) << "Ignoring Depends item with empty submodules list."; - return; - } - if (Q_UNLIKELY(submodules.size() > 1 && !dependsItem->id().isEmpty())) { - QString msg = Tr::tr("A Depends item with more than one module cannot have an id."); - throw ErrorInfo(msg, dependsItem->location()); - } - const FallbackMode fallbackMode = m_parameters.fallbackProviderEnabled() - && m_evaluator->boolValue(dependsItem, StringConstants::enableFallbackProperty()) - ? FallbackMode::Enabled : FallbackMode::Disabled; - - QList<QualifiedId> moduleNames; - const QualifiedId nameParts = QualifiedId::fromString(name); - if (submodules.empty()) { - // Ignore explicit dependencies on the base module, which has already been loaded. - if (name == StringConstants::qbsModule()) - return; - - moduleNames << nameParts; - } else { - for (const QString &submodule : submodules) - moduleNames << nameParts + QualifiedId::fromString(submodule); - } - - Item::Module result; - bool productTypesIsSet; - m_evaluator->stringValue(dependsItem, StringConstants::productTypesProperty(), - QString(), &productTypesIsSet); - if (m_dependencyResolvingPass == 1 && productTypesIsSet) { - qCDebug(lcModuleLoader) << "queuing product" << dependsContext->product->name - << "for a second dependencies resolving pass"; - m_productsWithDeferredDependsItems[dependsContext->product].insert( - DeferredDependsContext(dependsContext->exportingProductItem, parentItem)); - return; - } - - const bool isRequiredValue = - m_evaluator->boolValue(dependsItem, StringConstants::requiredProperty()); - const bool isRequired = !productTypesIsSet - && isRequiredValue - && !contains(m_requiredChain, false); - const Version minVersion = Version::fromString( - m_evaluator->stringValue(dependsItem, - StringConstants::versionAtLeastProperty())); - const Version maxVersion = Version::fromString( - m_evaluator->stringValue(dependsItem, StringConstants::versionBelowProperty())); - const VersionRange versionRange(minVersion, maxVersion); - QStringList multiplexConfigurationIds = m_evaluator->stringListValue( - dependsItem, - StringConstants::multiplexConfigurationIdsProperty()); - if (multiplexConfigurationIds.empty()) - multiplexConfigurationIds << QString(); - - for (const QualifiedId &moduleName : qAsConst(moduleNames)) { - // Don't load the same module twice. Duplicate Depends statements can easily - // happen due to inheritance. - const auto it = std::find_if(moduleResults->begin(), moduleResults->end(), - [moduleName](const Item::Module &m) { return m.name == moduleName; }); - if (it != moduleResults->end()) { - it->required = it->required || isRequired; - it->requiredValue = it->requiredValue || isRequiredValue; - it->fallbackEnabled = it->fallbackEnabled && fallbackMode == FallbackMode::Enabled; - it->versionRange.narrowDown(versionRange); - continue; - } - - QVariantMap defaultParameters; - Item *moduleItem = loadModule(dependsContext->product, dependsContext->exportingProductItem, - parentItem, dependsItem->location(), dependsItem->id(), - moduleName, multiplexConfigurationIds.first(), fallbackMode, - isRequired, &result.isProduct, &defaultParameters); - if (!moduleItem) { - const QString productName = ResolvedProduct::fullDisplayName( - dependsContext->product->name, - dependsContext->product->multiplexConfigurationId); - if (!multiplexConfigurationIds.first().isEmpty()) { - const QString depName = ResolvedProduct::fullDisplayName( - moduleName.toString(), multiplexConfigurationIds.first()); - throw ErrorInfo(Tr::tr("Dependency from product '%1' to product '%2' not " - "fulfilled.").arg(productName, depName)); - } - ErrorInfo e(Tr::tr("Dependency '%1' not found for product '%2'.") - .arg(moduleName.toString(), productName), dependsItem->location()); - throw e; - } - if (result.isProduct && !m_dependsChain.empty() && !m_dependsChain.back().isProduct) { - throw ErrorInfo(Tr::tr("Invalid dependency on product '%1': Modules cannot depend on " - "products. You may want to turn your module into a product and " - "add the dependency in that product's Export item.") - .arg(moduleName.toString()), dependsItem->location()); - } - qCDebug(lcModuleLoader) << "module loaded:" << moduleName.toString(); - result.name = moduleName; - result.item = moduleItem; - result.requiredValue = isRequiredValue; - result.required = isRequired; - result.fallbackEnabled = fallbackMode == FallbackMode::Enabled; - result.parameters = defaultParameters; - result.versionRange = versionRange; - moduleResults->push_back(result); - if (result.isProduct) { - qCDebug(lcModuleLoader) << "product dependency loaded:" << moduleName.toString(); - bool profilesPropertyWasSet = false; - QStringList profiles = m_evaluator->stringListValue(dependsItem, - StringConstants::profilesProperty(), - &profilesPropertyWasSet); - if (profiles.empty()) { - if (profilesPropertyWasSet) - profiles.push_back(StringConstants::star()); - else - profiles.push_back(QString()); - } - for (const QString &profile : qAsConst(profiles)) { - for (const QString &multiplexId : qAsConst(multiplexConfigurationIds)) { - ModuleLoaderResult::ProductInfo::Dependency dependency; - dependency.name = moduleName.toString(); - dependency.profile = profile; - dependency.multiplexConfigurationId = multiplexId; - dependency.isRequired = isRequired; - productResults->push_back(dependency); - } - } - } - } -} - void ModuleLoader::forwardParameterDeclarations(const Item *dependsItem, - const ItemModuleList &modules) + const Item::Modules &modules) { for (auto it = dependsItem->properties().begin(); it != dependsItem->properties().end(); ++it) { if (it.value()->type() != Value::ItemValueType) continue; - forwardParameterDeclarations(it.key(), - std::static_pointer_cast<ItemValue>(it.value())->item(), - modules); + d->forwardParameterDeclarations(it.key(), + std::static_pointer_cast<ItemValue>(it.value())->item(), + modules); } } -void ModuleLoader::forwardParameterDeclarations(const QualifiedId &moduleName, Item *item, - const ItemModuleList &modules) +void ModuleLoader::Private::forwardParameterDeclarations(const QualifiedId &moduleName, Item *item, + const Item::Modules &modules) { auto it = std::find_if(modules.begin(), modules.end(), [&moduleName] (const Item::Module &m) { return m.name == moduleName; }); if (it != modules.end()) { - item->setPropertyDeclarations(m_parameterDeclarations.value(rootPrototype(it->item))); + item->setPropertyDeclarations(parameterDeclarations[it->item->rootPrototype()]); } else { for (auto it = item->properties().begin(); it != item->properties().end(); ++it) { if (it.value()->type() != Value::ItemValueType) @@ -2683,1143 +336,4 @@ void ModuleLoader::forwardParameterDeclarations(const QualifiedId &moduleName, I } } -void ModuleLoader::resolveParameterDeclarations(const Item *module) -{ - Item::PropertyDeclarationMap decls; - const auto &moduleChildren = module->children(); - for (Item *param : moduleChildren) { - if (param->type() != ItemType::Parameter) - continue; - const auto ¶mDecls = param->propertyDeclarations(); - for (auto it = paramDecls.begin(); it != paramDecls.end(); ++it) - decls.insert(it.key(), it.value()); - } - m_parameterDeclarations.insert(module, decls); -} - -static bool isItemValue(const ValuePtr &v) -{ - return v->type() == Value::ItemValueType; -} - -static Item::PropertyMap filterItemProperties(const Item::PropertyMap &properties) -{ - Item::PropertyMap result; - auto itEnd = properties.end(); - for (auto it = properties.begin(); it != itEnd; ++it) { - if (isItemValue(it.value())) - result.insert(it.key(), it.value()); - } - return result; -} - -static QVariantMap safeToVariant(JSContext *ctx, const JSValue &v) -{ - QVariantMap result; - handleJsProperties(ctx, v, [&](const JSAtom &prop, const JSPropertyDescriptor &desc) { - const JSValue u = desc.value; - if (JS_IsError(ctx, u)) - throw ErrorInfo(getJsString(ctx, u)); - const QString name = getJsString(ctx, prop); - result[name] = (JS_IsObject(u) && !JS_IsArray(ctx, u) && !JS_IsRegExp(ctx, u)) - ? safeToVariant(ctx, u) : getJsVariant(ctx, u); - }); - return result; -} - -QVariantMap ModuleLoader::extractParameters(Item *dependsItem) const -{ - QVariantMap result; - const Item::PropertyMap &itemProperties = filterItemProperties( - rootPrototype(dependsItem)->properties()); - if (itemProperties.empty()) - return result; - - auto origProperties = dependsItem->properties(); - dependsItem->setProperties(itemProperties); - JSValue sv = m_evaluator->scriptValue(dependsItem); - try { - result = safeToVariant(m_evaluator->engine()->context(), sv); - } catch (const ErrorInfo &exception) { - auto ei = exception; - ei.prepend(Tr::tr("Error in dependency parameter."), dependsItem->location()); - throw ei; - } - dependsItem->setProperties(origProperties); - return result; -} - -[[noreturn]] static void throwModuleNamePrefixError(const QualifiedId &shortName, - const QualifiedId &longName, const CodeLocation &codeLocation) -{ - throw ErrorInfo(Tr::tr("The name of module '%1' is equal to the first component of the " - "name of module '%2', which is not allowed") - .arg(shortName.toString(), longName.toString()), codeLocation); -} - -Item *ModuleLoader::moduleInstanceItem(Item *containerItem, const QualifiedId &moduleName) -{ - QBS_CHECK(!moduleName.empty()); - Item *instance = containerItem; - for (int i = 0; i < moduleName.size(); ++i) { - const QString &moduleNameSegment = moduleName.at(i); - const ValuePtr v = instance->ownProperty(moduleName.at(i)); - if (v && v->type() == Value::ItemValueType) { - instance = std::static_pointer_cast<ItemValue>(v)->item(); - } else { - const ItemType itemType = i < moduleName.size() - 1 ? ItemType::ModulePrefix - : ItemType::ModuleInstance; - auto newItem = Item::create(m_pool, itemType); - instance->setProperty(moduleNameSegment, ItemValue::create(newItem)); - instance = newItem; - } - if (i < moduleName.size() - 1) { - if (instance->type() == ItemType::ModuleInstance) { - QualifiedId conflictingName = QStringList(moduleName.mid(0, i + 1)); - throwModuleNamePrefixError(conflictingName, moduleName, CodeLocation()); - } - QBS_CHECK(instance->type() == ItemType::ModulePrefix); - } - } - QBS_CHECK(instance != containerItem); - return instance; -} - -ModuleLoader::ProductModuleInfo *ModuleLoader::productModule(ProductContext *productContext, - const QString &name, const QString &multiplexId, bool &productNameMatch) -{ - auto &exportsData = productContext->project->topLevelProject->productModules; - const auto firstIt = exportsData.find(name); - productNameMatch = firstIt != exportsData.end(); - for (auto it = firstIt; it != exportsData.end() && it.key() == name; ++it) { - if (it.value().multiplexId == multiplexId) - return &it.value(); - } - if (multiplexId.isEmpty() && firstIt != exportsData.end()) - return &firstIt.value(); - return nullptr; -} - -ModuleLoader::ProductContext *ModuleLoader::product(ProjectContext *projectContext, - const QString &name) -{ - auto itEnd = projectContext->products.end(); - auto it = std::find_if(projectContext->products.begin(), itEnd, - [&name] (const ProductContext &ctx) { - return ctx.name == name; - }); - return it == itEnd ? nullptr : &*it; -} - -ModuleLoader::ProductContext *ModuleLoader::product(TopLevelProjectContext *tlpContext, - const QString &name) -{ - ProductContext *result = nullptr; - for (auto prj : tlpContext->projects) { - result = product(prj, name); - if (result) - break; - } - return result; -} - -class ModuleLoader::DependsChainManager -{ -public: - DependsChainManager(std::vector<DependsChainEntry> &dependsChain, const QualifiedId &module, - const CodeLocation &dependsLocation) - : m_dependsChain(dependsChain) - { - const bool alreadyInChain = Internal::any_of(dependsChain, - [&module](const DependsChainEntry &e) { - return e.name == module; - }); - if (alreadyInChain) { - ErrorInfo error; - error.append(Tr::tr("Cyclic dependencies detected:")); - for (const DependsChainEntry &e : qAsConst(m_dependsChain)) - error.append(e.name.toString(), e.location); - error.append(module.toString(), dependsLocation); - throw error; - } - m_dependsChain.emplace_back(module, dependsLocation); - } - - ~DependsChainManager() { m_dependsChain.pop_back(); } - -private: - std::vector<DependsChainEntry> &m_dependsChain; -}; - -static bool isBaseModule(QStringView fullModuleName) -{ - return fullModuleName == StringConstants::qbsModule(); -} - -class DelayedPropertyChanger -{ -public: - ~DelayedPropertyChanger() - { - applyNow(); - } - - void setLater(Item *item, const QString &name, const ValuePtr &value) - { - QBS_CHECK(m_item == nullptr); - m_item = item; - m_name = name; - m_value = value; - } - - void removeLater(Item *item, const QString &name) - { - QBS_CHECK(m_item == nullptr); - m_item = item; - m_name = name; - } - - void applyNow() - { - if (!m_item || m_name.isEmpty()) - return; - if (m_value) - m_item->setProperty(m_name, m_value); - else - m_item->removeProperty(m_name); - m_item = nullptr; - m_name.clear(); - m_value.reset(); - } - -private: - Item *m_item = nullptr; - QString m_name; - ValuePtr m_value; -}; - -Item *ModuleLoader::loadModule(ProductContext *productContext, Item *exportingProductItem, - Item *item, const CodeLocation &dependsItemLocation, - const QString &moduleId, const QualifiedId &moduleName, - const QString &multiplexId, FallbackMode fallbackMode, - bool isRequired, bool *isProductDependency, - QVariantMap *defaultParameters) -{ - qCDebug(lcModuleLoader) << "loadModule name:" << moduleName.toString() << "id:" << moduleId; - - RequiredChainManager requiredChainManager(m_requiredChain, isRequired); - DependsChainManager dependsChainManager(m_dependsChain, moduleName, dependsItemLocation); - - Item *moduleInstance = moduleId.isEmpty() - ? moduleInstanceItem(item, moduleName) - : moduleInstanceItem(item, QStringList(moduleId)); - if (moduleInstance->scope()) - return moduleInstance; // already handled - - if (Q_UNLIKELY(moduleInstance->type() == ItemType::ModulePrefix)) { - for (const Item::Module &m : item->modules()) { - if (m.name.front() == moduleName.front()) - throwModuleNamePrefixError(moduleName, m.name, dependsItemLocation); - } - } - QBS_CHECK(moduleInstance->type() == ItemType::ModuleInstance); - - // Prepare module instance for evaluating Module.condition. - DelayedPropertyChanger delayedPropertyChanger; - const QString &qbsModuleName = StringConstants::qbsModule(); - const auto fullName = moduleName.toString(); - if (!isBaseModule(fullName)) { - ItemValuePtr qbsProp = productContext->item->itemProperty(qbsModuleName); - if (qbsProp) { - ValuePtr qbsModuleValue = moduleInstance->ownProperty(qbsModuleName); - if (qbsModuleValue) - delayedPropertyChanger.setLater(moduleInstance, qbsModuleName, qbsModuleValue); - else - delayedPropertyChanger.removeLater(moduleInstance, qbsModuleName); - moduleInstance->setProperty(qbsModuleName, qbsProp); - } - } - - SearchPathsManager searchPathsManager(m_reader.get()); // paths can be added by providers - Item *modulePrototype = nullptr; - ProductModuleInfo * const pmi = productModule(productContext, fullName, - multiplexId, *isProductDependency); - if (pmi) { - m_dependsChain.back().isProduct = true; - modulePrototype = pmi->exportItem; - if (defaultParameters) - *defaultParameters = pmi->defaultParameters; - } else if (!*isProductDependency) { - modulePrototype = searchAndLoadModuleFile(productContext, dependsItemLocation, - moduleName, fallbackMode, isRequired, moduleInstance); - } - delayedPropertyChanger.applyNow(); - if (!modulePrototype) - return nullptr; - - searchPathsManager.reset(); // deps must be processed in a clean state - - instantiateModule(productContext, exportingProductItem, item, moduleInstance, modulePrototype, - moduleName, pmi); - return moduleInstance; -} - -struct PrioritizedItem -{ - PrioritizedItem(Item *item, int priority, int searchPathIndex) - : item(item), priority(priority), searchPathIndex(searchPathIndex) - { - } - - Item *item = nullptr; - int priority = 0; - int searchPathIndex = 0; -}; - -static Item *chooseModuleCandidate(const std::vector<PrioritizedItem> &candidates, - const QString &moduleName) -{ - auto maxIt = std::max_element(candidates.begin(), candidates.end(), - [] (const PrioritizedItem &a, const PrioritizedItem &b) { - if (a.priority < b.priority) - return true; - if (a.priority > b.priority) - return false; - return a.searchPathIndex > b.searchPathIndex; - }); - - size_t nmax = std::count_if(candidates.begin(), candidates.end(), - [maxIt] (const PrioritizedItem &i) { - return i.priority == maxIt->priority && i.searchPathIndex == maxIt->searchPathIndex; - }); - - if (nmax > 1) { - ErrorInfo e(Tr::tr("There is more than one equally prioritized candidate for module '%1'.") - .arg(moduleName)); - for (size_t i = 0; i < candidates.size(); ++i) { - const auto candidate = candidates.at(i); - if (candidate.priority == maxIt->priority) { - //: The %1 denotes the number of the candidate. - e.append(Tr::tr("candidate %1").arg(i + 1), candidates.at(i).item->location()); - } - } - throw e; - } - - return maxIt->item; -} - -Item *ModuleLoader::searchAndLoadModuleFile(ProductContext *productContext, - const CodeLocation &dependsItemLocation, const QualifiedId &moduleName, - FallbackMode fallbackMode, bool isRequired, Item *moduleInstance) -{ - auto existingPaths = findExistingModulePaths(m_reader->allSearchPaths(), moduleName); - - if (existingPaths.isEmpty()) { // no suitable names found, try to use providers - AccumulatingTimer providersTimer( - m_parameters.logElapsedTime() ? &m_elapsedTimeModuleProviders : nullptr); - auto result = m_moduleProviderLoader->executeModuleProviders( - *productContext, - dependsItemLocation, - moduleName, - fallbackMode); - if (result.providerAddedSearchPaths) { - qCDebug(lcModuleLoader) << "Re-checking for module" << moduleName.toString() - << "with newly added search paths from module provider"; - existingPaths = findExistingModulePaths(m_reader->allSearchPaths(), moduleName); - } - } - - const QString fullName = moduleName.toString(); - bool triedToLoadModule = false; - std::vector<PrioritizedItem> candidates; - candidates.reserve(size_t(existingPaths.size())); - for (int i = 0; i < existingPaths.size(); ++i) { - const QString &dirPath = existingPaths.at(i); - QStringList &moduleFileNames = getModuleFileNames(dirPath); - for (auto it = moduleFileNames.begin(); it != moduleFileNames.end(); ) { - const QString &filePath = *it; - const auto [module, triedToLoad] = loadModuleFile( - productContext, fullName, filePath, moduleInstance); - if (module) - candidates.emplace_back(module, 0, i); - if (!triedToLoad) - it = moduleFileNames.erase(it); - else - ++it; - triedToLoadModule = triedToLoadModule || triedToLoad; - } - } - - if (candidates.empty()) { - if (!isRequired) - return createNonPresentModule(fullName, QStringLiteral("not found"), nullptr); - if (Q_UNLIKELY(triedToLoadModule)) { - throw ErrorInfo(Tr::tr("Module %1 could not be loaded.").arg(fullName), - dependsItemLocation); - } - return nullptr; - } - - Item *moduleItem; - if (candidates.size() == 1) { - moduleItem = candidates.at(0).item; - } else { - for (auto &candidate : candidates) { - candidate.priority = m_evaluator->intValue(candidate.item, - StringConstants::priorityProperty(), - candidate.priority); - } - moduleItem = chooseModuleCandidate(candidates, fullName); - } - - const auto it = productContext->unknownProfilePropertyErrors.find(moduleItem); - if (it != productContext->unknownProfilePropertyErrors.cend()) { - const QString fullProductName = ResolvedProduct::fullDisplayName - (productContext->name, productContext->multiplexConfigurationId); - ErrorInfo error(Tr::tr("Loading module '%1' for product '%2' failed due to invalid values " - "in profile '%3':").arg(fullName, fullProductName, - productContext->profileName)); - for (const ErrorInfo &e : it->second) - error.append(e.toString()); - handlePropertyError(error, m_parameters, m_logger); - } - return moduleItem; -} - -QStringList &ModuleLoader::getModuleFileNames(const QString &dirPath) -{ - QStringList &moduleFileNames = m_moduleDirListCache[dirPath]; - if (moduleFileNames.empty()) { - QDirIterator dirIter(dirPath, StringConstants::qbsFileWildcards()); - while (dirIter.hasNext()) - moduleFileNames += dirIter.next(); - } - return moduleFileNames; -} - -static Item *findDeepestModuleInstance(Item *instance) -{ - while (instance->prototype() && instance->prototype()->type() == ItemType::ModuleInstance) - instance = instance->prototype(); - return instance; -} - -std::pair<Item *, bool> ModuleLoader::loadModuleFile( - ProductContext *productContext, const QString &fullModuleName, - const QString &filePath, Item *moduleInstance) -{ - checkCancelation(); - - qCDebug(lcModuleLoader) << "loadModuleFile" << fullModuleName << "from" << filePath; - - const auto [module, triedToLoad] = - getModulePrototype(productContext, fullModuleName, filePath); - if (!module) - return {nullptr, triedToLoad}; - - const auto key = std::make_pair(module, productContext); - const auto it = m_modulePrototypeEnabledInfo.find(key); - if (it != m_modulePrototypeEnabledInfo.end()) { - qCDebug(lcModuleLoader) << "prototype cache hit (level 2)"; - return {it.value() ? module : nullptr, triedToLoad}; - } - - // Set the name before evaluating any properties. Evaluator reads the module name. - module->setProperty(StringConstants::nameProperty(), VariantValue::create(fullModuleName)); - - Item *deepestModuleInstance = findDeepestModuleInstance(moduleInstance); - Item *origDeepestModuleInstancePrototype = deepestModuleInstance->prototype(); - deepestModuleInstance->setPrototype(module); - bool enabled = checkItemCondition(moduleInstance, module); - deepestModuleInstance->setPrototype(origDeepestModuleInstancePrototype); - if (!enabled) { - qCDebug(lcModuleLoader) << "condition of module" << fullModuleName << "is false"; - m_modulePrototypeEnabledInfo.insert(key, false); - return {nullptr, triedToLoad}; - } - - if (isBaseModule(fullModuleName)) - setupBaseModulePrototype(module); - else - resolveParameterDeclarations(module); - - m_modulePrototypeEnabledInfo.insert(key, true); - return {module, triedToLoad}; -} - -// Returns the module prototype item and a boolean indicating if we tried to load it from the file -std::pair<Item *, bool> ModuleLoader::getModulePrototype(ProductContext *productContext, - const QString &fullModuleName, const QString &filePath) -{ - auto &prototypeList = m_modulePrototypes[filePath]; - for (const auto &prototype : prototypeList) { - if (prototype.second == productContext->profileName) { - qCDebug(lcModuleLoader) << "prototype cache hit (level 1)"; - return {prototype.first, true}; - } - } - Item * const module = loadItemFromFile(filePath, CodeLocation()); - if (module->type() != ItemType::Module) { - qCDebug(lcModuleLoader).nospace() - << "Alleged module " << fullModuleName << " has type '" - << module->typeName() << "', so it's not a module after all."; - return {nullptr, false}; - } - prototypeList.emplace_back(module, productContext->profileName); - - // Module properties that are defined in the profile are used as default values. - // This is the reason we need to have different items per profile. - const QVariantMap profileModuleProperties - = productContext->moduleProperties.value(fullModuleName).toMap(); - for (auto it = profileModuleProperties.cbegin(); it != profileModuleProperties.cend(); ++it) { - if (Q_UNLIKELY(!module->hasProperty(it.key()))) { - productContext->unknownProfilePropertyErrors[module].emplace_back - (Tr::tr("Unknown property: %1.%2").arg(fullModuleName, it.key())); - continue; - } - const PropertyDeclaration decl = module->propertyDeclaration(it.key()); - VariantValuePtr v = VariantValue::create( - PropertyDeclaration::convertToPropertyType(it.value(), decl.type(), - QStringList(fullModuleName), it.key())); - module->setProperty(it.key(), v); - } - - return {module, true}; -} - -Item::Module ModuleLoader::loadBaseModule(ProductContext *productContext, Item *item) -{ - const QualifiedId baseModuleName(StringConstants::qbsModule()); - Item::Module baseModuleDesc; - baseModuleDesc.name = baseModuleName; - baseModuleDesc.item = loadModule(productContext, nullptr, item, CodeLocation(), QString(), - baseModuleName, QString(), FallbackMode::Disabled, true, - &baseModuleDesc.isProduct, nullptr); - if (productContext->item) { - const Item * const qbsInstanceItem - = moduleInstanceItem(productContext->item, baseModuleName); - const Item::PropertyMap &props = qbsInstanceItem->properties(); - for (auto it = props.cbegin(); it != props.cend(); ++it) { - if (it.value()->type() == Value::VariantValueType) - baseModuleDesc.item->setProperty(it.key(), it.value()); - } - } - QBS_CHECK(!baseModuleDesc.isProduct); - if (Q_UNLIKELY(!baseModuleDesc.item)) - throw ErrorInfo(Tr::tr("Cannot load base qbs module.")); - return baseModuleDesc; -} - -void ModuleLoader::setupBaseModulePrototype(Item *prototype) -{ - prototype->setProperty(QStringLiteral("hostPlatform"), - VariantValue::create(HostOsInfo::hostOSIdentifier())); - prototype->setProperty(QStringLiteral("hostArchitecture"), - VariantValue::create(HostOsInfo::hostOSArchitecture())); - prototype->setProperty(QStringLiteral("libexecPath"), - VariantValue::create(m_parameters.libexecPath())); - - const Version qbsVersion = LanguageInfo::qbsVersion(); - prototype->setProperty(QStringLiteral("versionMajor"), - VariantValue::create(qbsVersion.majorVersion())); - prototype->setProperty(QStringLiteral("versionMinor"), - VariantValue::create(qbsVersion.minorVersion())); - prototype->setProperty(QStringLiteral("versionPatch"), - VariantValue::create(qbsVersion.patchLevel())); -} - -static void collectItemsWithId_impl(Item *item, QList<Item *> *result) -{ - if (!item->id().isEmpty()) - result->push_back(item); - for (Item * const child : item->children()) - collectItemsWithId_impl(child, result); -} - -static QList<Item *> collectItemsWithId(Item *item) -{ - QList<Item *> result; - collectItemsWithId_impl(item, &result); - return result; -} - -static std::vector<std::pair<QualifiedId, ItemValuePtr>> instanceItemProperties(Item *item) -{ - std::vector<std::pair<QualifiedId, ItemValuePtr>> result; - QualifiedId name; - const auto func = [&] (Item *item, const auto &f) -> void { - for (auto it = item->properties().begin(), end = item->properties().end(); - it != end; ++it) { - if (it.value()->type() != Value::ItemValueType) - continue; - ItemValuePtr itemValue = std::static_pointer_cast<ItemValue>(it.value()); - if (!itemValue->item()) - continue; - name.push_back(it.key()); - if (itemValue->item()->type() == ItemType::ModulePrefix) - f(itemValue->item(), f); - else - result.emplace_back(name, itemValue); - name.removeLast(); - } - }; - func(item, func); - return result; -} - -void ModuleLoader::instantiateModule(ProductContext *productContext, Item *exportingProduct, - Item *instanceScope, Item *moduleInstance, Item *modulePrototype, - const QualifiedId &moduleName, ProductModuleInfo *productModuleInfo) -{ - Item *deepestModuleInstance = findDeepestModuleInstance(moduleInstance); - deepestModuleInstance->setPrototype(modulePrototype); - const QString fullName = moduleName.toString(); - const QString generalOverrideKey = QStringLiteral("modules.") + fullName; - const QString perProductOverrideKey = StringConstants::productsOverridePrefix() - + productContext->name + QLatin1Char('.') + fullName; - for (Item *instance = moduleInstance; instance; instance = instance->prototype()) { - overrideItemProperties(instance, generalOverrideKey, m_parameters.overriddenValuesTree()); - if (fullName == QStringLiteral("qbs")) - overrideItemProperties(instance, fullName, m_parameters.overriddenValuesTree()); - overrideItemProperties(instance, perProductOverrideKey, - m_parameters.overriddenValuesTree()); - if (instance == deepestModuleInstance) - break; - } - - moduleInstance->setFile(modulePrototype->file()); - moduleInstance->setLocation(modulePrototype->location()); - QBS_CHECK(moduleInstance->type() == ItemType::ModuleInstance); - - // create module scope - Item *moduleScope = Item::create(m_pool, ItemType::Scope); - QBS_CHECK(instanceScope->file()); - moduleScope->setFile(instanceScope->file()); - moduleScope->setScope(instanceScope); - QBS_CHECK(productContext->project->scope); - productContext->project->scope->copyProperty(StringConstants::projectVar(), moduleScope); - if (productContext->scope) - productContext->scope->copyProperty(StringConstants::productVar(), moduleScope); - else - QBS_CHECK(fullName == StringConstants::qbsModule()); // Dummy product. - - if (productModuleInfo) { - exportingProduct = productModuleInfo->exportItem->parent(); - QBS_CHECK(exportingProduct); - QBS_CHECK(exportingProduct->type() == ItemType::Product); - } - - if (exportingProduct) { - const auto exportingProductItemValue = ItemValue::create(exportingProduct); - moduleScope->setProperty(QStringLiteral("exportingProduct"), exportingProductItemValue); - - const auto importingProductItemValue = ItemValue::create(productContext->item); - moduleScope->setProperty(QStringLiteral("importingProduct"), importingProductItemValue); - - moduleScope->setProperty(StringConstants::projectVar(), - ItemValue::create(exportingProduct->parent())); - - PropertyDeclaration pd(StringConstants::qbsSourceDirPropertyInternal(), - PropertyDeclaration::String, QString(), - PropertyDeclaration::PropertyNotAvailableInConfig); - moduleInstance->setPropertyDeclaration(pd.name(), pd); - ValuePtr v = exportingProduct - ->property(StringConstants::sourceDirectoryProperty())->clone(); - moduleInstance->setProperty(pd.name(), v); - } - moduleInstance->setScope(moduleScope); - - QHash<Item *, Item *> prototypeInstanceMap; - prototypeInstanceMap[modulePrototype] = moduleInstance; - - // create instances for every child of the prototype - createChildInstances(moduleInstance, modulePrototype, &prototypeInstanceMap); - - // create ids from from the prototype in the instance - if (modulePrototype->file()->idScope()) { - const auto items = collectItemsWithId(modulePrototype); - for (Item * const itemWithId : items) { - Item *idProto = itemWithId; - Item *idInstance = prototypeInstanceMap.value(idProto); - QBS_ASSERT(idInstance, continue); - ItemValuePtr idInstanceValue = ItemValue::create(idInstance); - moduleScope->setProperty(itemWithId->id(), idInstanceValue); - } - } - - // For foo.bar in modulePrototype create an item foo in moduleInstance. - for (const auto &[propertyName, itemValue] : instanceItemProperties(modulePrototype)) { - if (itemValue->item()->properties().empty()) - continue; - qCDebug(lcModuleLoader) << "The prototype of " << moduleName - << " sets properties on " << propertyName.toString(); - Item *item = moduleInstanceItem(moduleInstance, propertyName); - item->setPrototype(itemValue->item()); - if (itemValue->createdByPropertiesBlock()) { - ItemValuePtr itemValue = moduleInstance->itemProperty(propertyName.front()); - for (int i = 1; i < propertyName.size(); ++i) - itemValue = itemValue->item()->itemProperty(propertyName.at(i)); - itemValue->setCreatedByPropertiesBlock(true); - } - } - - // Resolve dependencies of this module instance. - DependsContext dependsContext; - dependsContext.product = productContext; - dependsContext.exportingProductItem = exportingProduct; - QBS_ASSERT(moduleInstance->modules().empty(), moduleInstance->removeModules()); - if (productModuleInfo) { - dependsContext.productDependencies = &productContext->productModuleDependencies[fullName]; - resolveDependencies(&dependsContext, moduleInstance); - } else if (!isBaseModule(fullName)) { - dependsContext.productDependencies = &productContext->info.usedProducts; - resolveDependencies(&dependsContext, moduleInstance); - } - - // Check readonly properties. - const auto end = moduleInstance->properties().cend(); - for (auto it = moduleInstance->properties().cbegin(); it != end; ++it) { - const PropertyDeclaration &pd = moduleInstance->propertyDeclaration(it.key()); - if (!pd.flags().testFlag(PropertyDeclaration::ReadOnlyFlag)) - continue; - throw ErrorInfo(Tr::tr("Cannot set read-only property '%1'.").arg(pd.name()), - moduleInstance->property(pd.name())->location()); - } -} - -void ModuleLoader::createChildInstances(Item *instance, Item *prototype, - QHash<Item *, Item *> *prototypeInstanceMap) const -{ - instance->childrenReserve(instance->children().size() + prototype->children().size()); - - for (Item * const childPrototype : prototype->children()) { - Item *childInstance = Item::create(m_pool, childPrototype->type()); - prototypeInstanceMap->insert(childPrototype, childInstance); - childInstance->setPrototype(childPrototype); - childInstance->setFile(childPrototype->file()); - childInstance->setId(childPrototype->id()); - childInstance->setLocation(childPrototype->location()); - childInstance->setScope(instance->scope()); - Item::addChild(instance, childInstance); - createChildInstances(childInstance, childPrototype, prototypeInstanceMap); - } -} - -void ModuleLoader::checkCancelation() const -{ - if (m_progressObserver && m_progressObserver->canceled()) { - throw ErrorInfo(Tr::tr("Project resolving canceled for configuration %1.") - .arg(TopLevelProject::deriveId(m_parameters.finalBuildConfigurationTree()))); - } -} - -bool ModuleLoader::checkItemCondition(Item *item, Item *itemToDisable) -{ - if (m_evaluator->boolValue(item, StringConstants::conditionProperty())) - return true; - m_disabledItems += itemToDisable ? itemToDisable : item; - return false; -} - -QStringList ModuleLoader::readExtraSearchPaths(Item *item, bool *wasSet) -{ - QStringList result; - const QStringList paths = m_evaluator->stringListValue( - item, StringConstants::qbsSearchPathsProperty(), wasSet); - const JSSourceValueConstPtr prop = item->sourceProperty( - StringConstants::qbsSearchPathsProperty()); - - // Value can come from within a project file or as an overridden value from the user - // (e.g command line). - const QString basePath = FileInfo::path(prop ? prop->file()->filePath() - : m_parameters.projectFilePath()); - for (const QString &path : paths) - result += FileInfo::resolvePath(basePath, path); - return result; -} - -void ModuleLoader::copyProperties(const Item *sourceProject, Item *targetProject) -{ - if (!sourceProject) - return; - const QList<PropertyDeclaration> builtinProjectProperties = BuiltinDeclarations::instance() - .declarationsForType(ItemType::Project).properties(); - Set<QString> builtinProjectPropertyNames; - for (const PropertyDeclaration &p : builtinProjectProperties) - builtinProjectPropertyNames << p.name(); - - for (Item::PropertyDeclarationMap::ConstIterator it - = sourceProject->propertyDeclarations().constBegin(); - it != sourceProject->propertyDeclarations().constEnd(); ++it) { - - // We must not inherit built-in properties such as "name", - // but there are exceptions. - if (it.key() == StringConstants::qbsSearchPathsProperty() - || it.key() == StringConstants::profileProperty() - || it.key() == StringConstants::buildDirectoryProperty() - || it.key() == StringConstants::sourceDirectoryProperty() - || it.key() == StringConstants::minimumQbsVersionProperty()) { - const JSSourceValueConstPtr &v = targetProject->sourceProperty(it.key()); - QBS_ASSERT(v, continue); - if (v->sourceCode() == StringConstants::undefinedValue()) - sourceProject->copyProperty(it.key(), targetProject); - continue; - } - - if (builtinProjectPropertyNames.contains(it.key())) - continue; - - if (targetProject->hasOwnProperty(it.key())) - continue; // Ignore stuff the target project already has. - - targetProject->setPropertyDeclaration(it.key(), it.value()); - sourceProject->copyProperty(it.key(), targetProject); - } -} - -Item *ModuleLoader::wrapInProjectIfNecessary(Item *item) -{ - if (item->type() == ItemType::Project) - return item; - Item *prj = Item::create(item->pool(), ItemType::Project); - Item::addChild(prj, item); - prj->setFile(item->file()); - prj->setLocation(item->location()); - prj->setupForBuiltinType(m_parameters.deprecationWarningMode(), m_logger); - return prj; -} - -QString ModuleLoader::findExistingModulePath(const QString &searchPath, - const QualifiedId &moduleName) -{ - // isFileCaseCorrect is a very expensive call on macOS, so we cache the value for the - // modules and search paths we've already processed - auto &moduleInfo = m_existingModulePathCache[{searchPath, moduleName}]; - if (moduleInfo) - return *moduleInfo; - - QString dirPath = searchPath + QStringLiteral("/modules"); - - for (const QString &moduleNamePart : moduleName) { - dirPath = FileInfo::resolvePath(dirPath, moduleNamePart); - if (!FileInfo::exists(dirPath) || !FileInfo::isFileCaseCorrect(dirPath)) { - return *(moduleInfo = QString()); - } - } - - return *(moduleInfo = dirPath); -} - -QStringList ModuleLoader::findExistingModulePaths( - const QStringList &searchPaths, const QualifiedId &moduleName) -{ - QStringList result; - result.reserve(searchPaths.size()); - for (const auto &path: searchPaths) { - const QString dirPath = findExistingModulePath(path, moduleName); - if (!dirPath.isEmpty()) - result.append(dirPath); - } - return result; -} - -void ModuleLoader::setScopeForDescendants(Item *item, Item *scope) -{ - for (Item * const child : item->children()) { - child->setScope(scope); - setScopeForDescendants(child, scope); - } -} - -void ModuleLoader::overrideItemProperties(Item *item, const QString &buildConfigKey, - const QVariantMap &buildConfig) -{ - const QVariant buildConfigValue = buildConfig.value(buildConfigKey); - if (buildConfigValue.isNull()) - return; - item->overrideProperties(buildConfigValue.toMap(), buildConfigKey, m_parameters, m_logger); -} - -void ModuleLoader::collectAllModules(Item *item, std::vector<Item::Module> *modules) -{ - for (const Item::Module &m : item->modules()) { - if (moduleRepresentsDisabledProduct(m)) - m.item->removeModules(); - auto it = std::find_if(modules->begin(), modules->end(), - [m] (const Item::Module &m2) { return m.name == m2.name; }); - if (it != modules->end()) { - // If a module is required somewhere, it is required in the top-level item. - if (m.required) - it->required = true; - it->versionRange.narrowDown(m.versionRange); - it->fallbackEnabled = it->fallbackEnabled && m.fallbackEnabled; - continue; - } - modules->push_back(m); - collectAllModules(m.item, modules); - } -} - -std::vector<Item::Module> ModuleLoader::allModules(Item *item) -{ - std::vector<Item::Module> lst; - collectAllModules(item, &lst); - return lst; -} - -bool ModuleLoader::moduleRepresentsDisabledProduct(const Item::Module &module) -{ - if (!module.isProduct) - return false; - const Item *exportItem = module.item->prototype(); - while (exportItem && exportItem->type() != ItemType::Export) - exportItem = exportItem->prototype(); - QBS_CHECK(exportItem); - Item * const productItem = exportItem->parent(); - QBS_CHECK(productItem->type() == ItemType::Product); - return m_disabledItems.contains(productItem) || !checkItemCondition(productItem); -} - -void ModuleLoader::addProductModuleDependencies(ProductContext *productContext, const QString &name) -{ - auto deps = productContext->productModuleDependencies.at(name); - QList<ModuleLoaderResult::ProductInfo::Dependency> depsToAdd; - const bool productIsMultiplexed = !productContext->multiplexConfigurationId.isEmpty(); - for (auto &dep : deps) { - const auto productRange = m_productsByName.equal_range(dep.name); - std::vector<const ProductContext *> dependencies; - bool hasNonMultiplexedDependency = false; - for (auto it = productRange.first; it != productRange.second; ++it) { - if (!it->second->multiplexConfigurationId.isEmpty()) { - dependencies.push_back(it->second); - if (productIsMultiplexed && dep.profile.isEmpty()) - break; - } else { - hasNonMultiplexedDependency = true; - break; - } - } - - if (hasNonMultiplexedDependency) { - depsToAdd.push_back(dep); - continue; - } - - for (std::size_t i = 0; i < dependencies.size(); ++i) { - const bool profileMatch = dep.profile.isEmpty() - || dep.profile == StringConstants::star() - || dep.profile == dependencies.at(i)->profileName; - if (i == 0) { - if (productIsMultiplexed && dep.profile.isEmpty()) { - const ValuePtr &multiplexConfigIdProp = productContext->item->property( - StringConstants::multiplexConfigurationIdProperty()); - dep.multiplexConfigurationId = std::static_pointer_cast<VariantValue>( - multiplexConfigIdProp)->value().toString(); - depsToAdd.push_back(dep); - break; - } - if (profileMatch) { - dep.multiplexConfigurationId = dependencies.at(i)->multiplexConfigurationId; - depsToAdd.push_back(dep); - } - } else if (profileMatch) { - ModuleLoaderResult::ProductInfo::Dependency newDependency = dep; - newDependency.multiplexConfigurationId - = dependencies.at(i)->multiplexConfigurationId; - depsToAdd << newDependency; - } - } - } - productContext->info.usedProducts.insert(productContext->info.usedProducts.end(), - depsToAdd.cbegin(), depsToAdd.cend()); -} - -static void collectProductModuleDependencies(Item *item, Set<QualifiedId> &allDeps) -{ - for (const Item::Module &m : item->modules()) { - if (m.isProduct && allDeps.insert(m.name).second) - collectProductModuleDependencies(m.item, allDeps); - } -} - -void ModuleLoader::addProductModuleDependencies(ModuleLoader::ProductContext *ctx) -{ - Set<QualifiedId> deps; - collectProductModuleDependencies(ctx->item, deps); - for (const QualifiedId &dep : deps) - addProductModuleDependencies(ctx, dep.toString()); -} - -void ModuleLoader::addTransitiveDependencies(ProductContext *ctx) -{ - AccumulatingTimer timer(m_parameters.logElapsedTime() - ? &m_elapsedTimeTransitiveDependencies : nullptr); - qCDebug(lcModuleLoader) << "addTransitiveDependencies"; - - std::vector<Item::Module> transitiveDeps = allModules(ctx->item); - std::sort(transitiveDeps.begin(), transitiveDeps.end()); - for (const Item::Module &m : ctx->item->modules()) { - auto it = std::lower_bound(transitiveDeps.begin(), transitiveDeps.end(), m); - QBS_CHECK(it != transitiveDeps.end() && it->name == m.name); - transitiveDeps.erase(it); - } - for (const Item::Module &module : qAsConst(transitiveDeps)) { - if (module.isProduct) { - ctx->item->addModule(module); - } else { - const FallbackMode fallbackMode = module.fallbackEnabled - ? FallbackMode::Enabled : FallbackMode::Disabled; - Item::Module dep; - dep.item = loadModule(ctx, nullptr, ctx->item, ctx->item->location(), QString(), - module.name, QString(), fallbackMode, - module.required, &dep.isProduct, &dep.parameters); - if (!dep.item) { - throw ErrorInfo(Tr::tr("Module '%1' not found when setting up transitive " - "dependencies for product '%2'.").arg(module.name.toString(), - ctx->name), - ctx->item->location()); - } - dep.name = module.name; - dep.required = module.required; - dep.versionRange = module.versionRange; - dep.fallbackEnabled = fallbackMode == FallbackMode::Enabled; - ctx->item->addModule(dep); - } - } -} - -Item *ModuleLoader::createNonPresentModule(const QString &name, const QString &reason, Item *module) -{ - qCDebug(lcModuleLoader) << "Non-required module '" << name << "' not loaded (" << reason << ")." - << "Creating dummy module for presence check."; - if (!module) { - module = Item::create(m_pool, ItemType::ModuleInstance); - module->setFile(FileContext::create()); - module->setProperty(StringConstants::nameProperty(), VariantValue::create(name)); - } - module->setProperty(StringConstants::presentProperty(), VariantValue::falseValue()); - return module; -} - -void ModuleLoader::handleProductError(const ErrorInfo &error, - ModuleLoader::ProductContext *productContext) -{ - const bool alreadyHadError = productContext->info.delayedError.hasError(); - if (!alreadyHadError) { - productContext->info.delayedError.append(Tr::tr("Error while handling product '%1':") - .arg(productContext->name), - productContext->item->location()); - } - if (error.isInternalError()) { - if (alreadyHadError) { - qCDebug(lcModuleLoader()) << "ignoring subsequent internal error" << error.toString() - << "in product" << productContext->name; - return; - } - for (const auto &kv : productContext->productModuleDependencies) { - const auto rangeForName = m_productsByName.equal_range(kv.first); - for (auto rangeIt = rangeForName.first; rangeIt != rangeForName.second; ++rangeIt) { - const ProductContext * const dep = rangeIt->second; - if (dep->info.delayedError.hasError()) { - qCDebug(lcModuleLoader()) << "ignoring internal error" << error.toString() - << "in product" << productContext->name - << "assumed to be caused by erroneous dependency" - << dep->name; - return; - } - } - } - } - const auto errorItems = error.items(); - for (const ErrorItem &ei : errorItems) - productContext->info.delayedError.append(ei.description(), ei.codeLocation()); - productContext->project->result->productInfos[productContext->item] = productContext->info; - m_disabledItems << productContext->item; - m_erroneousProducts.insert(productContext->name); -} - -static void gatherAssignedProperties(ItemValue *iv, const QualifiedId &prefix, - QualifiedIdSet &properties) -{ - const Item::PropertyMap &props = iv->item()->properties(); - for (auto it = props.cbegin(); it != props.cend(); ++it) { - switch (it.value()->type()) { - case Value::JSSourceValueType: - properties << (QualifiedId(prefix) << it.key()); - break; - case Value::ItemValueType: - if (iv->item()->type() == ItemType::ModulePrefix) { - gatherAssignedProperties(std::static_pointer_cast<ItemValue>(it.value()).get(), - QualifiedId(prefix) << it.key(), properties); - } - break; - default: - break; - } - } -} - -QualifiedIdSet ModuleLoader::gatherModulePropertiesSetInGroup(const Item *group) -{ - QualifiedIdSet propsSetInGroup; - const Item::PropertyMap &props = group->properties(); - for (auto it = props.cbegin(); it != props.cend(); ++it) { - if (it.value()->type() == Value::ItemValueType) { - gatherAssignedProperties(std::static_pointer_cast<ItemValue>(it.value()).get(), - QualifiedId(it.key()), propsSetInGroup); - } - } - return propsSetInGroup; -} - -void ModuleLoader::markModuleTargetGroups(Item *group, const Item::Module &module) -{ - QBS_CHECK(group->type() == ItemType::Group); - if (m_evaluator->boolValue(group, StringConstants::filesAreTargetsProperty())) { - group->setProperty(StringConstants::modulePropertyInternal(), - VariantValue::create(module.name.toString())); - } - for (Item * const child : group->children()) - markModuleTargetGroups(child, module); -} - -void ModuleLoader::copyGroupsFromModuleToProduct(const ProductContext &productContext, - const Item::Module &module, - const Item *modulePrototype) -{ - for (Item * const child : modulePrototype->children()) { - if (child->type() == ItemType::Group) { - Item * const clonedGroup = child->clone(); - clonedGroup->setScope(productContext.scope); - setScopeForDescendants(clonedGroup, productContext.scope); - Item::addChild(productContext.item, clonedGroup); - markModuleTargetGroups(clonedGroup, module); - } - } -} - -void ModuleLoader::copyGroupsFromModulesToProduct(const ProductContext &productContext) -{ - for (const Item::Module &module : productContext.item->modules()) { - Item *prototype = module.item; - bool modulePassedValidation; - while ((modulePassedValidation = prototype->isPresentModule()) && prototype->prototype()) - prototype = prototype->prototype(); - if (modulePassedValidation) - copyGroupsFromModuleToProduct(productContext, module, prototype); - } -} - -QString ModuleLoaderResult::ProductInfo::Dependency::uniqueName() const -{ - return ResolvedProduct::uniqueName(name, multiplexConfigurationId); -} - -QString ModuleLoader::ProductContext::uniqueName() const -{ - return ResolvedProduct::uniqueName(name, multiplexConfigurationId); -} - -} // namespace Internal -} // namespace qbs +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/moduleloader.h b/src/lib/corelib/language/moduleloader.h index db0b51cae..2e1140726 100644 --- a/src/lib/corelib/language/moduleloader.h +++ b/src/lib/corelib/language/moduleloader.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2023 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of Qbs. @@ -37,423 +37,48 @@ ** ****************************************************************************/ -#ifndef QBS_MODULELOADER_H -#define QBS_MODULELOADER_H +#pragma once -#include "filetags.h" -#include "forward_decls.h" #include "item.h" -#include "itempool.h" -#include "moduleproviderinfo.h" -#include <logging/logger.h> -#include <tools/filetime.h> -#include <tools/qttools.h> -#include <tools/set.h> -#include <tools/setupprojectparameters.h> -#include <tools/version.h> -#include <QtCore/qmap.h> -#include <QtCore/qstringlist.h> -#include <QtCore/qvariant.h> - -#include <map> -#include <memory> -#include <optional> -#include <unordered_map> -#include <utility> -#include <vector> +#include <QString> +#include <QVariantMap> namespace qbs { - -class CodeLocation; -class Settings; - +class SetupProjectParameters; namespace Internal { - class Evaluator; -class Item; class ItemReader; -class ModuleProviderLoader; -class ProbesResolver; -class ProgressObserver; -class QualifiedId; -class SearchPathsManager; - -using ModulePropertiesPerGroup = std::unordered_map<const Item *, QualifiedIdSet>; - -struct ModuleLoaderResult -{ - ModuleLoaderResult() - : itemPool(new ItemPool), root(nullptr) - {} - - struct ProductInfo - { - struct Dependency - { - QString name; - QString profile; // "*" <=> Match all profiles. - QString multiplexConfigurationId; - QVariantMap parameters; - bool limitToSubProject = false; - bool isRequired = true; +class Logger; - QString uniqueName() const; - }; - - std::vector<ProbeConstPtr> probes; - std::vector<Dependency> usedProducts; - ModulePropertiesPerGroup modulePropertiesSetInGroups; - ErrorInfo delayedError; - }; - - std::shared_ptr<ItemPool> itemPool; - Item *root; - std::unordered_map<Item *, ProductInfo> productInfos; - std::vector<ProbeConstPtr> projectProbes; - StoredModuleProviderInfo storedModuleProviderInfo; - Set<QString> qbsFiles; - QVariantMap profileConfigs; -}; - -/* - * Loader stage II. Responsible for - * - loading modules and module dependencies, - * - project references, - * - Probe items. - */ class ModuleLoader { public: - ModuleLoader(Evaluator *evaluator, Logger &logger); + ModuleLoader(const SetupProjectParameters &setupParameters, ItemReader &itemReader, + Evaluator &evaluator, Logger &logger); ~ModuleLoader(); - void setProgressObserver(ProgressObserver *progressObserver); - void setSearchPaths(const QStringList &searchPaths); - void setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes); - void setOldProductProbes(const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes); - void setLastResolveTime(const FileTime &time) { m_lastResolveTime = time; } - void setStoredProfiles(const QVariantMap &profiles); - void setStoredModuleProviderInfo(const StoredModuleProviderInfo &moduleProviderInfo); - Evaluator *evaluator() const { return m_evaluator; } - - ModuleLoaderResult load(const SetupProjectParameters ¶meters); - -private: - friend class ModuleProviderLoader; - friend class ProbesResolver; - class ProductSortByDependencies; - - class ContextBase - { - public: - ContextBase() - : item(nullptr), scope(nullptr) - {} - - Item *item; - Item *scope; - QString name; - }; - - class ProjectContext; - - using ProductDependencies = std::vector<ModuleLoaderResult::ProductInfo::Dependency>; - - // This is the data we need to store at the point where a dependency is deferred - // in order to properly resolve the dependency in pass 2. - struct DeferredDependsContext { - DeferredDependsContext(Item *exportingProduct, Item *parent) - : exportingProductItem(exportingProduct), parentItem(parent) {} - Item *exportingProductItem = nullptr; - Item *parentItem = nullptr; - bool operator==(const DeferredDependsContext &other) const - { - return exportingProductItem == other.exportingProductItem - && parentItem == other.parentItem; - } - bool operator<(const DeferredDependsContext &other) const - { - return parentItem < other.parentItem; - } - }; - - class ProductContext : public ContextBase - { - public: - ProjectContext *project = nullptr; - ModuleLoaderResult::ProductInfo info; - QString profileName; - QString multiplexConfigurationId; - QVariantMap moduleProperties; - std::map<QString, ProductDependencies> productModuleDependencies; - std::unordered_map<const Item *, std::vector<ErrorInfo>> unknownProfilePropertyErrors; - QStringList searchPaths; - - std::optional<QVariantMap> theModuleProviderConfig; - - // The key corresponds to DeferredDependsContext.exportingProductItem, which is the - // only value from that data structure that we still need here. - std::unordered_map<Item *, std::vector<Item *>> deferredDependsItems; - - QString uniqueName() const; - }; - - class TopLevelProjectContext; - - class ProjectContext : public ContextBase - { - public: - TopLevelProjectContext *topLevelProject = nullptr; - ModuleLoaderResult *result = nullptr; - std::vector<ProductContext> products; - std::vector<QStringList> searchPathsStack; - }; - - struct ProductModuleInfo - { - Item *exportItem = nullptr; - QString multiplexId; - QVariantMap defaultParameters; + struct ProductContext { + const Item *item = nullptr; + const QString &name; + const QString &profile; + const QVariantMap &profileModuleProperties; }; + // TODO: Entry point should be searchAndLoadModuleFile(). Needs ProviderLoader clean-up first. + std::pair<Item *, bool> loadModuleFile(const ProductContext &product, + const QString &moduleName, const QString &filePath); - class TopLevelProjectContext - { - Q_DISABLE_COPY(TopLevelProjectContext) - public: - TopLevelProjectContext() = default; - ~TopLevelProjectContext() { qDeleteAll(projects); } + void checkDependencyParameterDeclarations(const ProductContext &product) const; + void forwardParameterDeclarations(const Item *dependsItem, const Item::Modules &modules); - std::vector<ProjectContext *> projects; - QMultiHash<QString, ProductModuleInfo> productModules; - std::vector<ProbeConstPtr> probes; - QString buildDirectory; - }; - - class DependsContext - { - public: - ProductContext *product = nullptr; - Item *exportingProductItem = nullptr; - ProductDependencies *productDependencies = nullptr; - }; - - void handleTopLevelProject(ModuleLoaderResult *loadResult, Item *projectItem, - const QString &buildDirectory, const Set<QString> &referencedFilePaths); - void handleProject(ModuleLoaderResult *loadResult, - TopLevelProjectContext *topLevelProjectContext, Item *projectItem, - const Set<QString> &referencedFilePaths); - - using MultiplexRow = std::vector<VariantValuePtr>; - using MultiplexTable = std::vector<MultiplexRow>; - - struct MultiplexInfo - { - std::vector<QString> properties; - MultiplexTable table; - bool aggregate = false; - VariantValuePtr multiplexedType; - - QString toIdString(size_t row) const; - static QVariantMap multiplexIdToVariantMap(const QString &multiplexId); - }; - - void dump(const MultiplexInfo &mpi); - static MultiplexTable combine(const MultiplexTable &table, const MultiplexRow &values); - MultiplexInfo extractMultiplexInfo(Item *productItem, Item *qbsModuleItem); - QList<Item *> multiplexProductItem(ProductContext *dummyContext, Item *productItem); - void normalizeDependencies(ProductContext *product, - const DeferredDependsContext &dependsContext); - void adjustDependenciesForMultiplexing(const TopLevelProjectContext &tlp); - void adjustDependenciesForMultiplexing(const ProductContext &product); - void adjustDependenciesForMultiplexing(const ProductContext &product, Item *dependsItem); - - void prepareProduct(ProjectContext *projectContext, Item *productItem); - void setupProductDependencies(ProductContext *productContext, - const Set<DeferredDependsContext> &deferredDependsContext); - void handleProduct(ProductContext *productContext); - void checkDependencyParameterDeclarations(const ProductContext *productContext) const; - void handleModuleSetupError(ProductContext *productContext, const Item::Module &module, - const ErrorInfo &error); - void initProductProperties(const ProductContext &product); - void handleSubProject(ProjectContext *projectContext, Item *projectItem, - const Set<QString> &referencedFilePaths); - QList<Item *> loadReferencedFile(const QString &relativePath, - const CodeLocation &referencingLocation, - const Set<QString> &referencedFilePaths, - ProductContext &dummyContext); - void handleAllPropertyOptionsItems(Item *item); - void handlePropertyOptions(Item *optionsItem); - - using ModuleDependencies = QHash<QualifiedId, QualifiedIdSet>; - void setupReverseModuleDependencies(const Item::Module &module, ModuleDependencies &deps, - QualifiedIdSet &seenModules); - ModuleDependencies setupReverseModuleDependencies(const Item *product); - void handleGroup(ProductContext *productContext, Item *groupItem, - const ModuleDependencies &reverseDepencencies); - void propagateModulesFromParent(ProductContext *productContext, Item *groupItem, - const ModuleDependencies &reverseDepencencies); - void adjustDefiningItemsInGroupModuleInstances(const Item::Module &module, - const Item::Modules &dependentModules); - - bool mergeExportItems(const ProductContext &productContext); - void resolveDependencies(DependsContext *dependsContext, Item *item, - ProductContext *productContext = nullptr); - class ItemModuleList; - void resolveDependsItem(DependsContext *dependsContext, Item *parentItem, Item *dependsItem, - ItemModuleList *moduleResults, ProductDependencies *productResults); - void forwardParameterDeclarations(const Item *dependsItem, const ItemModuleList &modules); - void forwardParameterDeclarations(const QualifiedId &moduleName, Item *item, - const ItemModuleList &modules); - void resolveParameterDeclarations(const Item *module); - QVariantMap extractParameters(Item *dependsItem) const; - Item *moduleInstanceItem(Item *containerItem, const QualifiedId &moduleName); - static ProductModuleInfo *productModule(ProductContext *productContext, const QString &name, - const QString &multiplexId, bool &productNameMatch); - static ProductContext *product(ProjectContext *projectContext, const QString &name); - static ProductContext *product(TopLevelProjectContext *tlpContext, const QString &name); - - enum class FallbackMode { Enabled, Disabled }; - Item *loadModule(ProductContext *productContext, Item *exportingProductItem, Item *item, - const CodeLocation &dependsItemLocation, const QString &moduleId, - const QualifiedId &moduleName, const QString &multiplexId, FallbackMode fallbackMode, - bool isRequired, bool *isProductDependency, QVariantMap *defaultParameters); - Item *searchAndLoadModuleFile(ProductContext *productContext, - const CodeLocation &dependsItemLocation, const QualifiedId &moduleName, - FallbackMode fallbackMode, bool isRequired, Item *moduleInstance); - QStringList &getModuleFileNames(const QString &dirPath); - std::pair<Item *, bool> loadModuleFile( - ProductContext *productContext, const QString &fullModuleName, - const QString &filePath, Item *moduleInstance); - std::pair<Item *, bool> getModulePrototype(ProductContext *productContext, - const QString &fullModuleName, const QString &filePath); - Item::Module loadBaseModule(ProductContext *productContext, Item *item); - void setupBaseModulePrototype(Item *prototype); - template <typename T, typename F> - T callWithTemporaryBaseModule(ProductContext *productContext, const F &func); - void instantiateModule(ProductContext *productContext, Item *exportingProductItem, - Item *instanceScope, Item *moduleInstance, Item *modulePrototype, - const QualifiedId &moduleName, ProductModuleInfo *productModuleInfo); - void createChildInstances(Item *instance, Item *prototype, - QHash<Item *, Item *> *prototypeInstanceMap) const; - void checkCancelation() const; - bool checkItemCondition(Item *item, Item *itemToDisable = nullptr); - QStringList readExtraSearchPaths(Item *item, bool *wasSet = nullptr); - void copyProperties(const Item *sourceProject, Item *targetProject); - Item *wrapInProjectIfNecessary(Item *item); - QString findExistingModulePath(const QString &searchPath, const QualifiedId &moduleName); - QStringList findExistingModulePaths( - const QStringList &searchPaths, const QualifiedId &moduleName); - - static void setScopeForDescendants(Item *item, Item *scope); - void overrideItemProperties(Item *item, const QString &buildConfigKey, - const QVariantMap &buildConfig); - void addProductModuleDependencies(ProductContext *ctx, const QString &name); - void addProductModuleDependencies(ProductContext *ctx); - void addTransitiveDependencies(ProductContext *ctx); - Item *createNonPresentModule(const QString &name, const QString &reason, Item *module); - void copyGroupsFromModuleToProduct(const ProductContext &productContext, - const Item::Module &module, const Item *modulePrototype); - void copyGroupsFromModulesToProduct(const ProductContext &productContext); - void markModuleTargetGroups(Item *group, const Item::Module &module); - bool checkExportItemCondition(Item *exportItem, const ProductContext &productContext); - - void printProfilingInfo(); - void handleProductError(const ErrorInfo &error, ProductContext *productContext); - QualifiedIdSet gatherModulePropertiesSetInGroup(const Item *group); - Item *loadItemFromFile(const QString &filePath, const CodeLocation &referencingLocation); - void collectProductsByName(const TopLevelProjectContext &topLevelProject); - void collectProductsByType(const TopLevelProjectContext &topLevelProject); - - void handleProfileItems(Item *item, ProjectContext *projectContext); - std::vector<Item *> collectProfileItems(Item *item, ProjectContext *projectContext); - void evaluateProfileValues(const QualifiedId &namePrefix, Item *item, Item *profileItem, - QVariantMap &values); - void handleProfile(Item *profileItem); - void collectNameFromOverride(const QString &overrideString); - void checkProjectNamesInOverrides(const TopLevelProjectContext &tlp); - void checkProductNamesInOverrides(); - void setSearchPathsForProduct(ProductContext *product); - - Item::Modules modulesSortedByDependency(const Item *productItem); - void createSortedModuleList(const Item::Module &parentModule, Item::Modules &modules); - void collectAllModules(Item *item, std::vector<Item::Module> *modules); - std::vector<Item::Module> allModules(Item *item); - bool moduleRepresentsDisabledProduct(const Item::Module &module); - - using ShadowProductInfo = std::pair<bool, QString>; - ShadowProductInfo getShadowProductInfo(const ProductContext &product) const; - - ItemPool *m_pool; - Logger &m_logger; - ProgressObserver *m_progressObserver; - const std::unique_ptr<ItemReader> m_reader; - Evaluator *m_evaluator; - const std::unique_ptr<ProbesResolver> m_probesResolver; - const std::unique_ptr<ModuleProviderLoader> m_moduleProviderLoader; - QMap<QString, QStringList> m_moduleDirListCache; - QHash<std::pair<QString, QualifiedId>, std::optional<QString>> m_existingModulePathCache; - - // The keys are file paths, the values are module prototype items accompanied by a profile. - std::unordered_map<QString, std::vector<std::pair<Item *, QString>>> m_modulePrototypes; - - // The keys are module prototypes and products, the values specify whether the module's - // condition is true for that product. - QHash<std::pair<Item *, ProductContext *>, bool> m_modulePrototypeEnabledInfo; - - QHash<const Item *, Item::PropertyDeclarationMap> m_parameterDeclarations; - Set<Item *> m_disabledItems; - std::vector<bool> m_requiredChain; - - struct DependsChainEntry - { - DependsChainEntry(QualifiedId name, const CodeLocation &location) - : name(std::move(name)), location(location) - { - } - - QualifiedId name; - CodeLocation location; - bool isProduct = false; - }; - class DependsChainManager; - std::vector<DependsChainEntry> m_dependsChain; - - FileTime m_lastResolveTime; - QVariantMap m_storedProfiles; - QVariantMap m_localProfiles; - std::multimap<QString, const ProductContext *> m_productsByName; - std::multimap<FileTag, const ProductContext *> m_productsByType; - - std::unordered_map<ProductContext *, Set<DeferredDependsContext>> m_productsWithDeferredDependsItems; - Set<Item *> m_exportsWithDeferredDependsItems; - - SetupProjectParameters m_parameters; - std::unique_ptr<Settings> m_settings; - Version m_qbsVersion; - Item *m_tempScopeItem = nullptr; - - qint64 m_elapsedTimeProbes = 0; - qint64 m_elapsedTimePrepareProducts = 0; - qint64 m_elapsedTimeProductDependencies = 0; - qint64 m_elapsedTimeModuleProviders = 0; - qint64 m_elapsedTimeTransitiveDependencies = 0; - qint64 m_elapsedTimeHandleProducts = 0; - qint64 m_elapsedTimePropertyChecking = 0; - Set<QString> m_projectNamesUsedInOverrides; - Set<QString> m_productNamesUsedInOverrides; - Set<QString> m_disabledProjects; - Set<QString> m_erroneousProducts; - - int m_dependencyResolvingPass = 0; + // TODO: Remove once entry point is changed. + void checkProfileErrorsForModule(Item *module, const QString &moduleName, + const QString &productName, const QString &profileName); +private: + class Private; + Private * const d; }; } // namespace Internal } // namespace qbs -QT_BEGIN_NAMESPACE -Q_DECLARE_TYPEINFO(qbs::Internal::ModuleLoaderResult::ProductInfo, Q_MOVABLE_TYPE); -Q_DECLARE_TYPEINFO(qbs::Internal::ModuleLoaderResult::ProductInfo::Dependency, Q_MOVABLE_TYPE); -QT_END_NAMESPACE - -#endif // QBS_MODULELOADER_H diff --git a/src/lib/corelib/language/modulemerger.cpp b/src/lib/corelib/language/modulemerger.cpp deleted file mode 100644 index 6ad8e2259..000000000 --- a/src/lib/corelib/language/modulemerger.cpp +++ /dev/null @@ -1,267 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of Qbs. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "modulemerger.h" - -#include "value.h" - -#include <logging/translator.h> -#include <tools/qbsassert.h> -#include <tools/qttools.h> -#include <tools/stlutils.h> -#include <tools/stringconstants.h> - -namespace qbs { -namespace Internal { - -ModuleMerger::ModuleMerger(Logger &logger, Item *productItem, const QString &productName, - const Item::Modules::iterator &modulesBegin, - const Item::Modules::iterator &modulesEnd) - : m_logger(logger) - , m_productItem(productItem) - , m_mergedModule(*modulesBegin) - , m_isBaseModule(m_mergedModule.name.first() == StringConstants::qbsModule()) - , m_isShadowProduct(productName.startsWith(StringConstants::shadowProductPrefix())) - , m_modulesBegin(std::next(modulesBegin)) - , m_modulesEnd(modulesEnd) -{ - QBS_CHECK(modulesBegin->item->type() == ItemType::ModuleInstance); -} - -void ModuleMerger::replaceItemInValues(QualifiedId moduleName, Item *containerItem, Item *toReplace) -{ - QBS_CHECK(!moduleName.empty()); - QBS_CHECK(containerItem != m_mergedModule.item); - const QString moduleNamePrefix = moduleName.takeFirst(); - const Item::PropertyMap &properties = containerItem->properties(); - for (auto it = properties.begin(); it != properties.end(); ++it) { - if (it.key() != moduleNamePrefix) - continue; - Value * const val = it.value().get(); - QBS_CHECK(val); - QBS_CHECK(val->type() == Value::ItemValueType); - const auto itemVal = static_cast<ItemValue *>(val); - if (moduleName.empty()) { - QBS_CHECK(itemVal->item() == toReplace); - itemVal->setItem(m_mergedModule.item); - } else { - replaceItemInValues(moduleName, itemVal->item(), toReplace); - } - } -} - -void ModuleMerger::start() -{ - // Iterate over any module that our product depends on. These modules - // may depend on m_mergedModule and contribute property assignments. - Item::PropertyMap props; - for (auto module = m_modulesBegin; module != m_modulesEnd; module++) - mergeModule(&props, *module); - - // Module property assignments in the product have the highest priority - // and are thus prepended. - Item::Module m; - m.item = m_productItem; - mergeModule(&props, m); - - // The module's prototype is the essential unmodified module as loaded - // from the cache. - Item *moduleProto = m_mergedModule.item->prototype(); - while (moduleProto->prototype()) - moduleProto = moduleProto->prototype(); - - // The prototype item might contain default values which get appended in - // case of list properties. Scalar properties will only be set if not - // already specified above. - Item::PropertyMap mergedProps = m_mergedModule.item->properties(); - for (auto it = props.constBegin(); it != props.constEnd(); ++it) { - appendPrototypeValueToNextChain(moduleProto, it.key(), it.value()); - mergedProps[it.key()] = it.value(); - } - - m_mergedModule.item->setProperties(mergedProps); - - // Update all sibling instances of the to-be-merged module to behave identical - // to the merged module. - for (Item *moduleInstanceContainer : qAsConst(m_moduleInstanceContainers)) { - Item::Modules modules; - for (const Item::Module &dep : moduleInstanceContainer->modules()) { - const bool isTheModule = dep.name == m_mergedModule.name; - Item::Module m = dep; - if (isTheModule && m.item != m_mergedModule.item) { - QBS_CHECK(m.item->type() == ItemType::ModuleInstance); - replaceItemInValues(m.name, moduleInstanceContainer, m.item); - m.item = m_mergedModule.item; - m.required = m_mergedModule.required; - m.versionRange = m_mergedModule.versionRange; - m.fallbackEnabled = m_mergedModule.fallbackEnabled; - } - modules << m; - } - moduleInstanceContainer->setModules(modules); - } -} - -void ModuleMerger::mergeModule(Item::PropertyMap *dstProps, const Item::Module &module) -{ - const Item::Module *dep = findModule(module.item, m_mergedModule.name); - if (!dep) - return; - - const bool mergingProductItem = (module.item == m_productItem); - Item *srcItem = dep->item; - Item *origSrcItem = srcItem; - do { - if (m_seenInstances.insert(srcItem).second) { - for (auto it = srcItem->properties().constBegin(); - it != srcItem->properties().constEnd(); ++it) { - const ValuePtr &srcVal = it.value(); - if (srcVal->type() == Value::ItemValueType) - continue; - if (it.key() == StringConstants::qbsSourceDirPropertyInternal()) - continue; - const PropertyDeclaration srcDecl = srcItem->propertyDeclaration(it.key()); - if (!srcDecl.isValid()) - continue; - - // Scalar variant values could stem from product multiplexing, in which case - // the merged qbs module instance needs to get that value. - if (srcVal->type() == Value::VariantValueType - && (!srcDecl.isScalar() || !m_isBaseModule)) { - continue; - } - - ValuePtr clonedSrcVal = srcVal->clone(); - clonedSrcVal->setDefiningItem(origSrcItem); - - ValuePtr &dstVal = (*dstProps)[it.key()]; - if (dstVal) { - if (srcDecl.isScalar()) { - // Scalar properties get replaced. - if ((dstVal->type() == Value::JSSourceValueType) - && (srcVal->type() == Value::JSSourceValueType)) { - // Warn only about conflicting source code values - const JSSourceValuePtr dstJsVal = - std::static_pointer_cast<JSSourceValue>(dstVal); - const JSSourceValuePtr srcJsVal = - std::static_pointer_cast<JSSourceValue>(srcVal); - const bool overriddenInProduct = - m_mergedModule.item->properties().contains(it.key()); - - if (dstJsVal->sourceCode() != srcJsVal->sourceCode() - && !mergingProductItem && !overriddenInProduct - && !m_isShadowProduct) { - m_logger.qbsWarning() - << Tr::tr("Conflicting scalar values at %1 and %2.").arg( - dstJsVal->location().toString(), - srcJsVal->location().toString()); - } - } - } else { - // List properties get prepended - QBS_CHECK(!clonedSrcVal->next()); - clonedSrcVal->setNext(dstVal); - } - } - dstVal = clonedSrcVal; - } - } - srcItem = srcItem->prototype(); - } while (srcItem && srcItem->type() == ItemType::ModuleInstance); - - // Update dependency constraints - if (dep->required) - m_mergedModule.required = true; - // if one dep has fallback disabled, disable it for the merged module - m_mergedModule.fallbackEnabled = m_mergedModule.fallbackEnabled && dep->fallbackEnabled; - m_mergedModule.versionRange.narrowDown(dep->versionRange); - - // We need to touch the unmerged module instances later once more - m_moduleInstanceContainers << module.item; -} - -void ModuleMerger::appendPrototypeValueToNextChain(Item *moduleProto, const QString &propertyName, - const ValuePtr &sv) -{ - const PropertyDeclaration pd = m_mergedModule.item->propertyDeclaration(propertyName); - if (pd.isScalar()) - return; - if (!m_clonedModulePrototype) { - m_clonedModulePrototype = Item::create(moduleProto->pool(), ItemType::Module); - m_clonedModulePrototype->setScope(m_mergedModule.item); - m_clonedModulePrototype->setLocation(moduleProto->location()); - moduleProto->copyProperty(StringConstants::nameProperty(), m_clonedModulePrototype); - } - const ValuePtr &protoValue = moduleProto->property(propertyName); - QBS_CHECK(protoValue); - const ValuePtr clonedValue = protoValue->clone(); - lastInNextChain(sv)->setNext(clonedValue); - clonedValue->setDefiningItem(m_clonedModulePrototype); - m_clonedModulePrototype->setPropertyDeclaration(propertyName, pd); - m_clonedModulePrototype->setProperty(propertyName, clonedValue); -} - -ValuePtr ModuleMerger::lastInNextChain(const ValuePtr &v) -{ - ValuePtr n = v; - while (n->next()) - n = n->next(); - return n; -} - -const Item::Module *ModuleMerger::findModule(const Item *item, const QualifiedId &name) -{ - for (const auto &module : item->modules()) { - if (module.name == name) - return &module; - } - return nullptr; -} - -void ModuleMerger::merge(Logger &logger, Item *product, const QString &productName, - Item::Modules *topSortedModules) -{ - for (auto it = topSortedModules->begin(); it != topSortedModules->end(); ++it) - ModuleMerger(logger, product, productName, it, topSortedModules->end()).start(); -} - - - -} // namespace Internal -} // namespace qbs diff --git a/src/lib/corelib/language/modulepropertymerger.cpp b/src/lib/corelib/language/modulepropertymerger.cpp new file mode 100644 index 000000000..d45329d12 --- /dev/null +++ b/src/lib/corelib/language/modulepropertymerger.cpp @@ -0,0 +1,304 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "modulepropertymerger.h" + +#include "evaluator.h" +#include "item.h" +#include "value.h" + +#include <logging/translator.h> +#include <tools/profiling.h> +#include <tools/set.h> +#include <tools/setupprojectparameters.h> + +namespace qbs::Internal { +class ModulePropertyMerger::Private +{ +public: + Private(const SetupProjectParameters ¶meters, Evaluator &evaluator, Logger &logger) + : parameters(parameters), evaluator(evaluator), logger(logger) {} + + int compareValuePriorities(const Item *productItem, const ValueConstPtr &v1, + const ValueConstPtr &v2); + ValuePtr mergeListValues(const Item *productItem, const ValuePtr ¤tHead, const ValuePtr &newElem); + void mergePropertyFromLocalInstance(const Item *productItem, Item *loadingItem, + const QString &loadingName, Item *globalInstance, + const QString &name, const ValuePtr &value); + bool doFinalMerge(const Item *productItem, Item *moduleItem); + bool doFinalMerge(const Item *productItem, const PropertyDeclaration &propertyDecl, + ValuePtr &propertyValue); + + const SetupProjectParameters ¶meters; + Evaluator &evaluator; + Logger &logger; + qint64 elapsedTime = 0; +}; + +void ModulePropertyMerger::mergeFromLocalInstance( + const Item *productItem, Item *loadingItem, const QString &loadingName, + const Item *localInstance, Item *globalInstance) +{ + AccumulatingTimer t(d->parameters.logElapsedTime() ? &d->elapsedTime : nullptr); + + for (auto it = localInstance->properties().constBegin(); + it != localInstance->properties().constEnd(); ++it) { + d->mergePropertyFromLocalInstance(productItem, loadingItem, loadingName, + globalInstance, it.key(), it.value()); + } +} + +void ModulePropertyMerger::doFinalMerge(const Item *productItem) +{ + AccumulatingTimer t(d->parameters.logElapsedTime() ? &d->elapsedTime : nullptr); + + Set<const Item *> itemsToInvalidate; + for (const Item::Module &module : productItem->modules()) { + if (d->doFinalMerge(productItem, module.item)) + itemsToInvalidate << module.item; + } + const auto collectDependentItems = [&itemsToInvalidate](const Item *item, + const auto &collect) -> bool { + const bool alreadyInSet = itemsToInvalidate.contains(item); + bool addItem = false; + for (const Item::Module &m : item->modules()) { + if (collect(m.item, collect)) + addItem = true; + } + if (addItem && !alreadyInSet) + itemsToInvalidate << item; + return addItem || alreadyInSet; + }; + collectDependentItems(productItem, collectDependentItems); + for (const Item * const item : itemsToInvalidate) + d->evaluator.clearCache(item); +} + +void ModulePropertyMerger::printProfilingInfo(int indent) +{ + if (!d->parameters.logElapsedTime()) + return; + d->logger.qbsLog(LoggerInfo, true) << QByteArray(indent, ' ') + << Tr::tr("Merging module property values took %1.") + .arg(elapsedTimeString(d->elapsedTime)); +} + +ModulePropertyMerger::ModulePropertyMerger( + const SetupProjectParameters ¶meters, Evaluator &evaluator, Logger &logger) + : d(new Private(parameters, evaluator, logger)) { } +ModulePropertyMerger::~ModulePropertyMerger() { delete d; } + +int ModulePropertyMerger::Private::compareValuePriorities( + const Item *productItem, const ValueConstPtr &v1, const ValueConstPtr &v2) +{ + QBS_CHECK(v1); + QBS_CHECK(v2); + QBS_CHECK(v1->scope() != v2->scope()); + QBS_CHECK(v1->type() == Value::JSSourceValueType || v2->type() == Value::JSSourceValueType); + + const int prio1 = v1->priority(productItem); + const int prio2 = v2->priority(productItem); + if (prio1 != prio2) + return prio1 - prio2; + const int prioDiff = v1->scopeName().compare(v2->scopeName()); // Sic! See 8ff1dd0044 + QBS_CHECK(prioDiff != 0); + return prioDiff; +} + +ValuePtr ModulePropertyMerger::Private::mergeListValues( + const Item *productItem, const ValuePtr ¤tHead, const ValuePtr &newElem) +{ + QBS_CHECK(newElem); + QBS_CHECK(!newElem->next()); + + if (!currentHead) + return !newElem->expired(productItem) ? newElem : newElem->next(); + + QBS_CHECK(!currentHead->expired(productItem)); + + if (newElem->expired(productItem)) + return currentHead; + + if (compareValuePriorities(productItem, currentHead, newElem) < 0) { + newElem->setNext(currentHead); + return newElem; + } + currentHead->setNext(mergeListValues(productItem, currentHead->next(), newElem)); + return currentHead; +} + +void ModulePropertyMerger::Private::mergePropertyFromLocalInstance( + const Item *productItem, Item *loadingItem, const QString &loadingName, Item *globalInstance, + const QString &name, const ValuePtr &value) +{ + const PropertyDeclaration decl = globalInstance->propertyDeclaration(name); + if (!decl.isValid()) { + if (value->type() == Value::ItemValueType || value->createdByPropertiesBlock()) + return; + throw ErrorInfo(Tr::tr("Property '%1' is not declared.") + .arg(name), value->location()); + } + if (const ErrorInfo error = decl.checkForDeprecation( + parameters.deprecationWarningMode(), value->location(), logger); + error.hasError()) { + handlePropertyError(error, parameters, logger); + return; + } + if (value->setInternally()) { // E.g. qbs.architecture after multiplexing. + globalInstance->setProperty(decl.name(), value); + return; + } + QBS_CHECK(value->type() != Value::ItemValueType); + const ValuePtr globalVal = globalInstance->ownProperty(decl.name()); + value->setScope(loadingItem, loadingName); + QBS_CHECK(globalVal); + + // Values set internally cannot be overridden by JS values. + // The same goes for values set on the command line. + // Note that in both cases, there is no merging for list properties: The override is absolute. + if (globalVal->setInternally() || globalVal->setByCommandLine()) + return; + + QBS_CHECK(value->type() == Value::JSSourceValueType); + + if (decl.isScalar()) { + QBS_CHECK(!globalVal->expired(productItem)); + QBS_CHECK(!value->expired(productItem)); + if (compareValuePriorities(productItem, globalVal, value) < 0) { + value->setCandidates(globalVal->candidates()); + globalVal->setCandidates({}); + value->addCandidate(globalVal); + globalInstance->setProperty(decl.name(), value); + } else { + globalVal->addCandidate(value); + } + } else { + if (const ValuePtr &newChainStart = mergeListValues(productItem, globalVal, value); + newChainStart != globalVal) { + globalInstance->setProperty(decl.name(), newChainStart); + } + } +} + +bool ModulePropertyMerger::Private::doFinalMerge(const Item *productItem, Item *moduleItem) +{ + if (!moduleItem->isPresentModule()) + return false; + bool mustInvalidateCache = false; + for (auto it = moduleItem->properties().begin(); it != moduleItem->properties().end(); ++it) { + if (doFinalMerge(productItem, moduleItem->propertyDeclaration(it.key()), it.value())) + mustInvalidateCache = true; + } + return mustInvalidateCache; +} + +bool ModulePropertyMerger::Private::doFinalMerge( + const Item *productItem, const PropertyDeclaration &propertyDecl, ValuePtr &propertyValue) +{ + if (propertyValue->type() == Value::VariantValueType) { + QBS_CHECK(!propertyValue->next()); + return false; + } + if (!propertyDecl.isValid()) + return false; // Caught later by dedicated checker. + propertyValue->resetPriority(); + if (propertyDecl.isScalar()) { + if (propertyValue->candidates().empty()) + return false; + std::pair<int, std::vector<ValuePtr>> candidatesWithHighestPrio; + candidatesWithHighestPrio.first = propertyValue->priority(productItem); + candidatesWithHighestPrio.second.push_back(propertyValue); + for (const ValuePtr &v : propertyValue->candidates()) { + const int prio = v->priority(productItem); + if (prio < candidatesWithHighestPrio.first) + continue; + if (prio > candidatesWithHighestPrio.first) { + candidatesWithHighestPrio.first = prio; + candidatesWithHighestPrio.second = {v}; + continue; + } + candidatesWithHighestPrio.second.push_back(v); + } + ValuePtr chosenValue = candidatesWithHighestPrio.second.front(); + if (int(candidatesWithHighestPrio.second.size()) > 1) { + ErrorInfo error(Tr::tr("Conflicting scalar values for property '%1'.") + .arg(propertyDecl.name())); + error.append({}, chosenValue->location()); + QBS_CHECK(chosenValue->type() == Value::JSSourceValueType); + QStringView sourcCode = static_cast<JSSourceValue *>( + chosenValue.get())->sourceCode(); + for (int i = 1; i < int(candidatesWithHighestPrio.second.size()); ++i) { + const ValuePtr &v = candidatesWithHighestPrio.second.at(i); + QBS_CHECK(v->type() == Value::JSSourceValueType); + + // Note that this is a bit silly: The source code could still evaluate to + // different values in the end. + if (static_cast<JSSourceValue *>(v.get())->sourceCode() != sourcCode) + error.append({}, v->location()); + } + if (error.items().size() > 2) + logger.printWarning(error); + } + + if (propertyValue == chosenValue) + return false; + propertyValue = chosenValue; + return true; + } + if (!propertyValue->next()) + return false; + std::vector<ValuePtr> singleValuesBefore; + for (ValuePtr current = propertyValue; current;) { + singleValuesBefore.push_back(current); + const ValuePtr next = current->next(); + if (next) + current->setNext({}); + current = next; + } + ValuePtr newValue; + for (const ValuePtr &v : singleValuesBefore) + newValue = mergeListValues(productItem, newValue, v); + std::vector<ValuePtr> singleValuesAfter; + for (ValuePtr current = propertyValue; current; current = current->next()) + singleValuesAfter.push_back(current); + propertyValue = newValue; + return singleValuesBefore != singleValuesAfter; +} + +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/modulepropertymerger.h b/src/lib/corelib/language/modulepropertymerger.h new file mode 100644 index 000000000..fc388cfbf --- /dev/null +++ b/src/lib/corelib/language/modulepropertymerger.h @@ -0,0 +1,99 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#pragma once + +#include <QtGlobal> + +namespace qbs { +class SetupProjectParameters; +namespace Internal { +class Evaluator; +class Item; +class Logger; + +// This class comprises functions for collecting values attached to module properties +// in different contexts. +// For example, in the Qt.core module you will find a property binding such as this: +// cpp.defines: "QT_CORE_LIB" +// while in the Qt.widgets module, it will look like this: +// cpp.defines: "QT_WIDGETS_LIB" +// A product with a dependency on both these modules will end up with a value of +// ["QT_WIDGETS_LIB", "QT_CORE_LIB"], plus potentially other defines set elsewhere. +// Each of these values is assigned a priority that roughly corresponds to the "level" at which +// the module containing the property binding resides in the dependency hierarchy. +// For list properties, the priorities determine the order of the respecive values in the +// final array, for scalar values they determine which one survives. Different scalar values +// with the same priority trigger a warning message. +// Since the right-hand side of a binding can refer to properties of the surrounding context, +// each such value gets its own scope. +class ModulePropertyMerger +{ +public: + ModulePropertyMerger(const SetupProjectParameters ¶meters, Evaluator &evaluator, + Logger &logger); + ~ModulePropertyMerger(); + + // This function is called when a module is loaded via a Depends item. + // loadingItem is the product or module containing the Depends item. + // loadingName is the name of that module. It is used as a tie-breaker for list property values + // with equal priority. + // localInstance is the module instance placeholder in the ItemValue of a property binding, + // i.e. the "cpp" in "cpp.defines". + // globalInstance is the actual module into which the properties from localInstance get merged. + void mergeFromLocalInstance(const Item *productItem, Item *loadingItem, + const QString &loadingName, const Item *localInstance, + Item *globalInstance); + + // This function is called after all dependencies have been resolved. It uses its global + // knowledge of module priorities to potentially adjust the order of list values or + // favor different scalar values. It can also remove previously merged-in values again; + // this can happen if a module fails to load after it already merged some values, or + // if it fails validation in the end. + void doFinalMerge(const Item *productItem); + + void printProfilingInfo(int indent); + +private: + class Private; + Private * const d; +}; + +} // namespace Internal +} // namespace qbs diff --git a/src/lib/corelib/language/moduleproviderloader.cpp b/src/lib/corelib/language/moduleproviderloader.cpp index dae8bba15..387b102d0 100644 --- a/src/lib/corelib/language/moduleproviderloader.cpp +++ b/src/lib/corelib/language/moduleproviderloader.cpp @@ -42,8 +42,8 @@ #include "builtindeclarations.h" #include "evaluator.h" +#include "item.h" #include "itemreader.h" -#include "moduleloader.h" #include "probesresolver.h" #include <language/scriptengine.h> @@ -269,6 +269,7 @@ QVariantMap ModuleProviderLoader::evaluateQbsModule(ProductContext &product) con { const QString properties[] = { QStringLiteral("sysroot"), + QStringLiteral("toolchain"), }; const auto qbsItemValue = std::static_pointer_cast<ItemValue>( product.item->property(StringConstants::qbsModule())); @@ -277,8 +278,15 @@ QVariantMap ModuleProviderLoader::evaluateQbsModule(ProductContext &product) con const ScopedJsValue val(m_evaluator->engine()->context(), m_evaluator->value(qbsItemValue->item(), property)); auto value = getJsVariant(m_evaluator->engine()->context(), val); - if (value.isValid()) - result[property] = std::move(value); + if (!value.isValid()) + continue; + + // The xcode module sets qbs.sysroot; the resulting value is bogus before the probes + // have run. + if (property == QLatin1String("sysroot") && !FileInfo::isAbsolute(value.toString())) + continue; + + result[property] = std::move(value); } return result; } @@ -342,8 +350,8 @@ QStringList ModuleProviderLoader::evaluateModuleProvider( << endl; stream << "}" << endl; stream.flush(); - Item * const providerItem = - m_reader->readFile(dummyItemFile.fileName(), dependsItemLocation); + Item * const providerItem = m_reader->setupItemFromFile( + dummyItemFile.fileName(), dependsItemLocation, *m_evaluator); if (providerItem->type() != ItemType::ModuleProvider) { throw ErrorInfo(Tr::tr("File '%1' declares an item of type '%2', " "but '%3' was expected.") @@ -353,9 +361,10 @@ QStringList ModuleProviderLoader::evaluateModuleProvider( providerItem->setScope(createProviderScope(product, qbsModule)); - providerItem->overrideProperties(moduleConfig, name.toString(), m_parameters, m_logger); + providerItem->overrideProperties(moduleConfig, name, m_parameters, m_logger); - m_probesResolver->resolveProbes(&product, providerItem); + product.info.probes << m_probesResolver->resolveProbes({product.name, product.uniqueName()}, + providerItem); EvalContextSwitcher contextSwitcher(m_evaluator->engine(), EvalContext::ModuleProvider); return m_evaluator->stringListValue(providerItem, QStringLiteral("searchPaths")); diff --git a/src/lib/corelib/language/moduleproviderloader.h b/src/lib/corelib/language/moduleproviderloader.h index 91a32ec80..0e4198092 100644 --- a/src/lib/corelib/language/moduleproviderloader.h +++ b/src/lib/corelib/language/moduleproviderloader.h @@ -41,23 +41,23 @@ #ifndef MODULEPROVIDERLOADER_H #define MODULEPROVIDERLOADER_H -#include "moduleloader.h" +#include "projecttreebuilder.h" #include "moduleproviderinfo.h" -#include "probesresolver.h" + +#include <tools/setupprojectparameters.h> #include <QtCore/qmap.h> #include <QtCore/qvariant.h> namespace qbs { namespace Internal { - +class ItemReader; class Logger; +class ProbesResolver; class ModuleProviderLoader { public: - using ProductContext = ModuleLoader::ProductContext; - using FallbackMode = ModuleLoader::FallbackMode; explicit ModuleProviderLoader(ItemReader *itemReader, Evaluator *evaluator, ProbesResolver *probesResolver, Logger &logger); diff --git a/src/lib/corelib/language/probesresolver.cpp b/src/lib/corelib/language/probesresolver.cpp index d2f3fefa2..1462c706b 100644 --- a/src/lib/corelib/language/probesresolver.cpp +++ b/src/lib/corelib/language/probesresolver.cpp @@ -40,14 +40,11 @@ #include "probesresolver.h" -#include "builtindeclarations.h" #include "evaluator.h" #include "filecontext.h" #include "item.h" #include "itemreader.h" #include "language.h" -#include "modulemerger.h" -#include "qualifiedid.h" #include "scriptengine.h" #include "value.h" @@ -58,6 +55,7 @@ #include <logging/translator.h> #include <tools/profiling.h> #include <tools/scripttools.h> +#include <tools/setupprojectparameters.h> #include <tools/stringconstants.h> #include <quickjs.h> @@ -83,19 +81,12 @@ static QString probeGlobalId(Item *probe) return id + QLatin1Char('_') + probe->file()->filePath(); } -ProbesResolver::ProbesResolver(Evaluator *evaluator, Logger &logger) - : m_evaluator(evaluator) - , m_logger(logger) +ProbesResolver::ProbesResolver(const SetupProjectParameters ¶meters, Evaluator &evaluator, + Logger &logger) + : m_parameters(parameters), m_evaluator(evaluator), m_logger(logger) { } -void ProbesResolver::setProjectParameters(SetupProjectParameters parameters) -{ - m_parameters = std::move(parameters); - m_elapsedTimeProbes = m_probesEncountered = m_probesRun = m_probesCachedCurrent - = m_probesCachedOld = 0; -} - void ProbesResolver::setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes) { m_oldProjectProbes.clear(); @@ -109,17 +100,19 @@ void ProbesResolver::setOldProductProbes( m_oldProductProbes = oldProbes; } -void ProbesResolver::resolveProbes(ModuleLoader::ProductContext *productContext, Item *item) +std::vector<ProbeConstPtr> ProbesResolver::resolveProbes(const ProductContext &productContext, Item *item) { AccumulatingTimer probesTimer(m_parameters.logElapsedTime() ? &m_elapsedTimeProbes : nullptr); - EvalContextSwitcher evalContextSwitcher(m_evaluator->engine(), EvalContext::ProbeExecution); + EvalContextSwitcher evalContextSwitcher(m_evaluator.engine(), EvalContext::ProbeExecution); + std::vector<ProbeConstPtr> probes; for (Item * const child : item->children()) if (child->type() == ItemType::Probe) - resolveProbe(productContext, item, child); + probes.push_back(resolveProbe(productContext, item, child)); + return probes; } -void ProbesResolver::resolveProbe(ModuleLoader::ProductContext *productContext, Item *parent, - Item *probe) +ProbeConstPtr ProbesResolver::resolveProbe(const ProductContext &productContext, Item *parent, + Item *probe) { qCDebug(lcModuleLoader) << "Resolving Probe at " << probe->location().toString(); ++m_probesEncountered; @@ -133,7 +126,7 @@ void ProbesResolver::resolveProbe(ModuleLoader::ProductContext *productContext, throw ErrorInfo(Tr::tr("Probe.configure must be set."), probe->location()); using ProbeProperty = std::pair<QString, ScopedJsValue>; std::vector<ProbeProperty> probeBindings; - ScriptEngine * const engine = m_evaluator->engine(); + ScriptEngine * const engine = m_evaluator.engine(); JSContext * const ctx = engine->context(); QVariantMap initialProperties; for (Item *obj = probe; obj; obj = obj->prototype()) { @@ -142,22 +135,21 @@ void ProbesResolver::resolveProbe(ModuleLoader::ProductContext *productContext, const QString &name = it.key(); if (name == StringConstants::configureProperty()) continue; - const JSValue value = m_evaluator->value(probe, name); + const JSValue value = m_evaluator.value(probe, name); probeBindings.emplace_back(name, ScopedJsValue(ctx, value)); if (name != StringConstants::conditionProperty()) initialProperties.insert(name, getJsVariant(ctx, value)); } } - const bool condition = m_evaluator->boolValue(probe, StringConstants::conditionProperty()); + const bool condition = m_evaluator.boolValue(probe, StringConstants::conditionProperty()); const QString &sourceCode = configureScript->sourceCode().toString(); ProbeConstPtr resolvedProbe; if (parent->type() == ItemType::Project - || productContext->name.startsWith(StringConstants::shadowProductPrefix())) { + || productContext.name.startsWith(StringConstants::shadowProductPrefix())) { resolvedProbe = findOldProjectProbe(probeId, condition, initialProperties, sourceCode); } else { - const QString &uniqueProductName = productContext->uniqueName(); - resolvedProbe - = findOldProductProbe(uniqueProductName, condition, initialProperties, sourceCode); + resolvedProbe = findOldProductProbe(productContext.uniqueName, condition, + initialProperties, sourceCode); } if (!resolvedProbe) { resolvedProbe = findCurrentProbe(probe->location(), condition, initialProperties); @@ -177,7 +169,7 @@ void ProbesResolver::resolveProbe(ModuleLoader::ProductContext *productContext, ++m_probesRun; qCDebug(lcModuleLoader) << "configure script needs to run"; const Evaluator::FileContextScopes fileCtxScopes - = m_evaluator->fileContextScopes(configureScript->file()); + = m_evaluator.fileContextScopes(configureScript->file()); configureScope.setValue(engine->newObject()); for (const ProbeProperty &b : probeBindings) setJsProperty(ctx, configureScope, b.first, JS_DupValue(ctx, b.second)); @@ -202,7 +194,7 @@ void ProbesResolver::resolveProbe(ModuleLoader::ProductContext *productContext, const JSValue saved = v; ScopedJsValue valueMgr(ctx, saved); const PropertyDeclaration decl = probe->propertyDeclaration(b.first); - m_evaluator->convertToPropertyType(decl, probe->location(), v); + m_evaluator.convertToPropertyType(decl, probe->location(), v); // If the value was converted from scalar to array as per our convenience // functionality, then the original value is now the only element of a @@ -230,7 +222,7 @@ void ProbesResolver::resolveProbe(ModuleLoader::ProductContext *productContext, importedFilesUsedInConfigure); m_currentProbes[probe->location()] << resolvedProbe; } - productContext->info.probes << resolvedProbe; + return resolvedProbe; } ProbeConstPtr ProbesResolver::findOldProjectProbe( @@ -291,16 +283,18 @@ bool ProbesResolver::probeMatches(const ProbeConstPtr &probe, bool condition, && !probe->needsReconfigure(m_lastResolveTime))); } -void ProbesResolver::printProfilingInfo() +void ProbesResolver::printProfilingInfo(int indent) { if (!m_parameters.logElapsedTime()) return; - m_logger.qbsLog(LoggerInfo, true) << "\t\t" - << Tr::tr("Running Probes took %1.") - .arg(elapsedTimeString(m_elapsedTimeProbes)); - m_logger.qbsLog(LoggerInfo, true) << "\t\t" - << Tr::tr("%1 probes encountered, %2 configure scripts executed, " - "%3 re-used from current run, %4 re-used from earlier run.") + const QByteArray prefix(indent, ' '); + m_logger.qbsLog(LoggerInfo, true) + << prefix + << Tr::tr("Running Probes took %1.").arg(elapsedTimeString(m_elapsedTimeProbes)); + m_logger.qbsLog(LoggerInfo, true) + << prefix + << Tr::tr("%1 probes encountered, %2 configure scripts executed, " + "%3 re-used from current run, %4 re-used from earlier run.") .arg(m_probesEncountered).arg(m_probesRun).arg(m_probesCachedCurrent) .arg(m_probesCachedOld); } diff --git a/src/lib/corelib/language/probesresolver.h b/src/lib/corelib/language/probesresolver.h index 1aeec27ce..4aae0b887 100644 --- a/src/lib/corelib/language/probesresolver.h +++ b/src/lib/corelib/language/probesresolver.h @@ -41,21 +41,35 @@ #ifndef PROBESRESOLVER_H #define PROBESRESOLVER_H -#include "moduleloader.h" +#include "forward_decls.h" + +#include <tools/filetime.h> + +#include <QString> + +#include <vector> namespace qbs { +class SetupProjectParameters; namespace Internal { +class Item; +class Evaluator; +class Logger; class ProbesResolver { public: - explicit ProbesResolver(Evaluator *evaluator, Logger &logger); - void setProjectParameters(SetupProjectParameters parameters); + explicit ProbesResolver(const SetupProjectParameters ¶meters, Evaluator &evaluator, + Logger &logger); void setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes); void setOldProductProbes(const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes); - void resolveProbes(ModuleLoader::ProductContext *productContext, Item *item); - void resolveProbe(ModuleLoader::ProductContext *productContext, Item *parent, Item *probe); - void printProfilingInfo(); + void printProfilingInfo(int indent); + + struct ProductContext { + const QString &name; + const QString &uniqueName; + }; + std::vector<ProbeConstPtr> resolveProbes(const ProductContext &productContext, Item *item); private: ProbeConstPtr findOldProjectProbe(const QString &globalId, bool condition, @@ -70,6 +84,7 @@ private: bool probeMatches(const ProbeConstPtr &probe, bool condition, const QVariantMap &initialProperties, const QString &configureScript, CompareScript compareScript) const; + ProbeConstPtr resolveProbe(const ProductContext &productContext, Item *parent, Item *probe); qint64 m_elapsedTimeProbes = 0; quint64 m_probesEncountered = 0; @@ -77,8 +92,8 @@ private: quint64 m_probesCachedCurrent = 0; quint64 m_probesCachedOld = 0; - SetupProjectParameters m_parameters; - Evaluator *m_evaluator = nullptr; + const SetupProjectParameters &m_parameters; + Evaluator &m_evaluator; Logger &m_logger; QHash<QString, std::vector<ProbeConstPtr>> m_oldProjectProbes; QHash<QString, std::vector<ProbeConstPtr>> m_oldProductProbes; diff --git a/src/lib/corelib/language/productitemmultiplexer.cpp b/src/lib/corelib/language/productitemmultiplexer.cpp new file mode 100644 index 000000000..c737be7f1 --- /dev/null +++ b/src/lib/corelib/language/productitemmultiplexer.cpp @@ -0,0 +1,288 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "productitemmultiplexer.h" + +#include "evaluator.h" +#include "item.h" +#include "scriptengine.h" +#include "value.h" + +#include <logging/translator.h> +#include <tools/scripttools.h> +#include <tools/setupprojectparameters.h> +#include <tools/stringconstants.h> + +#include <QJsonDocument> +#include <QThreadStorage> + +#include <vector> + + +namespace qbs::Internal { +namespace { +using MultiplexConfigurationByIdTable = QThreadStorage<QHash<QString, QVariantMap>>; +using MultiplexRow = std::vector<VariantValuePtr>; +using MultiplexTable = std::vector<MultiplexRow>; +class MultiplexInfo +{ +public: + std::vector<QString> properties; + MultiplexTable table; + bool aggregate = false; + VariantValuePtr multiplexedType; + + QString toIdString(size_t row) const; +}; +} // namespace + +Q_GLOBAL_STATIC(MultiplexConfigurationByIdTable, multiplexConfigurationsById); + +class ProductItemMultiplexer::Private +{ +public: + Private(const SetupProjectParameters ¶meters, Evaluator &evaluator, Logger &logger, + QbsItemRetriever qbsItemRetriever) + : parameters(parameters), evaluator(evaluator), logger(logger), + qbsItemRetriever(std::move(qbsItemRetriever)) {} + + MultiplexInfo extractMultiplexInfo(Item *productItem, Item *qbsModuleItem); + MultiplexTable combine(const MultiplexTable &table, const MultiplexRow &values); + + const SetupProjectParameters ¶meters; + Evaluator &evaluator; + Logger &logger; + const QbsItemRetriever qbsItemRetriever; +}; + +ProductItemMultiplexer::ProductItemMultiplexer( + const SetupProjectParameters ¶meters, Evaluator &evaluator, Logger &logger, + const QbsItemRetriever &qbsItemRetriever) + : d(new Private(parameters, evaluator, logger, qbsItemRetriever)) {} + +ProductItemMultiplexer::~ProductItemMultiplexer() { delete d; } + +QList<Item *> ProductItemMultiplexer::multiplex( + const QString &productName, + Item *productItem, + Item *tempQbsModuleItem, + const std::function<void ()> &dropTempQbsModule) +{ + const auto multiplexInfo = d->extractMultiplexInfo(productItem, tempQbsModuleItem); + dropTempQbsModule(); + if (multiplexInfo.table.size() > 1) + productItem->setProperty(StringConstants::multiplexedProperty(), VariantValue::trueValue()); + VariantValuePtr productNameValue = VariantValue::create(productName); + Item *aggregator = multiplexInfo.aggregate ? productItem->clone() : nullptr; + QList<Item *> additionalProductItems; + std::vector<VariantValuePtr> multiplexConfigurationIdValues; + for (size_t row = 0; row < multiplexInfo.table.size(); ++row) { + Item *item = productItem; + const auto &mprow = multiplexInfo.table.at(row); + QBS_CHECK(mprow.size() == multiplexInfo.properties.size()); + if (row > 0) { + item = productItem->clone(); + additionalProductItems.push_back(item); + } + const QString multiplexConfigurationId = multiplexInfo.toIdString(row); + const VariantValuePtr multiplexConfigurationIdValue + = VariantValue::create(multiplexConfigurationId); + if (multiplexInfo.table.size() > 1 || aggregator) { + multiplexConfigurationIdValues.push_back(multiplexConfigurationIdValue); + item->setProperty(StringConstants::multiplexConfigurationIdProperty(), + multiplexConfigurationIdValue); + } + if (multiplexInfo.multiplexedType) + item->setProperty(StringConstants::typeProperty(), multiplexInfo.multiplexedType); + for (size_t column = 0; column < mprow.size(); ++column) { + Item * const qbsItem = d->qbsItemRetriever(item); + const QString &propertyName = multiplexInfo.properties.at(column); + const VariantValuePtr &mpvalue = mprow.at(column); + qbsItem->setProperty(propertyName, mpvalue); + } + } + + if (aggregator) { + additionalProductItems << aggregator; + + // Add dependencies to all multiplexed instances. + for (const auto &v : multiplexConfigurationIdValues) { + Item *dependsItem = Item::create(aggregator->pool(), ItemType::Depends); + dependsItem->setProperty(StringConstants::nameProperty(), productNameValue); + dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), v); + dependsItem->setProperty(StringConstants::profilesProperty(), + VariantValue::create(QStringList())); + dependsItem->setFile(aggregator->file()); + dependsItem->setupForBuiltinType(d->parameters.deprecationWarningMode(), d->logger); + Item::addChild(aggregator, dependsItem); + } + } + + return additionalProductItems; +} + +MultiplexInfo ProductItemMultiplexer::Private::extractMultiplexInfo(Item *productItem, + Item *qbsModuleItem) +{ + static const QString mpmKey = QStringLiteral("multiplexMap"); + + JSContext * const ctx = evaluator.engine()->context(); + const ScopedJsValue multiplexMap(ctx, evaluator.value(qbsModuleItem, mpmKey)); + const QStringList multiplexByQbsProperties = evaluator.stringListValue( + productItem, StringConstants::multiplexByQbsPropertiesProperty()); + + MultiplexInfo multiplexInfo; + multiplexInfo.aggregate = evaluator.boolValue( + productItem, StringConstants::aggregateProperty()); + + const QString multiplexedType = evaluator.stringValue( + productItem, StringConstants::multiplexedTypeProperty()); + if (!multiplexedType.isEmpty()) + multiplexInfo.multiplexedType = VariantValue::create(multiplexedType); + + Set<QString> uniqueMultiplexByQbsProperties; + for (const QString &key : multiplexByQbsProperties) { + const QString mappedKey = getJsStringProperty(ctx, multiplexMap, key); + if (mappedKey.isEmpty()) + throw ErrorInfo(Tr::tr("There is no entry for '%1' in 'qbs.multiplexMap'.").arg(key)); + + if (!uniqueMultiplexByQbsProperties.insert(mappedKey).second) { + throw ErrorInfo(Tr::tr("Duplicate entry '%1' in Product.%2.") + .arg(mappedKey, StringConstants::multiplexByQbsPropertiesProperty()), + productItem->location()); + } + + const ScopedJsValue arr(ctx, evaluator.value(qbsModuleItem, key)); + if (JS_IsUndefined(arr)) + continue; + if (!JS_IsArray(ctx, arr)) + throw ErrorInfo(Tr::tr("Property '%1' must be an array.").arg(key)); + + const quint32 arrlen = getJsIntProperty(ctx, arr, StringConstants::lengthProperty()); + if (arrlen == 0) + continue; + + MultiplexRow mprow; + mprow.resize(arrlen); + QVariantList entriesForKey; + for (quint32 i = 0; i < arrlen; ++i) { + const ScopedJsValue sv(ctx, JS_GetPropertyUint32(ctx, arr, i)); + const QVariant value = getJsVariant(ctx, sv); + if (entriesForKey.contains(value)) { + throw ErrorInfo(Tr::tr("Duplicate entry '%1' in qbs.%2.") + .arg(value.toString(), key), productItem->location()); + } + entriesForKey << value; + mprow[i] = VariantValue::create(value); + } + multiplexInfo.table = combine(multiplexInfo.table, mprow); + multiplexInfo.properties.push_back(mappedKey); + } + return multiplexInfo; + +} + +MultiplexTable ProductItemMultiplexer::Private::combine(const MultiplexTable &table, + const MultiplexRow &values) +{ + MultiplexTable result; + if (table.empty()) { + result.resize(values.size()); + for (size_t i = 0; i < values.size(); ++i) { + MultiplexRow row; + row.resize(1); + row[0] = values.at(i); + result[i] = row; + } + } else { + for (const auto &row : table) { + for (const auto &value : values) { + MultiplexRow newRow = row; + newRow.push_back(value); + result.push_back(newRow); + } + } + } + return result; +} + +QVariantMap ProductItemMultiplexer::multiplexIdToVariantMap(const QString &multiplexId) +{ + if (multiplexId.isEmpty()) + return QVariantMap(); + + // We assume that MultiplexInfo::toIdString() has been called for this + // particular multiplex configuration. + QVariantMap result = multiplexConfigurationsById->localData().value(multiplexId); + QBS_CHECK(!result.isEmpty()); + return result; +} + +QString ProductItemMultiplexer::fullProductDisplayName(const QString &name, + const QString &multiplexId) +{ + static const auto multiplexIdToString =[](const QString &id) { + return QString::fromUtf8(QByteArray::fromBase64(id.toUtf8())); + }; + QString result = name; + if (!multiplexId.isEmpty()) + result.append(QLatin1Char(' ')).append(multiplexIdToString(multiplexId)); + return result; +} + +QString MultiplexInfo::toIdString(size_t row) const +{ + const auto &mprow = table.at(row); + QVariantMap multiplexConfiguration; + for (size_t column = 0; column < mprow.size(); ++column) { + const QString &propertyName = properties.at(column); + const VariantValuePtr &mpvalue = mprow.at(column); + multiplexConfiguration.insert(propertyName, mpvalue->value()); + } + QString id = QString::fromUtf8(QJsonDocument::fromVariant(multiplexConfiguration) + .toJson(QJsonDocument::Compact) + .toBase64()); + + // Cache for later use in multiplexIdToVariantMap() + multiplexConfigurationsById->localData().insert(id, multiplexConfiguration); + + return id; +} + +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/productitemmultiplexer.h b/src/lib/corelib/language/productitemmultiplexer.h new file mode 100644 index 000000000..d99267336 --- /dev/null +++ b/src/lib/corelib/language/productitemmultiplexer.h @@ -0,0 +1,84 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#pragma once + +#include <QList> +#include <QVariantMap> + +#include <functional> + +namespace qbs { +class SetupProjectParameters; +namespace Internal { +class Evaluator; +class Item; +class Logger; + +// This class deals with product multiplexing over the various defined axes. +// For instance, a product with qbs.architectures: ["x86", "arm"] will get multiplexed into +// two products with qbs.architecture: "x86" and qbs.architecture: "arm", respectively. +class ProductItemMultiplexer +{ +public: + using QbsItemRetriever = std::function<Item *(Item *)>; + ProductItemMultiplexer(const SetupProjectParameters ¶meters, Evaluator &evaluator, + Logger &logger, const QbsItemRetriever &qbsItemRetriever); + ~ProductItemMultiplexer(); + + // Checks whether the product item is to be multiplexed and returns the list of additional + // product items. In the normal, non-multiplex case, this list is empty. + QList<Item *> multiplex( + const QString &productName, + Item *productItem, + Item *tempQbsModuleItem, + const std::function<void()> &dropTempQbsModule + ); + + QVariantMap multiplexIdToVariantMap(const QString &multiplexId); + + static QString fullProductDisplayName(const QString &name, const QString &multiplexId); + +private: + class Private; + Private * const d; +}; + +} // namespace Internal +} // namespace qbs diff --git a/src/lib/corelib/language/projectresolver.cpp b/src/lib/corelib/language/projectresolver.cpp index c2c8ba134..403fd35bc 100644 --- a/src/lib/corelib/language/projectresolver.cpp +++ b/src/lib/corelib/language/projectresolver.cpp @@ -117,7 +117,7 @@ struct ProjectResolver::ModuleContext class CancelException { }; -ProjectResolver::ProjectResolver(Evaluator *evaluator, ModuleLoaderResult loadResult, +ProjectResolver::ProjectResolver(Evaluator *evaluator, ProjectTreeBuilder::Result loadResult, SetupProjectParameters setupParameters, Logger &logger) : m_evaluator(evaluator) , m_logger(logger) @@ -261,7 +261,7 @@ TopLevelProjectPtr ProjectResolver::resolveTopLevelProject() project->environment = m_engine->environment(); project->buildSystemFiles.unite(m_engine->imports()); makeSubProjectNamesUniqe(project); - resolveProductDependencies(projectContext); + resolveProductDependencies(); collectExportedProductDependencies(); checkForDuplicateProductNames(project); @@ -411,9 +411,32 @@ void ProjectResolver::resolveProduct(Item *item, ProjectContext *projectContext) productContext.product = product; product->location = item->location(); ProductContextSwitcher contextSwitcher(this, &productContext, m_progressObserver); + const auto errorFromDelayedError = [&] { + ProjectTreeBuilder::Result::ProductInfo &pi = m_loadResult.productInfos[item]; + if (pi.delayedError.hasError()) { + ErrorInfo errorInfo; + + // First item is "main error", gets prepended again in the catch clause. + const QList<ErrorItem> &items = pi.delayedError.items(); + for (int i = 1; i < items.size(); ++i) + errorInfo.append(items.at(i)); + + pi.delayedError.clear(); + return errorInfo; + } + return ErrorInfo(); + }; + + // Even if we previously encountered an error, try to continue for as long as possible + // to provide IDEs with useful data (e.g. the list of files). + // If we encounter a follow-up error, suppress it and report the original one instead. try { resolveProductFully(item, projectContext); - } catch (const ErrorInfo &e) { + if (const ErrorInfo error = errorFromDelayedError(); error.hasError()) + throw error; + } catch (ErrorInfo e) { + if (const ErrorInfo error = errorFromDelayedError(); error.hasError()) + e = error; QString mainErrorString = !product->name.isEmpty() ? Tr::tr("Error while handling product '%1':").arg(product->name) : Tr::tr("Error while handling product:"); @@ -445,21 +468,10 @@ void ProjectResolver::resolveProductFully(Item *item, ProjectContext *projectCon product->multiplexConfigurationId = m_evaluator->stringValue(item, StringConstants::multiplexConfigurationIdProperty()); qCDebug(lcProjectResolver) << "resolveProduct" << product->uniqueName(); - m_productsByName.insert(product->uniqueName(), product); + m_productsByItem.insert(item, product); product->enabled = product->enabled && m_evaluator->boolValue(item, StringConstants::conditionProperty()); - ModuleLoaderResult::ProductInfo &pi = m_loadResult.productInfos[item]; - if (pi.delayedError.hasError()) { - ErrorInfo errorInfo; - - // First item is "main error", gets prepended again in the catch clause. - const QList<ErrorItem> &items = pi.delayedError.items(); - for (int i = 1; i < items.size(); ++i) - errorInfo.append(items.at(i)); - - pi.delayedError.clear(); - throw errorInfo; - } + ProjectTreeBuilder::Result::ProductInfo &pi = m_loadResult.productInfos[item]; gatherProductTypes(product.get(), item); product->targetName = m_evaluator->stringValue(item, StringConstants::targetNameProperty()); product->sourceDirectory = m_evaluator->stringValue( @@ -526,8 +538,10 @@ void ProjectResolver::resolveProductFully(Item *item, ProjectContext *projectCon void ProjectResolver::resolveModules(const Item *item, ProjectContext *projectContext) { JobLimits jobLimits; - for (const Item::Module &m : item->modules()) - resolveModule(m.name, m.item, m.isProduct, m.parameters, jobLimits, projectContext); + for (const Item::Module &m : item->modules()) { + resolveModule(m.name, m.item, m.productInfo.has_value(), m.parameters, jobLimits, + projectContext); + } for (int i = 0; i < jobLimits.count(); ++i) { const JobLimit &moduleJobLimit = jobLimits.jobLimitAt(i); if (m_productContext->product->jobLimits.getLimit(moduleJobLimit.pool()) == -1) @@ -592,15 +606,9 @@ void ProjectResolver::resolveModule(const QualifiedId &moduleName, Item *item, b void ProjectResolver::gatherProductTypes(ResolvedProduct *product, Item *item) { - product->fileTags = m_evaluator->fileTagsValue(item, StringConstants::typeProperty()); - for (const Item::Module &m : item->modules()) { - if (m.item->isPresentModule()) { - product->fileTags += m_evaluator->fileTagsValue(m.item, - StringConstants::additionalProductTypesProperty()); - } - } - item->setProperty(StringConstants::typeProperty(), - VariantValue::create(sorted(product->fileTags.toStringList()))); + const VariantValuePtr type = item->variantProperty(StringConstants::typeProperty()); + if (type) + product->fileTags = FileTags::fromStringList(type->value().toStringList()); } SourceArtifactPtr ProjectResolver::createSourceArtifact(const ResolvedProductPtr &rproduct, @@ -678,8 +686,7 @@ QVariantMap ProjectResolver::resolveAdditionalModuleProperties(const Item *group = QualifiedId(fullPropName.mid(0, fullPropName.size() - 1)).toString(); propsPerModule[moduleName] << fullPropName.last(); } - EvalCacheEnabler cachingEnabler(m_evaluator); - m_evaluator->setPathPropertiesBaseDir(m_productContext->product->sourceDirectory); + EvalCacheEnabler cachingEnabler(m_evaluator, m_productContext->product->sourceDirectory); for (const Item::Module &module : group->modules()) { const QString &fullModName = module.name.toString(); const QStringList propsForModule = propsPerModule.take(fullModName); @@ -691,7 +698,6 @@ QVariantMap ProjectResolver::resolveAdditionalModuleProperties(const Item *group modulesMap.insert(fullModName, evaluateProperties(module.item, module.item, reusableValues, true, true)); } - m_evaluator->clearPathPropertiesBaseDir(); return modulesMap; } @@ -938,37 +944,27 @@ void ProjectResolver::collectExportedProductDependencies() if (!exportingProduct->enabled) continue; Item * const importingProductItem = exportingProductInfo.second; - std::vector<QString> directDepNames; + + std::vector<std::pair<ResolvedProductPtr, QVariantMap>> directDeps; for (const Item::Module &m : importingProductItem->modules()) { - if (m.name.toString() == exportingProduct->name) { - for (const Item::Module &dep : m.item->modules()) { - if (dep.isProduct) - directDepNames.push_back(dep.name.toString()); + if (m.name.toString() != exportingProduct->name) + continue; + for (const Item::Module &dep : m.item->modules()) { + if (dep.productInfo) { + directDeps.emplace_back(m_productsByItem.value(dep.productInfo->item), + m.parameters); } - break; } } - const ModuleLoaderResult::ProductInfo &importingProductInfo - = mapValue(m_loadResult.productInfos, importingProductItem); - const ProductDependencyInfos &depInfos - = getProductDependencies(dummyProduct, importingProductInfo); - for (const auto &dep : depInfos.dependencies) { - if (dep.product == exportingProduct) - continue; - - // Filter out indirect dependencies. - // TODO: Depends items using "profile" or "productTypes" will not work. - if (!contains(directDepNames, dep.product->name)) - continue; - + for (const auto &dep : directDeps) { if (!contains(exportingProduct->exportedModule.productDependencies, - dep.product->uniqueName())) { + dep.first->uniqueName())) { exportingProduct->exportedModule.productDependencies.push_back( - dep.product->uniqueName()); + dep.first->uniqueName()); } - if (!dep.parameters.isEmpty()) { - exportingProduct->exportedModule.dependencyParameters.insert(dep.product, - dep.parameters); + if (!dep.second.isEmpty()) { + exportingProduct->exportedModule.dependencyParameters.insert(dep.first, + dep.second); } } auto &productDeps = exportingProduct->exportedModule.productDependencies; @@ -1406,64 +1402,6 @@ void ProjectResolver::resolveScanner(Item *item, ProjectResolver::ProjectContext m_productContext->product->scanners.push_back(scanner); } -ProjectResolver::ProductDependencyInfos ProjectResolver::getProductDependencies( - const ResolvedProductConstPtr &product, const ModuleLoaderResult::ProductInfo &productInfo) -{ - ProductDependencyInfos result; - result.dependencies.reserve(productInfo.usedProducts.size()); - for (const auto &dependency : productInfo.usedProducts) { - QBS_CHECK(!dependency.name.isEmpty()); - if (dependency.profile == StringConstants::star()) { - for (const ResolvedProductPtr &p : qAsConst(m_productsByName)) { - if (p->name != dependency.name || p == product || !p->enabled - || (dependency.limitToSubProject && !product->isInParentProject(p))) { - continue; - } - result.dependencies.emplace_back(p, dependency.parameters); - } - } else { - ResolvedProductPtr usedProduct = m_productsByName.value(dependency.uniqueName()); - const QString depDisplayName = ResolvedProduct::fullDisplayName(dependency.name, - dependency.multiplexConfigurationId); - if (!usedProduct) { - throw ErrorInfo(Tr::tr("Product '%1' depends on '%2', which does not exist.") - .arg(product->fullDisplayName(), depDisplayName), - product->location); - } - if (!dependency.profile.isEmpty() && usedProduct->profile() != dependency.profile) { - usedProduct.reset(); - for (const ResolvedProductPtr &p : qAsConst(m_productsByName)) { - if (p->name == dependency.name && p->profile() == dependency.profile) { - usedProduct = p; - break; - } - } - if (!usedProduct) { - throw ErrorInfo(Tr::tr("Product '%1' depends on '%2', which does not exist " - "for the requested profile '%3'.") - .arg(product->fullDisplayName(), depDisplayName, - dependency.profile), - product->location); - } - } - if (!usedProduct->enabled) { - if (!dependency.isRequired) - continue; - ErrorInfo e; - e.append(Tr::tr("Product '%1' depends on '%2',") - .arg(product->name, usedProduct->name), product->location); - e.append(Tr::tr("but product '%1' is disabled.").arg(usedProduct->name), - usedProduct->location); - if (m_setupParams.productErrorMode() == ErrorHandlingMode::Strict) - throw e; - result.hasDisabledDependency = true; - } - result.dependencies.emplace_back(usedProduct, dependency.parameters); - } - } - return result; -} - void ProjectResolver::matchArtifactProperties(const ResolvedProductPtr &product, const std::vector<SourceArtifactPtr> &artifacts) { @@ -1494,14 +1432,26 @@ void ProjectResolver::printProfilingInfo() class TempScopeSetter { public: - TempScopeSetter(Item * item, Item *newScope) : m_item(item), m_oldScope(item->scope()) + TempScopeSetter(const ValuePtr &value, Item *newScope) : m_value(value), m_oldScope(value->scope()) { - item->setScope(newScope); + value->setScope(newScope, {}); } - ~TempScopeSetter() { m_item->setScope(m_oldScope); } + ~TempScopeSetter() { if (m_value) m_value->setScope(m_oldScope, {}); } + + TempScopeSetter(const TempScopeSetter &) = delete; + TempScopeSetter &operator=(const TempScopeSetter &) = delete; + TempScopeSetter &operator=(TempScopeSetter &&) = delete; + + TempScopeSetter(TempScopeSetter &&other) noexcept + : m_value(std::move(other.m_value)), m_oldScope(other.m_oldScope) + { + other.m_value.reset(); + other.m_oldScope = nullptr; + } + private: - Item * const m_item; - Item * const m_oldScope; + ValuePtr m_value; + Item *m_oldScope; }; void ProjectResolver::collectPropertiesForExportItem(Item *productModuleInstance) @@ -1509,8 +1459,8 @@ void ProjectResolver::collectPropertiesForExportItem(Item *productModuleInstance if (!productModuleInstance->isPresentModule()) return; Item * const exportItem = productModuleInstance->prototype(); - QBS_CHECK(exportItem && exportItem->type() == ItemType::Export); - TempScopeSetter tempScopeSetter(exportItem, productModuleInstance->scope()); + QBS_CHECK(exportItem); + QBS_CHECK(exportItem->type() == ItemType::Export); const ItemDeclaration::Properties exportDecls = BuiltinDeclarations::instance() .declarationsForType(ItemType::Export).properties(); ExportedModule &exportedModule = m_productContext->product->exportedModule; @@ -1526,6 +1476,7 @@ void ProjectResolver::collectPropertiesForExportItem(Item *productModuleInstance collectPropertiesForExportItem(it.key(), it.value(), productModuleInstance, exportedModule.modulePropertyValues); } else { + TempScopeSetter tss(it.value(), productModuleInstance); evaluateProperty(exportItem, it.key(), it.value(), exportedModule.propertyValues, false); } @@ -1538,7 +1489,7 @@ void ProjectResolver::collectPropertiesForModuleInExportItem(const Item::Module if (!module.item->isPresentModule()) return; ExportedModule &exportedModule = m_productContext->product->exportedModule; - if (module.isProduct || module.name.first() == StringConstants::qbsModule()) + if (module.productInfo || module.name.first() == StringConstants::qbsModule()) return; const auto checkName = [module](const ExportedModuleDependency &d) { return module.name.toString() == d.name; @@ -1551,7 +1502,6 @@ void ProjectResolver::collectPropertiesForModuleInExportItem(const Item::Module modulePrototype = modulePrototype->prototype(); if (!modulePrototype) // Can happen for broken products in relaxed mode. return; - TempScopeSetter tempScopeSetter(modulePrototype, module.item->scope()); const Item::PropertyMap &props = modulePrototype->properties(); ExportedModuleDependency dep; dep.name = module.name.toString(); @@ -1565,107 +1515,25 @@ void ProjectResolver::collectPropertiesForModuleInExportItem(const Item::Module collectPropertiesForModuleInExportItem(dep); } -static bool hasDependencyCycle(Set<ResolvedProduct *> *checked, - Set<ResolvedProduct *> *branch, - const ResolvedProductPtr &product, - ErrorInfo *error) -{ - if (branch->contains(product.get())) - return true; - if (checked->contains(product.get())) - return false; - checked->insert(product.get()); - branch->insert(product.get()); - for (const ResolvedProductPtr &dep : qAsConst(product->dependencies)) { - if (hasDependencyCycle(checked, branch, dep, error)) { - error->prepend(dep->name, dep->location); - return true; - } - } - branch->remove(product.get()); - return false; -} - -using DependencyMap = QHash<ResolvedProduct *, Set<ResolvedProduct *>>; -void gatherDependencies(ResolvedProduct *product, DependencyMap &dependencies) -{ - if (dependencies.contains(product)) - return; - // Hold locally because the QHash references aren't stable in Qt6. - Set<ResolvedProduct *> productDeps = dependencies[product]; - for (const ResolvedProductPtr &dep : qAsConst(product->dependencies)) { - productDeps << dep.get(); - gatherDependencies(dep.get(), dependencies); - productDeps += dependencies.value(dep.get()); - } - // Now that we gathered the dependencies, put them in the map. - dependencies[product] = std::move(productDeps); -} - - - -static DependencyMap allDependencies(const std::vector<ResolvedProductPtr> &products) -{ - DependencyMap dependencies; - for (const ResolvedProductPtr &product : products) - gatherDependencies(product.get(), dependencies); - return dependencies; -} - -void ProjectResolver::resolveProductDependencies(const ProjectContext &projectContext) +void ProjectResolver::resolveProductDependencies() { - // Resolve all inter-product dependencies. - const std::vector<ResolvedProductPtr> allProducts = projectContext.project->allProducts(); - bool disabledDependency = false; - for (const ResolvedProductPtr &rproduct : allProducts) { - if (!rproduct->enabled) - continue; - Item *productItem = m_productItemMap.value(rproduct); - const ModuleLoaderResult::ProductInfo &productInfo - = mapValue(m_loadResult.productInfos, productItem); - const ProductDependencyInfos &depInfos = getProductDependencies(rproduct, productInfo); - if (depInfos.hasDisabledDependency) - disabledDependency = true; - for (const auto &dep : depInfos.dependencies) { - if (!contains(rproduct->dependencies, dep.product)) - rproduct->dependencies.push_back(dep.product); - if (!dep.parameters.empty()) - rproduct->dependencyParameters.insert(dep.product, dep.parameters); - } - } - - // Check for cyclic dependencies. - Set<ResolvedProduct *> checked; - for (const ResolvedProductPtr &rproduct : allProducts) { - Set<ResolvedProduct *> branch; - ErrorInfo error; - if (hasDependencyCycle(&checked, &branch, rproduct, &error)) { - error.prepend(rproduct->name, rproduct->location); - error.prepend(Tr::tr("Cyclic dependencies detected.")); - throw error; - } - } - - // Mark all products as disabled that have a disabled dependency. - if (disabledDependency && m_setupParams.productErrorMode() == ErrorHandlingMode::Relaxed) { - const DependencyMap allDeps = allDependencies(allProducts); - DependencyMap allDepsReversed; - for (auto it = allDeps.constBegin(); it != allDeps.constEnd(); ++it) { - for (ResolvedProduct *dep : qAsConst(it.value())) - allDepsReversed[dep] << it.key(); - } - for (auto it = allDepsReversed.constBegin(); it != allDepsReversed.constEnd(); ++it) { - if (it.key()->enabled) + for (auto it = m_productsByItem.cbegin(); it != m_productsByItem.cend(); ++it) { + const ResolvedProductPtr &product = it.value(); + for (const Item::Module &module : it.key()->modules()) { + if (!module.productInfo) continue; - for (ResolvedProduct * const dependingProduct : qAsConst(it.value())) { - if (dependingProduct->enabled) { - m_logger.qbsWarning() << Tr::tr("Disabling product '%1', because it depends on " - "disabled product '%2'.") - .arg(dependingProduct->name, it.key()->name); - dependingProduct->enabled = false; - } - } + const ResolvedProductPtr &dep = m_productsByItem.value(module.productInfo->item); + QBS_CHECK(dep); + QBS_CHECK(dep != product); + it.value()->dependencies << dep; + it.value()->dependencyParameters.insert(dep, module.parameters); // TODO: Streamline this with normal module dependencies? } + + // TODO: We might want to keep the topological sorting and get rid of "module module dependencies". + std::sort(product->dependencies.begin(),product->dependencies.end(), + [](const ResolvedProductPtr &p1, const ResolvedProductPtr &p2) { + return p1->fullDisplayName() < p2->fullDisplayName(); + }); } } @@ -1854,13 +1722,20 @@ void ProjectResolver::collectPropertiesForExportItem(const QualifiedId &moduleNa { QBS_CHECK(value->type() == Value::ItemValueType); Item * const itemValueItem = std::static_pointer_cast<ItemValue>(value)->item(); - if (itemValueItem->type() == ItemType::ModuleInstance) { + if (itemValueItem->propertyDeclarations().isEmpty()) { + for (const Item::Module &module : moduleInstance->modules()) { + if (module.name == moduleName) { + itemValueItem->setPropertyDeclarations(module.item->propertyDeclarations()); + break; + } + } + } + if (itemValueItem->type() == ItemType::ModuleInstancePlaceholder) { struct EvalPreparer { - EvalPreparer(Item *valueItem, Item *moduleInstance, const QualifiedId &moduleName) - : valueItem(valueItem), oldScope(valueItem->scope()), + EvalPreparer(Item *valueItem, const QualifiedId &moduleName) + : valueItem(valueItem), hadName(!!valueItem->variantProperty(StringConstants::nameProperty())) { - valueItem->setScope(moduleInstance); if (!hadName) { // Evaluator expects a name here. valueItem->setProperty(StringConstants::nameProperty(), @@ -1869,15 +1744,16 @@ void ProjectResolver::collectPropertiesForExportItem(const QualifiedId &moduleNa } ~EvalPreparer() { - valueItem->setScope(oldScope); if (!hadName) valueItem->setProperty(StringConstants::nameProperty(), VariantValuePtr()); } Item * const valueItem; - Item * const oldScope; const bool hadName; }; - EvalPreparer ep(itemValueItem, moduleInstance, moduleName); + EvalPreparer ep(itemValueItem, moduleName); + std::vector<TempScopeSetter> tss; + for (const ValuePtr &v : itemValueItem->properties()) + tss.emplace_back(v, moduleInstance); moduleProps.insert(moduleName.toString(), evaluateProperties(itemValueItem, false, false)); return; } @@ -1892,12 +1768,10 @@ void ProjectResolver::collectPropertiesForExportItem(const QualifiedId &moduleNa void ProjectResolver::createProductConfig(ResolvedProduct *product) { - EvalCacheEnabler cachingEnabler(m_evaluator); - m_evaluator->setPathPropertiesBaseDir(m_productContext->product->sourceDirectory); + EvalCacheEnabler cachingEnabler(m_evaluator, m_productContext->product->sourceDirectory); product->moduleProperties->setValue(evaluateModuleValues(m_productContext->item)); product->productProperties = evaluateProperties(m_productContext->item, m_productContext->item, QVariantMap(), true, true); - m_evaluator->clearPathPropertiesBaseDir(); } void ProjectResolver::callItemFunction(const ItemFuncMap &mappings, Item *item, diff --git a/src/lib/corelib/language/projectresolver.h b/src/lib/corelib/language/projectresolver.h index 52d835535..a8b06b6e6 100644 --- a/src/lib/corelib/language/projectresolver.h +++ b/src/lib/corelib/language/projectresolver.h @@ -41,12 +41,14 @@ #define PROJECTRESOLVER_H #include "filetags.h" +#include "item.h" #include "itemtype.h" -#include "moduleloader.h" +#include "projecttreebuilder.h" #include "qualifiedid.h" #include <logging/logger.h> #include <tools/set.h> +#include <tools/setupprojectparameters.h> #include <QtCore/qhash.h> #include <QtCore/qmap.h> @@ -67,7 +69,7 @@ class ScriptEngine; class ProjectResolver { public: - ProjectResolver(Evaluator *evaluator, ModuleLoaderResult loadResult, + ProjectResolver(Evaluator *evaluator, ProjectTreeBuilder::Result loadResult, SetupProjectParameters setupParameters, Logger &logger); ~ProjectResolver(); @@ -122,7 +124,7 @@ private: void resolveFileTagger(Item *item, ProjectContext *projectContext); void resolveJobLimit(Item *item, ProjectContext *projectContext); void resolveScanner(Item *item, ProjectContext *projectContext); - void resolveProductDependencies(const ProjectContext &projectContext); + void resolveProductDependencies(); void postProcess(const ResolvedProductPtr &product, ProjectContext *projectContext) const; void applyFileTaggers(const ResolvedProductPtr &product) const; QVariantMap evaluateModuleValues(Item *item, bool lookupPrototype = true); @@ -152,14 +154,6 @@ private: QVariantMap parameters; }; - struct ProductDependencyInfos - { - std::vector<ProductDependencyInfo> dependencies; - bool hasDisabledDependency = false; - }; - - ProductDependencyInfos getProductDependencies(const ResolvedProductConstPtr &product, - const ModuleLoaderResult::ProductInfo &productInfo); QString sourceCodeAsFunction(const JSSourceValueConstPtr &value, const PropertyDeclaration &decl) const; QString sourceCodeForEvaluation(const JSSourceValueConstPtr &value) const; @@ -181,7 +175,7 @@ private: ProgressObserver *m_progressObserver = nullptr; ProductContext *m_productContext = nullptr; ModuleContext *m_moduleContext = nullptr; - QMap<QString, ResolvedProductPtr> m_productsByName; + QHash<Item *, ResolvedProductPtr> m_productsByItem; QHash<FileTag, QList<ResolvedProductPtr> > m_productsByType; QHash<ResolvedProductPtr, Item *> m_productItemMap; mutable QHash<FileContextConstPtr, ResolvedFileContextPtr> m_fileContextMap; @@ -189,7 +183,7 @@ private: mutable QHash<std::pair<QStringView, QStringList>, QString> m_scriptFunctions; mutable QHash<QStringView, QString> m_sourceCode; const SetupProjectParameters m_setupParams; - ModuleLoaderResult m_loadResult; + ProjectTreeBuilder::Result m_loadResult; Set<CodeLocation> m_groupLocationWarnings; std::vector<std::pair<ResolvedProductPtr, Item *>> m_productExportInfo; std::vector<ErrorInfo> m_queuedErrors; diff --git a/src/lib/corelib/language/projecttreebuilder.cpp b/src/lib/corelib/language/projecttreebuilder.cpp new file mode 100644 index 000000000..9910325ac --- /dev/null +++ b/src/lib/corelib/language/projecttreebuilder.cpp @@ -0,0 +1,2298 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "projecttreebuilder.h" + +#include "builtindeclarations.h" +#include "evaluator.h" +#include "filecontext.h" +#include "groupshandler.h" +#include "itemreader.h" +#include "language.h" +#include "localprofiles.h" +#include "moduleinstantiator.h" +#include "moduleloader.h" +#include "modulepropertymerger.h" +#include "moduleproviderloader.h" +#include "probesresolver.h" +#include "productitemmultiplexer.h" +#include "scriptengine.h" +#include "value.h" + +#include <logging/categories.h> +#include <logging/translator.h> +#include <tools/fileinfo.h> +#include <tools/filetime.h> +#include <tools/preferences.h> +#include <tools/progressobserver.h> +#include <tools/profile.h> +#include <tools/profiling.h> +#include <tools/scripttools.h> +#include <tools/settings.h> +#include <tools/setupprojectparameters.h> +#include <tools/stringconstants.h> + +#include <QDir> +#include <QDirIterator> +#include <QFileInfo> + +#include <list> +#include <memory> +#include <optional> +#include <queue> +#include <utility> +#include <vector> + +namespace qbs::Internal { + +using ShadowProductInfo = std::pair<bool, QString>; +enum class Deferral { Allowed, NotAllowed }; +enum class HandleDependency { Use, Ignore, Defer }; + +class SearchPathsManager { +public: + SearchPathsManager(ItemReader &itemReader, const QStringList &extraSearchPaths); + SearchPathsManager(ItemReader &itemReader, ProductContext &product); + ~SearchPathsManager(); + +private: + SearchPathsManager(ItemReader &itemReader, ProductContext *product, + const QStringList &extraSearchPaths); + + ItemReader &m_itemReader; + ProductContext * const m_product = nullptr; + size_t m_oldSize{0}; +}; + +class TimingData { +public: + qint64 prepareProducts = 0; + qint64 productDependencies = 0; + qint64 moduleProviders = 0; + qint64 handleProducts = 0; + qint64 propertyChecking = 0; +}; + +class ProjectTreeBuilder::Private +{ +public: + Private(const SetupProjectParameters ¶meters, ItemPool &itemPool, Evaluator &evaluator, + Logger &logger) + : parameters(parameters), itemPool(itemPool), evaluator(evaluator), logger(logger) {} + + Item *loadTopLevelProjectItem(); + void checkOverriddenValues(); + void collectNameFromOverride(const QString &overrideString); + Item *loadItemFromFile(const QString &filePath, const CodeLocation &referencingLocation); + Item *wrapInProjectIfNecessary(Item *item); + void handleTopLevelProject(Result &loadResult, const Set<QString> &referencedFilePaths); + void handleProject(Result *loadResult, TopLevelProjectContext *topLevelProjectContext, + Item *projectItem, const Set<QString> &referencedFilePaths); + void prepareProduct(ProjectContext &projectContext, Item *productItem); + void handleNextProduct(TopLevelProjectContext &tlp); + void handleProduct(ProductContext &productContext, Deferral deferral); + bool resolveDependencies(ProductContext &product, Deferral deferral); + void setSearchPathsForProduct(ProductContext &product); + void handleSubProject(ProjectContext &projectContext, Item *projectItem, + const Set<QString> &referencedFilePaths); + void initProductProperties(const ProductContext &product); + void printProfilingInfo(); + void checkProjectNamesInOverrides(const TopLevelProjectContext &tlp); + void checkProductNamesInOverrides(); + void collectProductsByName(const TopLevelProjectContext &topLevelProject); + void adjustDependsItemForMultiplexing(const ProductContext &product, Item *dependsItem); + ShadowProductInfo getShadowProductInfo(const ProductContext &product) const; + void handleProductError(const ErrorInfo &error, ProductContext &productContext); + void handleModuleSetupError(ProductContext &product, const Item::Module &module, + const ErrorInfo &error); + bool checkItemCondition(Item *item); + QStringList readExtraSearchPaths(Item *item, bool *wasSet = nullptr); + QList<Item *> multiplexProductItem(ProductContext &dummyContext, Item *productItem); + void checkCancelation() const; + QList<Item *> loadReferencedFile(const QString &relativePath, + const CodeLocation &referencingLocation, + const Set<QString> &referencedFilePaths, + ProductContext &dummyContext); + void copyProperties(const Item *sourceProject, Item *targetProject); + bool mergeExportItems(ProductContext &productContext); + bool checkExportItemCondition(Item *exportItem, const ProductContext &product); + void resolveProbes(ProductContext &product, Item *item); + + Item *loadBaseModule(ProductContext &product, Item *item); + + struct LoadModuleResult { + Item *moduleItem = nullptr; + ProductContext *product = nullptr; + HandleDependency handleDependency = HandleDependency::Use; + }; + LoadModuleResult loadModule(ProductContext &product, Item *loadingItem, + const ProductContext::ResolvedAndMultiplexedDependsItem &dependency, + Deferral deferral); + Item *searchAndLoadModuleFile(ProductContext *productContext, + const CodeLocation &dependsItemLocation, + const QualifiedId &moduleName, + FallbackMode fallbackMode, bool isRequired); + + std::optional<ProductContext::ResolvedDependsItem> + resolveDependsItem(const ProductContext &product, Item *dependsItem); + std::queue<ProductContext::ResolvedAndMultiplexedDependsItem> + multiplexDependency(const ProductContext &product, + const ProductContext::ResolvedDependsItem &dependency); + static bool haveSameSubProject(const ProductContext &p1, const ProductContext &p2); + QVariantMap extractParameters(Item *dependsItem) const; + + const SetupProjectParameters ¶meters; + ItemPool &itemPool; + Evaluator &evaluator; + Logger &logger; + ProgressObserver *progressObserver = nullptr; + TimingData timingData; + ItemReader reader{logger}; + ProbesResolver probesResolver{parameters, evaluator, logger}; + ModuleProviderLoader moduleProviderLoader{&reader, &evaluator, &probesResolver, logger}; + ModuleLoader moduleLoader{parameters, reader, evaluator, logger}; + ModulePropertyMerger propertyMerger{parameters, evaluator, logger}; + ModuleInstantiator moduleInstantiator{parameters, itemPool, propertyMerger, logger}; + ProductItemMultiplexer multiplexer{parameters, evaluator, logger, [this](Item *productItem) { + return moduleInstantiator.retrieveQbsItem(productItem); + }}; + GroupsHandler groupsHandler{parameters, moduleInstantiator, evaluator, logger}; + LocalProfiles localProfiles{parameters, evaluator, logger}; + FileTime lastResolveTime; + QVariantMap storedProfiles; + + Set<Item *> disabledItems; + std::unique_ptr<Settings> settings; + Set<QString> projectNamesUsedInOverrides; + Set<QString> productNamesUsedInOverrides; + Set<QString> disabledProjects; + Set<QString> erroneousProducts; + std::multimap<QString, ProductContext *> productsByName; + + // For fast look-up when resolving Depends.productTypes. + // The contract is that it contains fully handled, error-free, enabled products. + std::multimap<FileTag, ProductContext *> productsByType; + + Version qbsVersion; + Item *tempScopeItem = nullptr; + QHash<std::pair<QString, QualifiedId>, std::optional<QString>> existingModulePathCache; + QMap<QString, QStringList> moduleDirListCache; + +private: + class TempBaseModuleAttacher { + public: + TempBaseModuleAttacher(Private *d, ProductContext &product); + ~TempBaseModuleAttacher() { drop(); } + void drop(); + Item *tempBaseModuleItem() const { return m_tempBaseModule; } + + private: + Item * const m_productItem; + ValuePtr m_origQbsValue; + Item *m_tempBaseModule = nullptr; + }; +}; + +ProjectTreeBuilder::ProjectTreeBuilder(const SetupProjectParameters ¶meters, ItemPool &itemPool, + Evaluator &evaluator, Logger &logger) + : d(new Private(parameters, itemPool, evaluator, logger)) +{ + d->reader.setDeprecationWarningMode(parameters.deprecationWarningMode()); + d->reader.setEnableTiming(parameters.logElapsedTime()); + d->moduleProviderLoader.setProjectParameters(parameters); + d->settings = std::make_unique<Settings>(parameters.settingsDirectory()); +} + +ProjectTreeBuilder::~ProjectTreeBuilder() { delete d; } + +void ProjectTreeBuilder::setProgressObserver(ProgressObserver *progressObserver) +{ + d->progressObserver = progressObserver; +} + +void ProjectTreeBuilder::setSearchPaths(const QStringList &searchPaths) +{ + d->reader.setSearchPaths(searchPaths); + qCDebug(lcModuleLoader) << "initial search paths:" << searchPaths; +} + +void ProjectTreeBuilder::setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes) +{ + d->probesResolver.setOldProjectProbes(oldProbes); +} + +void ProjectTreeBuilder::setOldProductProbes( + const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes) +{ + d->probesResolver.setOldProductProbes(oldProbes); +} + +void ProjectTreeBuilder::setLastResolveTime(const FileTime &time) { d->lastResolveTime = time; } + +void ProjectTreeBuilder::setStoredProfiles(const QVariantMap &profiles) +{ + d->storedProfiles = profiles; +} + +void ProjectTreeBuilder::setStoredModuleProviderInfo( + const StoredModuleProviderInfo &moduleProviderInfo) +{ + d->moduleProviderLoader.setStoredModuleProviderInfo(moduleProviderInfo); +} + +ProjectTreeBuilder::Result ProjectTreeBuilder::load() +{ + TimedActivityLogger mainTimer(d->logger, Tr::tr("ProjectTreeBuilder"), + d->parameters.logElapsedTime()); + qCDebug(lcModuleLoader) << "load" << d->parameters.projectFilePath(); + + d->checkOverriddenValues(); + d->reader.setPool(&d->itemPool); + + Result result; + result.profileConfigs = d->storedProfiles; + result.root = d->loadTopLevelProjectItem(); + d->handleTopLevelProject(result, {QDir::cleanPath(d->parameters.projectFilePath())}); + + result.qbsFiles = d->reader.filesRead() - d->moduleProviderLoader.tempQbsFiles(); + for (auto it = d->localProfiles.profiles().begin(); it != d->localProfiles.profiles().end(); + ++it) { + result.profileConfigs.remove(it.key()); + } + + d->printProfilingInfo(); + + return result; +} + +Item *ProjectTreeBuilder::Private::loadTopLevelProjectItem() +{ + const QStringList topLevelSearchPaths + = parameters.finalBuildConfigurationTree() + .value(StringConstants::projectPrefix()).toMap() + .value(StringConstants::qbsSearchPathsProperty()).toStringList(); + SearchPathsManager searchPathsManager(reader, topLevelSearchPaths); + Item * const root = loadItemFromFile(parameters.projectFilePath(), CodeLocation()); + if (!root) + return {}; + + switch (root->type()) { + case ItemType::Product: + return wrapInProjectIfNecessary(root); + case ItemType::Project: + return root; + default: + throw ErrorInfo(Tr::tr("The top-level item must be of type 'Project' or 'Product', but it" + " is of type '%1'.").arg(root->typeName()), root->location()); + } +} + +void ProjectTreeBuilder::Private::checkOverriddenValues() +{ + static const auto matchesPrefix = [](const QString &key) { + static const QStringList prefixes({StringConstants::projectPrefix(), + QStringLiteral("projects"), + QStringLiteral("products"), QStringLiteral("modules"), + StringConstants::moduleProviders(), + StringConstants::qbsModule()}); + for (const auto &prefix : prefixes) { + if (key.startsWith(prefix + QLatin1Char('.'))) + return true; + } + return false; + }; + const QVariantMap &overriddenValues = parameters.overriddenValues(); + for (auto it = overriddenValues.begin(); it != overriddenValues.end(); ++it) { + if (matchesPrefix(it.key())) { + collectNameFromOverride(it.key()); + continue; + } + + ErrorInfo e(Tr::tr("Property override key '%1' not understood.").arg(it.key())); + e.append(Tr::tr("Please use one of the following:")); + e.append(QLatin1Char('\t') + Tr::tr("projects.<project-name>.<property-name>:value")); + e.append(QLatin1Char('\t') + Tr::tr("products.<product-name>.<property-name>:value")); + e.append(QLatin1Char('\t') + Tr::tr("modules.<module-name>.<property-name>:value")); + e.append(QLatin1Char('\t') + Tr::tr("products.<product-name>.<module-name>." + "<property-name>:value")); + e.append(QLatin1Char('\t') + Tr::tr("moduleProviders.<provider-name>." + "<property-name>:value")); + handlePropertyError(e, parameters, logger); + } +} + +void ProjectTreeBuilder::Private::collectNameFromOverride(const QString &overrideString) +{ + static const auto extract = [](const QString &prefix, const QString &overrideString) { + if (!overrideString.startsWith(prefix)) + return QString(); + const int startPos = prefix.length(); + const int endPos = overrideString.lastIndexOf(StringConstants::dot()); + if (endPos == -1) + return QString(); + return overrideString.mid(startPos, endPos - startPos); + }; + const QString &projectName = extract(StringConstants::projectsOverridePrefix(), overrideString); + if (!projectName.isEmpty()) { + projectNamesUsedInOverrides.insert(projectName); + return; + } + const QString &productName = extract(StringConstants::productsOverridePrefix(), overrideString); + if (!productName.isEmpty()) { + productNamesUsedInOverrides.insert(productName.left( + productName.indexOf(StringConstants::dot()))); + return; + } +} + +Item *ProjectTreeBuilder::Private::loadItemFromFile(const QString &filePath, + const CodeLocation &referencingLocation) +{ + return reader.setupItemFromFile(filePath, referencingLocation, evaluator); +} + +Item *ProjectTreeBuilder::Private::wrapInProjectIfNecessary(Item *item) +{ + if (item->type() == ItemType::Project) + return item; + Item *prj = Item::create(item->pool(), ItemType::Project); + Item::addChild(prj, item); + prj->setFile(item->file()); + prj->setLocation(item->location()); + prj->setupForBuiltinType(parameters.deprecationWarningMode(), logger); + return prj; +} + +void ProjectTreeBuilder::Private::handleTopLevelProject(Result &loadResult, + const Set<QString> &referencedFilePaths) +{ + TopLevelProjectContext tlp; + tlp.buildDirectory = TopLevelProject::deriveBuildDirectory( + parameters.buildRoot(), + TopLevelProject::deriveId(parameters.finalBuildConfigurationTree())); + Item * const projectItem = loadResult.root; + projectItem->setProperty(StringConstants::sourceDirectoryProperty(), + VariantValue::create(QFileInfo(projectItem->file()->filePath()) + .absolutePath())); + projectItem->setProperty(StringConstants::buildDirectoryProperty(), + VariantValue::create(tlp.buildDirectory)); + projectItem->setProperty(StringConstants::profileProperty(), + VariantValue::create(parameters.topLevelProfile())); + handleProject(&loadResult, &tlp, projectItem, referencedFilePaths); + checkProjectNamesInOverrides(tlp); + collectProductsByName(tlp); + checkProductNamesInOverrides(); + + for (ProjectContext * const projectContext : qAsConst(tlp.projects)) { + for (ProductContext &productContext : projectContext->products) + tlp.productsToHandle.emplace_back(&productContext, -1); + } + while (!tlp.productsToHandle.empty()) + handleNextProduct(tlp); + + loadResult.projectProbes = tlp.probes; + loadResult.storedModuleProviderInfo = moduleProviderLoader.storedModuleProviderInfo(); + + reader.clearExtraSearchPathsStack(); + AccumulatingTimer timer(parameters.logElapsedTime() + ? &timingData.propertyChecking : nullptr); + checkPropertyDeclarations(projectItem, disabledItems, parameters, logger); +} + +void ProjectTreeBuilder::Private::handleProject( + Result *loadResult, TopLevelProjectContext *topLevelProjectContext, Item *projectItem, + const Set<QString> &referencedFilePaths) +{ + auto p = std::make_unique<ProjectContext>(); + auto &projectContext = *p; + projectContext.topLevelProject = topLevelProjectContext; + projectContext.result = loadResult; + ItemValuePtr itemValue = ItemValue::create(projectItem); + projectContext.scope = Item::create(&itemPool, ItemType::Scope); + projectContext.scope->setFile(projectItem->file()); + projectContext.scope->setProperty(StringConstants::projectVar(), itemValue); + ProductContext dummyProductContext; + dummyProductContext.project = &projectContext; + dummyProductContext.moduleProperties = parameters.finalBuildConfigurationTree(); + dummyProductContext.profileModuleProperties = dummyProductContext.moduleProperties; + dummyProductContext.profileName = parameters.topLevelProfile(); + loadBaseModule(dummyProductContext, projectItem); + + projectItem->overrideProperties(parameters.overriddenValuesTree(), + StringConstants::projectPrefix(), parameters, logger); + projectContext.name = evaluator.stringValue(projectItem, StringConstants::nameProperty()); + if (projectContext.name.isEmpty()) { + projectContext.name = FileInfo::baseName(projectItem->location().filePath()); + projectItem->setProperty(StringConstants::nameProperty(), + VariantValue::create(projectContext.name)); + } + projectItem->overrideProperties(parameters.overriddenValuesTree(), + StringConstants::projectsOverridePrefix() + projectContext.name, + parameters, logger); + if (!checkItemCondition(projectItem)) { + disabledProjects.insert(projectContext.name); + return; + } + topLevelProjectContext->projects.push_back(p.release()); + SearchPathsManager searchPathsManager(reader, readExtraSearchPaths(projectItem) + << projectItem->file()->dirPath()); + projectContext.searchPathsStack = reader.extraSearchPathsStack(); + projectContext.item = projectItem; + + const QString minVersionStr + = evaluator.stringValue(projectItem, StringConstants::minimumQbsVersionProperty(), + QStringLiteral("1.3.0")); + const Version minVersion = Version::fromString(minVersionStr); + if (!minVersion.isValid()) { + throw ErrorInfo(Tr::tr("The value '%1' of Project.minimumQbsVersion " + "is not a valid version string.") + .arg(minVersionStr), projectItem->location()); + } + if (!qbsVersion.isValid()) + qbsVersion = Version::fromString(QLatin1String(QBS_VERSION)); + if (qbsVersion < minVersion) { + throw ErrorInfo(Tr::tr("The project requires at least qbs version %1, but " + "this is qbs version %2.").arg(minVersion.toString(), + qbsVersion.toString())); + } + + for (Item * const child : projectItem->children()) + child->setScope(projectContext.scope); + + resolveProbes(dummyProductContext, projectItem); + projectContext.topLevelProject->probes << dummyProductContext.info.probes; + + localProfiles.collectProfilesFromItems(projectItem, projectContext.scope); + + QList<Item *> multiplexedProducts; + for (Item * const child : projectItem->children()) { + if (child->type() == ItemType::Product) + multiplexedProducts << multiplexProductItem(dummyProductContext, child); + } + for (Item * const additionalProductItem : qAsConst(multiplexedProducts)) + Item::addChild(projectItem, additionalProductItem); + + const QList<Item *> originalChildren = projectItem->children(); + for (Item * const child : originalChildren) { + switch (child->type()) { + case ItemType::Product: + prepareProduct(projectContext, child); + break; + case ItemType::SubProject: + handleSubProject(projectContext, child, referencedFilePaths); + break; + case ItemType::Project: + copyProperties(projectItem, child); + handleProject(loadResult, topLevelProjectContext, child, referencedFilePaths); + break; + default: + break; + } + } + + const QStringList refs = evaluator.stringListValue( + projectItem, StringConstants::referencesProperty()); + const CodeLocation referencingLocation + = projectItem->property(StringConstants::referencesProperty())->location(); + QList<Item *> additionalProjectChildren; + for (const QString &filePath : refs) { + try { + additionalProjectChildren << loadReferencedFile( + filePath, referencingLocation, referencedFilePaths, dummyProductContext); + } catch (const ErrorInfo &error) { + if (parameters.productErrorMode() == ErrorHandlingMode::Strict) + throw; + logger.printWarning(error); + } + } + for (Item * const subItem : qAsConst(additionalProjectChildren)) { + Item::addChild(projectContext.item, subItem); + switch (subItem->type()) { + case ItemType::Product: + prepareProduct(projectContext, subItem); + break; + case ItemType::Project: + copyProperties(projectItem, subItem); + handleProject(loadResult, topLevelProjectContext, subItem, + Set<QString>(referencedFilePaths) << subItem->file()->filePath()); + break; + default: + break; + } + } + +} + +void ProjectTreeBuilder::Private::prepareProduct(ProjectContext &projectContext, Item *productItem) +{ + AccumulatingTimer timer(parameters.logElapsedTime() + ? &timingData.prepareProducts : nullptr); + checkCancelation(); + qCDebug(lcModuleLoader) << "prepareProduct" << productItem->file()->filePath(); + + ProductContext productContext; + productContext.item = productItem; + productContext.project = &projectContext; + + // Retrieve name, profile and multiplex id. + productContext.name = evaluator.stringValue(productItem, StringConstants::nameProperty()); + QBS_CHECK(!productContext.name.isEmpty()); + const ItemValueConstPtr qbsItemValue = productItem->itemProperty(StringConstants::qbsModule()); + if (qbsItemValue && qbsItemValue->item()->hasProperty(StringConstants::profileProperty())) { + TempBaseModuleAttacher tbma(this, productContext); + productContext.profileName = evaluator.stringValue( + tbma.tempBaseModuleItem(), StringConstants::profileProperty(), QString()); + } else { + productContext.profileName = parameters.topLevelProfile(); + } + productContext.multiplexConfigurationId = evaluator.stringValue( + productItem, StringConstants::multiplexConfigurationIdProperty()); + QBS_CHECK(!productContext.profileName.isEmpty()); + + // Set up full module property map based on the profile. + const auto it = projectContext.result->profileConfigs.constFind(productContext.profileName); + QVariantMap flatConfig; + if (it == projectContext.result->profileConfigs.constEnd()) { + const Profile profile(productContext.profileName, settings.get(), localProfiles.profiles()); + if (!profile.exists()) { + ErrorInfo error(Tr::tr("Profile '%1' does not exist.").arg(profile.name()), + productItem->location()); + handleProductError(error, productContext); + return; + } + flatConfig = SetupProjectParameters::expandedBuildConfiguration( + profile, parameters.configurationName()); + projectContext.result->profileConfigs.insert(productContext.profileName, flatConfig); + } else { + flatConfig = it.value().toMap(); + } + productContext.profileModuleProperties = SetupProjectParameters::finalBuildConfigurationTree( + flatConfig, {}); + productContext.moduleProperties = SetupProjectParameters::finalBuildConfigurationTree( + flatConfig, parameters.overriddenValues()); + initProductProperties(productContext); + + // Set up product scope. This is mainly for using the "product" and "project" + // variables in some contexts. + ItemValuePtr itemValue = ItemValue::create(productItem); + productContext.scope = Item::create(&itemPool, ItemType::Scope); + productContext.scope->setProperty(StringConstants::productVar(), itemValue); + productContext.scope->setFile(productItem->file()); + productContext.scope->setScope(productContext.project->scope); + + const bool hasExportItems = mergeExportItems(productContext); + + setScopeForDescendants(productItem, productContext.scope); + + projectContext.products.push_back(productContext); + + if (!hasExportItems || getShadowProductInfo(productContext).first) + return; + + // This "shadow product" exists only to pull in a dependency on the actual product + // and nothing else, thus providing us with the pure environment that we need to + // evaluate the product's exported properties in isolation in the project resolver. + Item * const importer = Item::create(productItem->pool(), ItemType::Product); + importer->setProperty(QStringLiteral("name"), + VariantValue::create(StringConstants::shadowProductPrefix() + + productContext.name)); + importer->setFile(productItem->file()); + importer->setLocation(productItem->location()); + importer->setScope(projectContext.scope); + importer->setupForBuiltinType(parameters.deprecationWarningMode(), logger); + Item * const dependsItem = Item::create(productItem->pool(), ItemType::Depends); + dependsItem->setProperty(QStringLiteral("name"), VariantValue::create(productContext.name)); + dependsItem->setProperty(QStringLiteral("required"), VariantValue::create(false)); + dependsItem->setFile(importer->file()); + dependsItem->setLocation(importer->location()); + dependsItem->setupForBuiltinType(parameters.deprecationWarningMode(), logger); + Item::addChild(importer, dependsItem); + Item::addChild(productItem, importer); + prepareProduct(projectContext, importer); +} + +void ProjectTreeBuilder::Private::handleNextProduct(TopLevelProjectContext &tlp) +{ + auto [product, queueSizeOnInsert] = tlp.productsToHandle.front(); + tlp.productsToHandle.pop_front(); + + // If the queue of in-progress products has shrunk since the last time we tried handling + // this product, there has been forward progress and we can allow a deferral. + const Deferral deferral = queueSizeOnInsert == -1 + || queueSizeOnInsert > int(tlp.productsToHandle.size()) + ? Deferral::Allowed : Deferral::NotAllowed; + + reader.setExtraSearchPathsStack(product->project->searchPathsStack); + try { + handleProduct(*product, deferral); + if (product->name.startsWith(StringConstants::shadowProductPrefix())) + tlp.probes << product->info.probes; + } catch (const ErrorInfo &err) { + handleProductError(err, *product); + } + + // The search paths stack can change during dependency resolution (due to module providers); + // check that we've rolled back all the changes + QBS_CHECK(reader.extraSearchPathsStack() == product->project->searchPathsStack); + + // If we encountered a dependency to an in-progress product or to a bulk dependency, + // we defer handling this product if it hasn't failed yet and there is still forward progress. + if (!product->info.delayedError.hasError() && !product->resolveDependenciesState.empty()) + tlp.productsToHandle.emplace_back(product, int(tlp.productsToHandle.size())); +} + +void ProjectTreeBuilder::Private::handleProduct(ProductContext &product, Deferral deferral) +{ + checkCancelation(); + + AccumulatingTimer timer(parameters.logElapsedTime() ? &timingData.handleProducts : nullptr); + if (product.info.delayedError.hasError()) + return; + + if (!resolveDependencies(product, deferral)) + return; + + // Run probes for modules and product. + for (const Item::Module &module : product.item->modules()) { + if (!module.item->isPresentModule()) + continue; + if (module.productInfo && disabledItems.contains(module.productInfo->item)) { + createNonPresentModule(itemPool, module.name.toString(), + QLatin1String("module's exporting product is disabled"), + module.item); + continue; + } + try { + resolveProbes(product, module.item); + if (module.versionRange.minimum.isValid() + || module.versionRange.maximum.isValid()) { + if (module.versionRange.maximum.isValid() + && module.versionRange.minimum >= module.versionRange.maximum) { + throw ErrorInfo(Tr::tr("Impossible version constraint [%1,%2) set for module " + "'%3'").arg(module.versionRange.minimum.toString(), + module.versionRange.maximum.toString(), + module.name.toString())); + } + const Version moduleVersion = Version::fromString( + evaluator.stringValue(module.item, + StringConstants::versionProperty())); + if (moduleVersion < module.versionRange.minimum) { + throw ErrorInfo(Tr::tr("Module '%1' has version %2, but it needs to be " + "at least %3.").arg(module.name.toString(), + moduleVersion.toString(), + module.versionRange.minimum.toString())); + } + if (module.versionRange.maximum.isValid() + && moduleVersion >= module.versionRange.maximum) { + throw ErrorInfo(Tr::tr("Module '%1' has version %2, but it needs to be " + "lower than %3.").arg(module.name.toString(), + moduleVersion.toString(), + module.versionRange.maximum.toString())); + } + } + } catch (const ErrorInfo &error) { + handleModuleSetupError(product, module, error); + if (product.info.delayedError.hasError()) + return; + } + } + resolveProbes(product, product.item); + + // After the probes have run, we can switch on the evaluator cache. + FileTags fileTags = evaluator.fileTagsValue(product.item, StringConstants::typeProperty()); + EvalCacheEnabler cacheEnabler(&evaluator, evaluator.stringValue( + product.item, + StringConstants::sourceDirectoryProperty())); + + // Run module validation scripts. + for (const Item::Module &module : product.item->modules()) { + if (!module.item->isPresentModule()) + continue; + try { + evaluator.boolValue(module.item, StringConstants::validateProperty()); + for (const auto &dep : module.item->modules()) { + if (dep.required && !dep.item->isPresentModule()) { + throw ErrorInfo(Tr::tr("Module '%1' depends on module '%2', which was not " + "loaded successfully") + .arg(module.name.toString(), dep.name.toString())); + } + } + fileTags += evaluator.fileTagsValue( + module.item, StringConstants::additionalProductTypesProperty()); + } catch (const ErrorInfo &error) { + handleModuleSetupError(product, module, error); + if (product.info.delayedError.hasError()) + return; + } + } + + // Disable modules that have been pulled in only by now-disabled modules. + // Note that this has to happen in the reverse order compared to the other loops, + // with the leaves checked last. + for (auto it = product.item->modules().rbegin(); it != product.item->modules().rend(); ++it) { + const Item::Module &module = *it; + if (!module.item->isPresentModule()) + continue; + bool hasPresentLoadingItem = false; + for (const Item * const loadingItem : module.loadingItems) { + if (loadingItem == product.item) { + hasPresentLoadingItem = true; + break; + } + if (!loadingItem->isPresentModule()) + continue; + if (loadingItem->prototype() && loadingItem->prototype()->type() == ItemType::Export) { + QBS_CHECK(loadingItem->prototype()->parent()->type() == ItemType::Product); + if (disabledItems.contains(loadingItem->prototype()->parent())) + continue; + } + hasPresentLoadingItem = true; + break; + } + if (!hasPresentLoadingItem) { + createNonPresentModule(itemPool, module.name.toString(), + QLatin1String("imported only by disabled module(s)"), + module.item); + continue; + } + } + + // Now do the canonical module property values merge. Note that this will remove + // previously attached values from modules that failed validation. + // Evaluator cache entries that could potentially change due to this will be purged. + propertyMerger.doFinalMerge(product.item); + + const bool enabled = checkItemCondition(product.item); + moduleLoader.checkDependencyParameterDeclarations({product.item, product.name, {}, {}}); + + groupsHandler.setupGroups(product.item, product.scope); + product.info.modulePropertiesSetInGroups = groupsHandler.modulePropertiesSetInGroups(); + disabledItems.unite(groupsHandler.disabledGroups()); + + // Collect the full list of fileTags, including the values contributed by modules. + if (!product.info.delayedError.hasError() && enabled) { + for (const FileTag &tag : fileTags) + productsByType.insert({tag, &product}); + product.item->setProperty(StringConstants::typeProperty(), + VariantValue::create(sorted(fileTags.toStringList()))); + } + product.project->result->productInfos[product.item] = product.info; +} + +bool ProjectTreeBuilder::Private::resolveDependencies(ProductContext &product, Deferral deferral) +{ + AccumulatingTimer timer(parameters.logElapsedTime() + ? &timingData.productDependencies : nullptr); + + // Initialize the state with the direct Depends items of the product item. + // This branch is executed once per product, while the function might be entered + // multiple times due to deferrals. + if (product.resolveDependenciesState.empty()) { + setSearchPathsForProduct(product); + std::queue<Item *> topLevelDependsItems; + for (Item * const child : product.item->children()) { + if (child->type() == ItemType::Depends) + topLevelDependsItems.push(child); + } + product.resolveDependenciesState.push_front({product.item, {}, topLevelDependsItems, }); + product.resolveDependenciesState.front().pendingResolvedDependencies.push( + ProductContext::ResolvedAndMultiplexedDependsItem::makeBaseDependency()); + } + + SearchPathsManager searchPathsMgr(reader, product); + + while (!product.resolveDependenciesState.empty()) { +fixme: + auto &state = product.resolveDependenciesState.front(); + while (!state.pendingResolvedDependencies.empty()) { + QBS_CHECK(!state.currentDependsItem); + const auto dependency = state.pendingResolvedDependencies.front(); + try { + const LoadModuleResult res = loadModule(product, state.loadingItem, dependency, + deferral); + switch (res.handleDependency) { + case HandleDependency::Defer: + QBS_CHECK(deferral == Deferral::Allowed); + if (res.product) + state.pendingResolvedDependencies.front().product = res.product; + return false; + case HandleDependency::Ignore: + state.pendingResolvedDependencies.pop(); + continue; + case HandleDependency::Use: + if (dependency.name.toString() == StringConstants::qbsModule()) { + state.pendingResolvedDependencies.pop(); + continue; + } + break; + } + + QBS_CHECK(res.moduleItem); + std::queue<Item *> moduleDependsItems; + for (Item * const child : res.moduleItem->children()) { + if (child->type() == ItemType::Depends) + moduleDependsItems.push(child); + } + + state.pendingResolvedDependencies.pop(); + product.resolveDependenciesState.push_front( + {res.moduleItem, dependency, moduleDependsItems, {}, {}, + dependency.requiredGlobally || state.requiredByLoadingItem}); + product.resolveDependenciesState.front().pendingResolvedDependencies.push( + ProductContext::ResolvedAndMultiplexedDependsItem::makeBaseDependency()); + break; + } catch (const ErrorInfo &e) { + if (dependency.name.toString() == StringConstants::qbsModule()) + throw e; + + if (!dependency.requiredLocally) { + state.pendingResolvedDependencies.pop(); + continue; + } + + // See QBS-1338 for why we do not abort handling the product. + state.pendingResolvedDependencies.pop(); + Item::Modules &modules = product.item->modules(); + while (product.resolveDependenciesState.size() > 1) { + const auto loadingItemModule = std::find_if( + modules.begin(), modules.end(), [&](const Item::Module &m) { + return m.item == product.resolveDependenciesState.front().loadingItem; + }); + for (auto it = loadingItemModule; it != modules.end(); ++it) { + createNonPresentModule(itemPool, it->name.toString(), + QLatin1String("error in Depends chain"), it->item); + } + modules.erase(loadingItemModule, modules.end()); + product.resolveDependenciesState.pop_front(); + } + handleProductError(e, product); + goto fixme; + } + } + if (&state != &product.resolveDependenciesState.front()) + continue; + + if (state.currentDependsItem) { + QBS_CHECK(state.pendingResolvedDependencies.empty()); + + // We postpone handling Depends.productTypes for as long as possible, because + // the full type of a product becomes available only after its modules have been loaded. + if (!state.currentDependsItem->productTypes.empty() && deferral == Deferral::Allowed) + return false; + + state.pendingResolvedDependencies = multiplexDependency(product, + *state.currentDependsItem); + state.currentDependsItem.reset(); + continue; + } + + while (!state.pendingDependsItems.empty()) { + QBS_CHECK(!state.currentDependsItem); + QBS_CHECK(state.pendingResolvedDependencies.empty()); + Item * const dependsItem = state.pendingDependsItems.front(); + state.pendingDependsItems.pop(); + adjustDependsItemForMultiplexing(product, dependsItem); + state.currentDependsItem = resolveDependsItem(product, dependsItem); + if (!state.currentDependsItem) + continue; + state.currentDependsItem->requiredGlobally = state.currentDependsItem->requiredLocally + && state.loadingItemOrigin.requiredGlobally; + goto fixme; + } + + QBS_CHECK(!state.currentDependsItem); + QBS_CHECK(state.pendingResolvedDependencies.empty()); + QBS_CHECK(state.pendingDependsItems.empty()); + + // This ensures a sorted module list in the product (dependers after dependencies). + if (product.resolveDependenciesState.size() > 1) { + QBS_CHECK(state.loadingItem->type() == ItemType::ModuleInstance); + Item::Modules &modules = product.item->modules(); + const auto loadingItemModule = std::find_if(modules.begin(), modules.end(), + [&](const Item::Module &m) { + return m.item == state.loadingItem; + }); + QBS_CHECK(loadingItemModule != modules.end()); + const Item::Module tempModule = *loadingItemModule; + modules.erase(loadingItemModule); + modules.push_back(tempModule); + } + product.resolveDependenciesState.pop_front(); + } + return true; +} + +void ProjectTreeBuilder::Private::setSearchPathsForProduct(ProductContext &product) +{ + QBS_CHECK(product.searchPaths.isEmpty()); + + product.searchPaths = readExtraSearchPaths(product.item); + Settings settings(parameters.settingsDirectory()); + const QStringList prefsSearchPaths = Preferences(&settings, product.profileModuleProperties) + .searchPaths(); + const QStringList ¤tSearchPaths = reader.allSearchPaths(); + for (const QString &p : prefsSearchPaths) { + if (!currentSearchPaths.contains(p) && FileInfo(p).exists()) + product.searchPaths << p; + } +} + +void ProjectTreeBuilder::Private::handleSubProject( + ProjectContext &projectContext, Item *projectItem, const Set<QString> &referencedFilePaths) +{ + qCDebug(lcModuleLoader) << "handleSubProject" << projectItem->file()->filePath(); + + Item * const propertiesItem = projectItem->child(ItemType::PropertiesInSubProject); + if (!checkItemCondition(projectItem)) + return; + if (propertiesItem) { + propertiesItem->setScope(projectItem); + if (!checkItemCondition(propertiesItem)) + return; + } + + Item *loadedItem = nullptr; + QString subProjectFilePath; + try { + const QString projectFileDirPath = FileInfo::path(projectItem->file()->filePath()); + const QString relativeFilePath + = evaluator.stringValue(projectItem, StringConstants::filePathProperty()); + subProjectFilePath = FileInfo::resolvePath(projectFileDirPath, relativeFilePath); + if (referencedFilePaths.contains(subProjectFilePath)) + throw ErrorInfo(Tr::tr("Cycle detected while loading subproject file '%1'.") + .arg(relativeFilePath), projectItem->location()); + loadedItem = loadItemFromFile(subProjectFilePath, projectItem->location()); + } catch (const ErrorInfo &error) { + if (parameters.productErrorMode() == ErrorHandlingMode::Strict) + throw; + logger.printWarning(error); + return; + } + + loadedItem = wrapInProjectIfNecessary(loadedItem); + const bool inheritProperties = evaluator.boolValue( + projectItem, StringConstants::inheritPropertiesProperty()); + + if (inheritProperties) + copyProperties(projectItem->parent(), loadedItem); + if (propertiesItem) { + const Item::PropertyMap &overriddenProperties = propertiesItem->properties(); + for (auto it = overriddenProperties.begin(); it != overriddenProperties.end(); ++it) + loadedItem->setProperty(it.key(), it.value()); + } + + Item::addChild(projectItem, loadedItem); + projectItem->setScope(projectContext.scope); + handleProject(projectContext.result, projectContext.topLevelProject, loadedItem, + Set<QString>(referencedFilePaths) << subProjectFilePath); +} + +void ProjectTreeBuilder::Private::initProductProperties(const ProductContext &product) +{ + QString buildDir = ResolvedProduct::deriveBuildDirectoryName(product.name, + product.multiplexConfigurationId); + buildDir = FileInfo::resolvePath(product.project->topLevelProject->buildDirectory, buildDir); + product.item->setProperty(StringConstants::buildDirectoryProperty(), + VariantValue::create(buildDir)); + const QString sourceDir = QFileInfo(product.item->file()->filePath()).absolutePath(); + product.item->setProperty(StringConstants::sourceDirectoryProperty(), + VariantValue::create(sourceDir)); +} + +void ProjectTreeBuilder::Private::printProfilingInfo() +{ + if (!parameters.logElapsedTime()) + return; + logger.qbsLog(LoggerInfo, true) << " " + << Tr::tr("Project file loading and parsing took %1.") + .arg(elapsedTimeString(reader.elapsedTime())); + logger.qbsLog(LoggerInfo, true) << " " + << Tr::tr("Preparing products took %1.") + .arg(elapsedTimeString(timingData.prepareProducts)); + logger.qbsLog(LoggerInfo, true) << " " + << Tr::tr("Handling products took %1.") + .arg(elapsedTimeString(timingData.handleProducts)); + logger.qbsLog(LoggerInfo, true) << " " + << Tr::tr("Setting up product dependencies took %1.") + .arg(elapsedTimeString(timingData.productDependencies)); + logger.qbsLog(LoggerInfo, true) << " " + << Tr::tr("Running module providers took %1.") + .arg(elapsedTimeString(timingData.moduleProviders)); + moduleInstantiator.printProfilingInfo(6); + propertyMerger.printProfilingInfo(6); + groupsHandler.printProfilingInfo(4); + probesResolver.printProfilingInfo(4); + logger.qbsLog(LoggerInfo, true) << " " + << Tr::tr("Property checking took %1.") + .arg(elapsedTimeString(timingData.propertyChecking)); +} + +void ProjectTreeBuilder::Private::checkProjectNamesInOverrides(const TopLevelProjectContext &tlp) +{ + for (const QString &projectNameInOverride : projectNamesUsedInOverrides) { + if (disabledProjects.contains(projectNameInOverride)) + continue; + if (!any_of(tlp.projects, [&projectNameInOverride](const ProjectContext *p) { + return p->name == projectNameInOverride; })) { + handlePropertyError(Tr::tr("Unknown project '%1' in property override.") + .arg(projectNameInOverride), parameters, logger); + } + } +} + +void ProjectTreeBuilder::Private::checkProductNamesInOverrides() +{ + for (const QString &productNameInOverride : productNamesUsedInOverrides) { + if (erroneousProducts.contains(productNameInOverride)) + continue; + if (!any_of(productsByName, [&productNameInOverride]( + const std::pair<QString, ProductContext *> &elem) { + // In an override string such as "a.b.c:d, we cannot tell whether we have a product + // "a" and a module "b.c" or a product "a.b" and a module "c", so we need to take + // care not to emit false positives here. + return elem.first == productNameInOverride + || elem.first.startsWith(productNameInOverride + StringConstants::dot()); + })) { + handlePropertyError(Tr::tr("Unknown product '%1' in property override.") + .arg(productNameInOverride), parameters, logger); + } + } +} + +void ProjectTreeBuilder::Private::collectProductsByName( + const TopLevelProjectContext &topLevelProject) +{ + for (ProjectContext * const project : topLevelProject.projects) { + for (ProductContext &product : project->products) + productsByName.insert({product.name, &product}); + } +} + +void ProjectTreeBuilder::Private::adjustDependsItemForMultiplexing(const ProductContext &product, + Item *dependsItem) +{ + const QString name = evaluator.stringValue(dependsItem, StringConstants::nameProperty()); + const bool productIsMultiplexed = !product.multiplexConfigurationId.isEmpty(); + if (name == product.name) { + QBS_CHECK(!productIsMultiplexed); // This product must be an aggregator. + return; + } + const auto productRange = productsByName.equal_range(name); + if (productRange.first == productRange.second) + return; // Dependency is a module. Nothing to adjust. + + bool profilesPropertyIsSet; + const QStringList profiles = evaluator.stringListValue( + dependsItem, StringConstants::profilesProperty(), &profilesPropertyIsSet); + + std::vector<const ProductContext *> multiplexedDependencies; + bool hasNonMultiplexedDependency = false; + for (auto it = productRange.first; it != productRange.second; ++it) { + if (!it->second->multiplexConfigurationId.isEmpty()) + multiplexedDependencies.push_back(it->second); + else + hasNonMultiplexedDependency = true; + } + bool hasMultiplexedDependencies = !multiplexedDependencies.empty(); + + static const auto multiplexConfigurationIntersects = [](const QVariantMap &lhs, + const QVariantMap &rhs) { + QBS_CHECK(!lhs.isEmpty() && !rhs.isEmpty()); + for (auto lhsProperty = lhs.constBegin(); lhsProperty != lhs.constEnd(); lhsProperty++) { + const auto rhsProperty = rhs.find(lhsProperty.key()); + const bool isCommonProperty = rhsProperty != rhs.constEnd(); + if (isCommonProperty && lhsProperty.value() != rhsProperty.value()) + return false; + } + return true; + }; + + // These are the allowed cases: + // (1) Normal dependency with no multiplexing whatsoever. + // (2) Both product and dependency are multiplexed. + // (2a) The profiles property is not set, we want to depend on the best + // matching variant. + // (2b) The profiles property is set, we want to depend on all variants + // with a matching profile. + // (3) The product is not multiplexed, but the dependency is. + // (3a) The profiles property is not set, the dependency has an aggregator. + // We want to depend on the aggregator. + // (3b) The profiles property is not set, the dependency does not have an + // aggregator. We want to depend on all the multiplexed variants. + // (3c) The profiles property is set, we want to depend on all variants + // with a matching profile regardless of whether an aggregator exists or not. + // (4) The product is multiplexed, but the dependency is not. We don't have to adapt + // any Depends items. + // (5) The product is a "shadow product". In that case, we know which product + // it should have a dependency on, and we make sure we depend on that. + + // (1) and (4) + if (!hasMultiplexedDependencies) + return; + + // (3a) + if (!productIsMultiplexed && hasNonMultiplexedDependency && !profilesPropertyIsSet) + return; + + QStringList multiplexIds; + const ShadowProductInfo shadowProductInfo = getShadowProductInfo(product); + const bool isShadowProduct = shadowProductInfo.first && shadowProductInfo.second == name; + const auto productMultiplexConfig + = multiplexer.multiplexIdToVariantMap(product.multiplexConfigurationId); + + for (const ProductContext *dependency : multiplexedDependencies) { + const bool depMatchesShadowProduct = isShadowProduct + && dependency->item == product.item->parent(); + const QString depMultiplexId = dependency->multiplexConfigurationId; + if (depMatchesShadowProduct) { // (5) + dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), + VariantValue::create(depMultiplexId)); + return; + } + if (productIsMultiplexed && !profilesPropertyIsSet) { // 2a + if (dependency->multiplexConfigurationId == product.multiplexConfigurationId) { + const ValuePtr &multiplexId = product.item->property( + StringConstants::multiplexConfigurationIdProperty()); + dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), + multiplexId); + return; + + } + // Otherwise collect partial matches and decide later + const auto dependencyMultiplexConfig + = multiplexer.multiplexIdToVariantMap(dependency->multiplexConfigurationId); + + if (multiplexConfigurationIntersects(dependencyMultiplexConfig, productMultiplexConfig)) + multiplexIds << dependency->multiplexConfigurationId; + } else { + // (2b), (3b) or (3c) + const bool profileMatch = !profilesPropertyIsSet || profiles.empty() + || profiles.contains(dependency->profileName); + if (profileMatch) + multiplexIds << depMultiplexId; + } + } + if (multiplexIds.empty()) { + const QString productName = ProductItemMultiplexer::fullProductDisplayName( + product.name, product.multiplexConfigurationId); + throw ErrorInfo(Tr::tr("Dependency from product '%1' to product '%2' not fulfilled. " + "There are no eligible multiplex candidates.").arg(productName, + name), + dependsItem->location()); + } + + // In case of (2a), at most 1 match is allowed + if (productIsMultiplexed && !profilesPropertyIsSet && multiplexIds.size() > 1) { + const QString productName = ProductItemMultiplexer::fullProductDisplayName( + product.name, product.multiplexConfigurationId); + QStringList candidateNames; + for (const auto &id : qAsConst(multiplexIds)) + candidateNames << ProductItemMultiplexer::fullProductDisplayName(name, id); + throw ErrorInfo(Tr::tr("Dependency from product '%1' to product '%2' is ambiguous. " + "Eligible multiplex candidates: %3.").arg( + productName, name, candidateNames.join(QLatin1String(", "))), + dependsItem->location()); + } + + dependsItem->setProperty(StringConstants::multiplexConfigurationIdsProperty(), + VariantValue::create(multiplexIds)); +} + +ShadowProductInfo ProjectTreeBuilder::Private::getShadowProductInfo( + const ProductContext &product) const +{ + const bool isShadowProduct = product.name.startsWith(StringConstants::shadowProductPrefix()); + return std::make_pair(isShadowProduct, isShadowProduct + ? product.name.mid(StringConstants::shadowProductPrefix().size()) + : QString()); +} + +void ProjectTreeBuilder::Private::handleProductError(const ErrorInfo &error, + ProductContext &productContext) +{ + const bool alreadyHadError = productContext.info.delayedError.hasError(); + if (!alreadyHadError) { + productContext.info.delayedError.append(Tr::tr("Error while handling product '%1':") + .arg(productContext.name), + productContext.item->location()); + } + if (error.isInternalError()) { + if (alreadyHadError) { + qCDebug(lcModuleLoader()) << "ignoring subsequent internal error" << error.toString() + << "in product" << productContext.name; + return; + } + } + const auto errorItems = error.items(); + for (const ErrorItem &ei : errorItems) + productContext.info.delayedError.append(ei.description(), ei.codeLocation()); + productContext.project->result->productInfos[productContext.item] = productContext.info; + disabledItems << productContext.item; + erroneousProducts.insert(productContext.name); +} + +void ProjectTreeBuilder::Private::handleModuleSetupError( + ProductContext &product, const Item::Module &module, const ErrorInfo &error) +{ + if (module.required) { + handleProductError(error, product); + } else { + qCDebug(lcModuleLoader()) << "non-required module" << module.name.toString() + << "found, but not usable in product" << product.name + << error.toString(); + createNonPresentModule(itemPool, module.name.toString(), + QStringLiteral("failed validation"), module.item); + } +} + +bool ProjectTreeBuilder::Private::checkItemCondition(Item *item) +{ + if (evaluator.boolValue(item, StringConstants::conditionProperty())) + return true; + disabledItems += item; + return false; +} + +QStringList ProjectTreeBuilder::Private::readExtraSearchPaths(Item *item, bool *wasSet) +{ + QStringList result; + const QStringList paths = evaluator.stringListValue( + item, StringConstants::qbsSearchPathsProperty(), wasSet); + const JSSourceValueConstPtr prop = item->sourceProperty( + StringConstants::qbsSearchPathsProperty()); + + // Value can come from within a project file or as an overridden value from the user + // (e.g command line). + const QString basePath = FileInfo::path(prop ? prop->file()->filePath() + : parameters.projectFilePath()); + for (const QString &path : paths) + result += FileInfo::resolvePath(basePath, path); + return result; +} + +QList<Item *> ProjectTreeBuilder::Private::multiplexProductItem(ProductContext &dummyContext, + Item *productItem) +{ + // Overriding the product item properties must be done here already, because multiplexing + // properties might depend on product properties. + const QString &nameKey = StringConstants::nameProperty(); + QString productName = evaluator.stringValue(productItem, nameKey); + if (productName.isEmpty()) { + productName = FileInfo::completeBaseName(productItem->file()->filePath()); + productItem->setProperty(nameKey, VariantValue::create(productName)); + } + productItem->overrideProperties(parameters.overriddenValuesTree(), + StringConstants::productsOverridePrefix() + productName, + parameters, logger); + dummyContext.item = productItem; + TempBaseModuleAttacher tbma(this, dummyContext); + return multiplexer.multiplex(productName, productItem, tbma.tempBaseModuleItem(), + [&] { tbma.drop(); }); +} + +void ProjectTreeBuilder::Private::checkCancelation() const +{ + if (progressObserver && progressObserver->canceled()) { + throw ErrorInfo(Tr::tr("Project resolving canceled for configuration %1.") + .arg(TopLevelProject::deriveId( + parameters.finalBuildConfigurationTree()))); + } +} + +QList<Item *> ProjectTreeBuilder::Private::loadReferencedFile( + const QString &relativePath, const CodeLocation &referencingLocation, + const Set<QString> &referencedFilePaths, ProductContext &dummyContext) +{ + QString absReferencePath = FileInfo::resolvePath(FileInfo::path(referencingLocation.filePath()), + relativePath); + if (FileInfo(absReferencePath).isDir()) { + QString qbsFilePath; + + QDirIterator dit(absReferencePath, StringConstants::qbsFileWildcards()); + while (dit.hasNext()) { + if (!qbsFilePath.isEmpty()) { + throw ErrorInfo(Tr::tr("Referenced directory '%1' contains more than one " + "qbs file.").arg(absReferencePath), referencingLocation); + } + qbsFilePath = dit.next(); + } + if (qbsFilePath.isEmpty()) { + throw ErrorInfo(Tr::tr("Referenced directory '%1' does not contain a qbs file.") + .arg(absReferencePath), referencingLocation); + } + absReferencePath = qbsFilePath; + } + if (referencedFilePaths.contains(absReferencePath)) + throw ErrorInfo(Tr::tr("Cycle detected while referencing file '%1'.").arg(relativePath), + referencingLocation); + Item * const subItem = loadItemFromFile(absReferencePath, referencingLocation); + if (subItem->type() != ItemType::Project && subItem->type() != ItemType::Product) { + ErrorInfo error(Tr::tr("Item type should be 'Product' or 'Project', but is '%1'.") + .arg(subItem->typeName())); + error.append(Tr::tr("Item is defined here."), subItem->location()); + error.append(Tr::tr("File is referenced here."), referencingLocation); + throw error; + } + subItem->setScope(dummyContext.project->scope); + subItem->setParent(dummyContext.project->item); + QList<Item *> loadedItems; + loadedItems << subItem; + if (subItem->type() == ItemType::Product) { + localProfiles.collectProfilesFromItems(subItem, dummyContext.project->scope); + loadedItems << multiplexProductItem(dummyContext, subItem); + } + return loadedItems; +} + +void ProjectTreeBuilder::Private::copyProperties(const Item *sourceProject, Item *targetProject) +{ + if (!sourceProject) + return; + const QList<PropertyDeclaration> builtinProjectProperties + = BuiltinDeclarations::instance().declarationsForType(ItemType::Project).properties(); + Set<QString> builtinProjectPropertyNames; + for (const PropertyDeclaration &p : builtinProjectProperties) + builtinProjectPropertyNames << p.name(); + + for (auto it = sourceProject->propertyDeclarations().begin(); + it != sourceProject->propertyDeclarations().end(); ++it) { + + // We must not inherit built-in properties such as "name", + // but there are exceptions. + if (it.key() == StringConstants::qbsSearchPathsProperty() + || it.key() == StringConstants::profileProperty() + || it.key() == StringConstants::buildDirectoryProperty() + || it.key() == StringConstants::sourceDirectoryProperty() + || it.key() == StringConstants::minimumQbsVersionProperty()) { + const JSSourceValueConstPtr &v = targetProject->sourceProperty(it.key()); + QBS_ASSERT(v, continue); + if (v->sourceCode() == StringConstants::undefinedValue()) + sourceProject->copyProperty(it.key(), targetProject); + continue; + } + + if (builtinProjectPropertyNames.contains(it.key())) + continue; + + if (targetProject->hasOwnProperty(it.key())) + continue; // Ignore stuff the target project already has. + + targetProject->setPropertyDeclaration(it.key(), it.value()); + sourceProject->copyProperty(it.key(), targetProject); + } +} + +static void mergeParameters(QVariantMap &dst, const QVariantMap &src) +{ + for (auto it = src.begin(); it != src.end(); ++it) { + if (it.value().userType() == QMetaType::QVariantMap) { + QVariant &vdst = dst[it.key()]; + QVariantMap mdst = vdst.toMap(); + mergeParameters(mdst, it.value().toMap()); + vdst = mdst; + } else { + dst[it.key()] = it.value(); + } + } +} + +static void adjustParametersScopes(Item *item, Item *scope) +{ + if (item->type() == ItemType::ModuleParameters) { + item->setScope(scope); + return; + } + + for (const auto &value : item->properties()) { + if (value->type() == Value::ItemValueType) + adjustParametersScopes(std::static_pointer_cast<ItemValue>(value)->item(), scope); + } +} + +static void mergeProperty(Item *dst, const QString &name, const ValuePtr &value) +{ + if (value->type() == Value::ItemValueType) { + const ItemValueConstPtr itemValue = std::static_pointer_cast<ItemValue>(value); + const Item * const valueItem = itemValue->item(); + Item * const subItem = dst->itemProperty(name, itemValue)->item(); + for (auto it = valueItem->properties().begin(); it != valueItem->properties().end(); ++it) + mergeProperty(subItem, it.key(), it.value()); + return; + } + + // If the property already exists, set up the base value. + if (value->type() == Value::JSSourceValueType) { + const auto jsValue = static_cast<JSSourceValue *>(value.get()); + if (jsValue->isBuiltinDefaultValue()) + return; + const ValuePtr baseValue = dst->property(name); + if (baseValue) { + QBS_CHECK(baseValue->type() == Value::JSSourceValueType); + const JSSourceValuePtr jsBaseValue = std::static_pointer_cast<JSSourceValue>( + baseValue->clone()); + jsValue->setBaseValue(jsBaseValue); + std::vector<JSSourceValue::Alternative> alternatives = jsValue->alternatives(); + jsValue->clearAlternatives(); + for (JSSourceValue::Alternative &a : alternatives) { + a.value->setBaseValue(jsBaseValue); + jsValue->addAlternative(a); + } + } + } + dst->setProperty(name, value); +} + +bool ProjectTreeBuilder::Private::mergeExportItems(ProductContext &productContext) +{ + std::vector<Item *> exportItems; + QList<Item *> children = productContext.item->children(); + + const auto isExport = [](Item *item) { return item->type() == ItemType::Export; }; + std::copy_if(children.cbegin(), children.cend(), std::back_inserter(exportItems), isExport); + qbs::Internal::removeIf(children, isExport); + + // Note that we do not return if there are no Export items: The "merged" item becomes the + // "product module", which always needs to exist, regardless of whether the product sources + // actually contain an Export item or not. + if (!exportItems.empty()) + productContext.item->setChildren(children); + + Item *merged = Item::create(productContext.item->pool(), ItemType::Export); + const QString &nameKey = StringConstants::nameProperty(); + const ValuePtr nameValue = VariantValue::create(productContext.name); + merged->setProperty(nameKey, nameValue); + Set<FileContextConstPtr> filesWithExportItem; + QVariantMap defaultParameters; + for (Item * const exportItem : qAsConst(exportItems)) { + checkCancelation(); + if (Q_UNLIKELY(filesWithExportItem.contains(exportItem->file()))) + throw ErrorInfo(Tr::tr("Multiple Export items in one product are prohibited."), + exportItem->location()); + exportItem->setProperty(nameKey, nameValue); + if (!checkExportItemCondition(exportItem, productContext)) + continue; + filesWithExportItem += exportItem->file(); + for (Item * const child : exportItem->children()) { + if (child->type() == ItemType::Parameters) { + adjustParametersScopes(child, child); + mergeParameters(defaultParameters, + getJsVariant(evaluator.engine()->context(), + evaluator.scriptValue(child)).toMap()); + } else { + Item::addChild(merged, child); + } + } + const Item::PropertyDeclarationMap &decls = exportItem->propertyDeclarations(); + for (auto it = decls.constBegin(); it != decls.constEnd(); ++it) { + const PropertyDeclaration &newDecl = it.value(); + const PropertyDeclaration &existingDecl = merged->propertyDeclaration(it.key()); + if (existingDecl.isValid() && existingDecl.type() != newDecl.type()) { + ErrorInfo error(Tr::tr("Export item in inherited item redeclares property " + "'%1' with different type.").arg(it.key()), exportItem->location()); + handlePropertyError(error, parameters, logger); + } + merged->setPropertyDeclaration(newDecl.name(), newDecl); + } + for (QMap<QString, ValuePtr>::const_iterator it = exportItem->properties().constBegin(); + it != exportItem->properties().constEnd(); ++it) { + mergeProperty(merged, it.key(), it.value()); + } + } + merged->setFile(exportItems.empty() + ? productContext.item->file() : exportItems.back()->file()); + merged->setLocation(exportItems.empty() + ? productContext.item->location() : exportItems.back()->location()); + Item::addChild(productContext.item, merged); + merged->setupForBuiltinType(parameters.deprecationWarningMode(), logger); + + productContext.mergedExportItem = merged; + productContext.defaultParameters = defaultParameters; + return !exportItems.empty(); +} + +// TODO: This seems dubious. Can we merge the conditions instead? +bool ProjectTreeBuilder::Private::checkExportItemCondition(Item *exportItem, + const ProductContext &product) +{ + class ScopeHandler { + public: + ScopeHandler(Item *exportItem, const ProductContext &productContext, Item **cachedScopeItem) + : m_exportItem(exportItem) + { + if (!*cachedScopeItem) + *cachedScopeItem = Item::create(exportItem->pool(), ItemType::Scope); + Item * const scope = *cachedScopeItem; + QBS_CHECK(productContext.item->file()); + scope->setFile(productContext.item->file()); + scope->setScope(productContext.item); + productContext.project->scope->copyProperty(StringConstants::projectVar(), scope); + productContext.scope->copyProperty(StringConstants::productVar(), scope); + QBS_CHECK(!exportItem->scope()); + exportItem->setScope(scope); + } + ~ScopeHandler() { m_exportItem->setScope(nullptr); } + + private: + Item * const m_exportItem; + } scopeHandler(exportItem, product, &tempScopeItem); + return checkItemCondition(exportItem); +} + +void ProjectTreeBuilder::Private::resolveProbes(ProductContext &product, Item *item) +{ + product.info.probes << probesResolver.resolveProbes({product.name, product.uniqueName()}, item); +} + +static void checkForModuleNamePrefixCollision( + const Item *product, const ProductContext::ResolvedAndMultiplexedDependsItem &dependency) +{ + if (!product) + return; + + for (const Item::Module &m : product->modules()) { + if (m.name.length() == dependency.name.length() + || m.name.front() != dependency.name.front()) { + continue; + } + QualifiedId shortName; + QualifiedId longName; + if (m.name < dependency.name) { + shortName = m.name; + longName = dependency.name; + } else { + shortName = dependency.name; + longName = m.name; + } + throw ErrorInfo(Tr::tr("The name of module '%1' is equal to the first component of the " + "name of module '%2', which is not allowed") + .arg(shortName.toString(), longName.toString()), dependency.location()); + } +} + +// Note: This function is never called for regular loading of the base module into a product, +// but only for the special cases of loading the dummy base module into a project +// and temporarily providing a base module for product multiplexing. +Item *ProjectTreeBuilder::Private::loadBaseModule(ProductContext &product, Item *item) +{ + const QualifiedId baseModuleName(StringConstants::qbsModule()); + const auto baseDependency + = ProductContext::ResolvedAndMultiplexedDependsItem::makeBaseDependency(); + Item * const moduleItem = loadModule(product, item, baseDependency, Deferral::NotAllowed) + .moduleItem; + if (Q_UNLIKELY(!moduleItem)) + throw ErrorInfo(Tr::tr("Cannot load base qbs module.")); + return moduleItem; +} + +ProjectTreeBuilder::Private::LoadModuleResult +ProjectTreeBuilder::Private::loadModule(ProductContext &product, Item *loadingItem, + const ProductContext::ResolvedAndMultiplexedDependsItem &dependency, + Deferral deferral) +{ + qCDebug(lcModuleLoader) << "loadModule name:" << dependency.name.toString() + << "id:" << dependency.id(); + + QBS_CHECK(loadingItem); + + const auto findExistingModule = [&dependency](Item *item) -> std::pair<Item::Module *, Item *> { + if (!item) // Happens if and only if called via loadBaseModule(). + return {}; + Item *moduleWithSameName = nullptr; + for (Item::Module &m : item->modules()) { + if (m.name != dependency.name) + continue; + if (!m.productInfo) { + QBS_CHECK(!dependency.product); + return {&m, m.item}; + } + if ((dependency.profile.isEmpty() || (m.productInfo->profile == dependency.profile)) + && m.productInfo->multiplexId == dependency.multiplexId) { + return {&m, m.item}; + } + moduleWithSameName = m.item; + } + return {nullptr, moduleWithSameName}; + }; + ProductContext *productDep = nullptr; + Item *moduleItem = nullptr; + static const auto displayName = [](const ProductContext &p) { + return ProductItemMultiplexer::fullProductDisplayName(p.name, p.multiplexConfigurationId); + }; + const auto &[existingModule, moduleWithSameName] = findExistingModule(product.item); + if (existingModule) { + // Merge version range and required property. These will be checked again + // after probes resolving. + if (existingModule->name.toString() != StringConstants::qbsModule()) { + moduleLoader.forwardParameterDeclarations(dependency.item, product.item->modules()); + + // TODO: Use priorities like for property values. See QBS-1300. + mergeParameters(existingModule->parameters, dependency.parameters); + + existingModule->versionRange.narrowDown(dependency.versionRange); + existingModule->required |= dependency.requiredGlobally; + if (int(product.resolveDependenciesState.size()) + > existingModule->maxDependsChainLength) { + existingModule->maxDependsChainLength = product.resolveDependenciesState.size(); + } + } + QBS_CHECK(existingModule->item); + moduleItem = existingModule->item; + if (!contains(existingModule->loadingItems, loadingItem)) + existingModule->loadingItems.push_back(loadingItem); + } else if (dependency.product) { + // We have already done the look-up. + productDep = dependency.product; + } else { + // First check if there's a matching product. + const auto candidates = productsByName.equal_range(dependency.name.toString()); + for (auto it = candidates.first; it != candidates.second; ++it) { + const auto candidate = it->second; + if (candidate->multiplexConfigurationId != dependency.multiplexId) + continue; + if (!dependency.profile.isEmpty() && dependency.profile != candidate->profileName) + continue; + if (dependency.limitToSubProject && !haveSameSubProject(product, *candidate)) + continue; + productDep = candidate; + break; + } + if (!productDep) { + // If we can tell that this is supposed to be a product dependency, we can skip + // the module look-up. + if (!dependency.profile.isEmpty() || !dependency.multiplexId.isEmpty()) { + if (dependency.requiredGlobally) { + if (!dependency.profile.isEmpty()) { + throw ErrorInfo(Tr::tr("Product '%1' depends on '%2', which does not exist " + "for the requested profile '%3'.") + .arg(displayName(product), dependency.displayName(), + dependency.profile), + product.item->location()); + } + throw ErrorInfo(Tr::tr("Product '%1' depends on '%2', which does not exist.") + .arg(displayName(product), dependency.displayName()), + product.item->location()); + } + } else { + // No matching product found, look for a "real" module. + moduleItem = searchAndLoadModuleFile(&product, dependency.location(), + dependency.name, dependency.fallbackMode, + dependency.requiredGlobally); + + if (moduleItem) { + Item * const proto = moduleItem; + moduleItem = moduleItem->clone(); + moduleItem->setPrototype(proto); // For parameter declarations. + } else if (dependency.requiredGlobally) { + throw ErrorInfo(Tr::tr("Dependency '%1' not found for product '%2'.") + .arg(dependency.name.toString(), displayName(product)), + dependency.location()); + } + } + } + } + + if (productDep && dependency.checkProduct) { + if (productDep == &product) { + throw ErrorInfo(Tr::tr("Dependency '%1' refers to itself.") + .arg(dependency.name.toString()), + dependency.location()); + } + + if (any_of(product.project->topLevelProject->productsToHandle, [productDep](const auto &e) { + return e.first == productDep; + })) { + if (deferral == Deferral::Allowed) + return {nullptr, productDep, HandleDependency::Defer}; + ErrorInfo e; + e.append(Tr::tr("Cyclic dependencies detected:")); + e.append(Tr::tr("First product is '%1'.") + .arg(displayName(product)), product.item->location()); + e.append(Tr::tr("Second product is '%1'.") + .arg(displayName(*productDep)), productDep->item->location()); + e.append(Tr::tr("Requested here."), dependency.location()); + throw e; + } + + // This covers both the case of user-disabled products and products with errors. + // The latter are force-disabled in handleProductError(). + if (disabledItems.contains(productDep->item)) { + if (dependency.requiredGlobally) { + ErrorInfo e; + e.append(Tr::tr("Product '%1' depends on '%2',") + .arg(displayName(product), displayName(*productDep)), + product.item->location()); + e.append(Tr::tr("but product '%1' is disabled.").arg(displayName(*productDep)), + productDep->item->location()); + throw e; + } + productDep = nullptr; + } + } + + if (productDep) { + QBS_CHECK(productDep->mergedExportItem); + moduleItem = productDep->mergedExportItem->clone(); + moduleItem->setParent(nullptr); + + // Needed for isolated Export item evaluation. + moduleItem->setPrototype(productDep->mergedExportItem); + } + + if (moduleItem) { + for (auto it = product.resolveDependenciesState.begin(); + it != product.resolveDependenciesState.end(); ++it) { + Item *itemToCheck = moduleItem; + if (it->loadingItem != itemToCheck) { + if (!productDep) + continue; + itemToCheck = productDep->item; + } + if (it->loadingItem != itemToCheck) + continue; + ErrorInfo e; + e.append(Tr::tr("Cyclic dependencies detected:")); + while (true) { + e.append(it->loadingItemOrigin.name.toString(), + it->loadingItemOrigin.location()); + if (it->loadingItem->type() == ItemType::ModuleInstance) { + createNonPresentModule(itemPool, it->loadingItemOrigin.name.toString(), + QLatin1String("cyclic dependency"), it->loadingItem); + } + if (it == product.resolveDependenciesState.begin()) + break; + --it; + } + e.append(dependency.name.toString(), dependency.location()); + throw e; + } + checkForModuleNamePrefixCollision(product.item, dependency); + } + + // Can only happen with multiplexing. + if (moduleWithSameName && moduleWithSameName != moduleItem) + QBS_CHECK(productDep); + + QString loadingName; + if (loadingItem == product.item) { + loadingName = product.name; + } else if (product.resolveDependenciesState.size() > 0) { + const auto &loadingItemOrigin = product.resolveDependenciesState.front().loadingItemOrigin; + loadingName = loadingItemOrigin.name.toString() + loadingItemOrigin.multiplexId + + loadingItemOrigin.profile; + } + moduleInstantiator.instantiate({ + product.item, product.name, loadingItem, loadingName, moduleItem, moduleWithSameName, + productDep ? productDep->item : nullptr, product.scope, product.project->scope, + dependency.name, dependency.id(), bool(existingModule)}); + + // At this point, a null module item is only possible for a non-required dependency. + // Note that we still needed to to the instantiation above, as that injects the module + // name into the surrounding item for the ".present" check. + if (!moduleItem) { + QBS_CHECK(!dependency.requiredGlobally); + return {nullptr, nullptr, HandleDependency::Ignore}; + } + + const auto createModule = [&] { + Item::Module m; + m.item = moduleItem; + if (productDep) { + m.productInfo.emplace(productDep->item, productDep->multiplexConfigurationId, + productDep->profileName); + } + m.name = dependency.name; + m.required = dependency.requiredLocally; + m.versionRange = dependency.versionRange; + return m; + }; + const auto addLocalModule = [&] { + if (loadingItem->type() == ItemType::ModuleInstance + && !findExistingModule(loadingItem).first) { + loadingItem->addModule(createModule()); + } + }; + + // The module has already been loaded, so we don't need to add it to the product's list of + // modules, nor do we need to handle its dependencies. The only thing we might need to + // do is to add it to the "local" list of modules of the loading item, if it isn't in there yet. + if (existingModule) { + addLocalModule(); + return {nullptr, nullptr, HandleDependency::Ignore}; + } + + qCDebug(lcModuleLoader) << "module loaded:" << dependency.name.toString(); + if (product.item) { + Item::Module module = createModule(); + + if (module.name.toString() != StringConstants::qbsModule()) { + // TODO: Why do we have default parameters only for Export items and + // property declarations only for modules? Does that make any sense? + if (productDep) + module.parameters = productDep->defaultParameters; + mergeParameters(module.parameters, dependency.parameters); + } + module.required = dependency.requiredGlobally; + module.loadingItems.push_back(loadingItem); + module.maxDependsChainLength = product.resolveDependenciesState.size(); + product.item->addModule(module); + addLocalModule(); + } + return {moduleItem, nullptr, HandleDependency::Use}; +} + +bool ProjectTreeBuilder::Private::haveSameSubProject(const ProductContext &p1, + const ProductContext &p2) +{ + for (const Item *otherParent = p2.item->parent(); otherParent; + otherParent = otherParent->parent()) { + if (otherParent == p1.item->parent()) + return true; + } + return false; +} + +static Item::PropertyMap filterItemProperties(const Item::PropertyMap &properties) +{ + Item::PropertyMap result; + for (auto it = properties.begin(); it != properties.end(); ++it) { + if (it.value()->type() == Value::ItemValueType) + result.insert(it.key(), it.value()); + } + return result; +} + +static QVariantMap safeToVariant(JSContext *ctx, const JSValue &v) +{ + QVariantMap result; + handleJsProperties(ctx, v, [&](const JSAtom &prop, const JSPropertyDescriptor &desc) { + const JSValue u = desc.value; + if (JS_IsError(ctx, u)) + throw ErrorInfo(getJsString(ctx, u)); + const QString name = getJsString(ctx, prop); + result[name] = (JS_IsObject(u) && !JS_IsArray(ctx, u) && !JS_IsRegExp(ctx, u)) + ? safeToVariant(ctx, u) : getJsVariant(ctx, u); + }); + return result; +} + +QVariantMap ProjectTreeBuilder::Private::extractParameters(Item *dependsItem) const +{ + QVariantMap result; + const Item::PropertyMap &itemProperties = filterItemProperties(dependsItem->properties()); + if (itemProperties.empty()) + return result; + auto origProperties = dependsItem->properties(); + + // TODO: This is not exception-safe. Also, can't we do the item value check along the + // way, without allocationg an extra map and exchanging the list of children? + dependsItem->setProperties(itemProperties); + + JSValue sv = evaluator.scriptValue(dependsItem); + try { + result = safeToVariant(evaluator.engine()->context(), sv); + } catch (const ErrorInfo &exception) { + auto ei = exception; + ei.prepend(Tr::tr("Error in dependency parameter."), dependsItem->location()); + throw ei; + } + dependsItem->setProperties(origProperties); + return result; +} + +// TODO Move the search & load stuff into ModuleLoader once we untangled the data types +struct PrioritizedItem +{ + PrioritizedItem(Item *item, int priority, int searchPathIndex) + : item(item), priority(priority), searchPathIndex(searchPathIndex) { } + + Item * const item; + int priority = 0; + const int searchPathIndex; +}; + +static Item *chooseModuleCandidate(const std::vector<PrioritizedItem> &candidates, + const QString &moduleName) +{ + // TODO: This should also consider the version requirement. + + auto maxIt = std::max_element( + candidates.begin(), candidates.end(), + [] (const PrioritizedItem &a, const PrioritizedItem &b) { + if (a.priority < b.priority) + return true; + if (a.priority > b.priority) + return false; + return a.searchPathIndex > b.searchPathIndex; + }); + + size_t nmax = std::count_if( + candidates.begin(), candidates.end(), + [maxIt] (const PrioritizedItem &i) { + return i.priority == maxIt->priority && i.searchPathIndex == maxIt->searchPathIndex; + }); + + if (nmax > 1) { + ErrorInfo e(Tr::tr("There is more than one equally prioritized candidate for module '%1'.") + .arg(moduleName)); + for (size_t i = 0; i < candidates.size(); ++i) { + const auto candidate = candidates.at(i); + if (candidate.priority == maxIt->priority) { + //: The %1 denotes the number of the candidate. + e.append(Tr::tr("candidate %1").arg(i + 1), candidates.at(i).item->location()); + } + } + throw e; + } + + return maxIt->item; +} + +Item *ProjectTreeBuilder::Private::searchAndLoadModuleFile( + ProductContext *productContext, const CodeLocation &dependsItemLocation, + const QualifiedId &moduleName, FallbackMode fallbackMode, bool isRequired) +{ + const auto findExistingModulePath = [&](const QString &searchPath) { + // isFileCaseCorrect is a very expensive call on macOS, so we cache the value for the + // modules and search paths we've already processed + auto &moduleInfo = existingModulePathCache[{searchPath, moduleName}]; + if (moduleInfo) + return *moduleInfo; + + QString dirPath = searchPath + QStringLiteral("/modules"); + for (const QString &moduleNamePart : moduleName) { + dirPath = FileInfo::resolvePath(dirPath, moduleNamePart); + if (!FileInfo::exists(dirPath) || !FileInfo::isFileCaseCorrect(dirPath)) { + return *(moduleInfo = QString()); + } + } + + return *(moduleInfo = dirPath); + }; + const auto findExistingModulePaths = [&] { + const QStringList &searchPaths = reader.allSearchPaths(); + QStringList result; + result.reserve(searchPaths.size()); + for (const auto &path: searchPaths) { + const QString dirPath = findExistingModulePath(path); + if (!dirPath.isEmpty()) + result.append(dirPath); + } + return result; + }; + + auto existingPaths = findExistingModulePaths(); + if (existingPaths.isEmpty()) { // no suitable names found, try to use providers + AccumulatingTimer providersTimer( + parameters.logElapsedTime() ? &timingData.moduleProviders : nullptr); + auto result = moduleProviderLoader.executeModuleProviders( + *productContext, + dependsItemLocation, + moduleName, + fallbackMode); + if (result.providerAddedSearchPaths) { + qCDebug(lcModuleLoader) << "Re-checking for module" << moduleName.toString() + << "with newly added search paths from module provider"; + existingPaths = findExistingModulePaths(); + } + } + + const auto getModuleFileNames = [&](const QString &dirPath) -> QStringList & { + QStringList &moduleFileNames = moduleDirListCache[dirPath]; + if (moduleFileNames.empty()) { + QDirIterator dirIter(dirPath, StringConstants::qbsFileWildcards()); + while (dirIter.hasNext()) + moduleFileNames += dirIter.next(); + } + return moduleFileNames; + }; + + const QString fullName = moduleName.toString(); + bool triedToLoadModule = false; + std::vector<PrioritizedItem> candidates; + candidates.reserve(size_t(existingPaths.size())); + for (int i = 0; i < existingPaths.size(); ++i) { + const QString &dirPath = existingPaths.at(i); + QStringList &moduleFileNames = getModuleFileNames(dirPath); + for (auto it = moduleFileNames.begin(); it != moduleFileNames.end(); ) { + const QString &filePath = *it; + const auto [module, triedToLoad] = moduleLoader.loadModuleFile( + {productContext->item, productContext->name, productContext->profileName, + productContext->profileModuleProperties}, + fullName, filePath); + if (module) + candidates.emplace_back(module, 0, i); + if (!triedToLoad) + it = moduleFileNames.erase(it); + else + ++it; + triedToLoadModule = triedToLoadModule || triedToLoad; + } + } + + if (candidates.empty()) { + if (!isRequired) + return createNonPresentModule(itemPool, fullName, QStringLiteral("not found"), nullptr); + if (Q_UNLIKELY(triedToLoadModule)) { + throw ErrorInfo(Tr::tr("Module %1 could not be loaded.").arg(fullName), + dependsItemLocation); + } + return nullptr; + } + + Item *moduleItem; + if (candidates.size() == 1) { + moduleItem = candidates.at(0).item; + } else { + for (auto &candidate : candidates) { + candidate.priority = evaluator.intValue(candidate.item, + StringConstants::priorityProperty(), + candidate.priority); + } + moduleItem = chooseModuleCandidate(candidates, fullName); + } + + const QString fullProductName = ProductItemMultiplexer::fullProductDisplayName( + productContext->name, productContext->multiplexConfigurationId); + moduleLoader.checkProfileErrorsForModule(moduleItem, fullName, fullProductName, + productContext->profileName); + return moduleItem; +} + +std::optional<ProductContext::ResolvedDependsItem> +ProjectTreeBuilder::Private::resolveDependsItem(const ProductContext &product, Item *dependsItem) +{ + if (!checkItemCondition(dependsItem)) { + qCDebug(lcModuleLoader) << "Depends item disabled, ignoring."; + return {}; + } + + const QString name = evaluator.stringValue(dependsItem, StringConstants::nameProperty()); + if (name == StringConstants::qbsModule()) // Redundant + return {}; + + bool submodulesPropertySet; + const QStringList submodules = evaluator.stringListValue( + dependsItem, StringConstants::submodulesProperty(), &submodulesPropertySet); + if (submodules.empty() && submodulesPropertySet) { + qCDebug(lcModuleLoader) << "Ignoring Depends item with empty submodules list."; + return {}; + } + if (Q_UNLIKELY(submodules.size() > 1 && !dependsItem->id().isEmpty())) { + QString msg = Tr::tr("A Depends item with more than one module cannot have an id."); + throw ErrorInfo(msg, dependsItem->location()); + } + bool productTypesWasSet; + const QStringList productTypes = evaluator.stringListValue( + dependsItem, StringConstants::productTypesProperty(), &productTypesWasSet); + if (!name.isEmpty() && !productTypes.isEmpty()) { + throw ErrorInfo(Tr::tr("The name and productTypes are mutually exclusive " + "in a Depends item"), dependsItem->location()); + } + if (productTypes.isEmpty() && productTypesWasSet) { + qCDebug(lcModuleLoader) << "Ignoring Depends item with empty productTypes list."; + return {}; + } + if (name.isEmpty() && !productTypesWasSet) { + throw ErrorInfo(Tr::tr("Either name or productTypes must be set in a Depends item"), + dependsItem->location()); + } + + const FallbackMode fallbackMode = parameters.fallbackProviderEnabled() + && evaluator.boolValue(dependsItem, StringConstants::enableFallbackProperty()) + ? FallbackMode::Enabled : FallbackMode::Disabled; + + bool profilesPropertyWasSet = false; + std::optional<QStringList> profiles; + bool required = true; + if (productTypes.isEmpty()) { + const QStringList profileList = evaluator.stringListValue( + dependsItem, StringConstants::profilesProperty(), &profilesPropertyWasSet); + if (profilesPropertyWasSet) + profiles.emplace(profileList); + required = evaluator.boolValue(dependsItem, StringConstants::requiredProperty()); + } + const Version minVersion = Version::fromString( + evaluator.stringValue(dependsItem, StringConstants::versionAtLeastProperty())); + const Version maxVersion = Version::fromString( + evaluator.stringValue(dependsItem, StringConstants::versionBelowProperty())); + const bool limitToSubProject = evaluator.boolValue( + dependsItem, StringConstants::limitToSubProjectProperty()); + const QStringList multiplexIds = evaluator.stringListValue( + dependsItem, StringConstants::multiplexConfigurationIdsProperty()); + adjustParametersScopes(dependsItem, dependsItem); + moduleLoader.forwardParameterDeclarations(dependsItem, product.item->modules()); + const QVariantMap parameters = extractParameters(dependsItem); + + return ProductContext::ResolvedDependsItem{dependsItem, QualifiedId::fromString(name), + submodules, FileTags::fromStringList(productTypes), multiplexIds, profiles, + {minVersion, maxVersion}, parameters, limitToSubProject, fallbackMode, required}; +} + +// Potentially multiplexes a dependency along Depends.productTypes, Depends.subModules and +// Depends.profiles, as well as internally set up multiplexing axes. +// Each entry in the resulting queue corresponds to exactly one product or module to pull in. +std::queue<ProductContext::ResolvedAndMultiplexedDependsItem> +ProjectTreeBuilder::Private::multiplexDependency( + const ProductContext &product, const ProductContext::ResolvedDependsItem &dependency) +{ + std::queue<ProductContext::ResolvedAndMultiplexedDependsItem> dependencies; + if (!dependency.productTypes.empty()) { + std::vector<ProductContext *> matchingProducts; + for (const FileTag &typeTag : dependency.productTypes) { + const auto range = productsByType.equal_range(typeTag); + for (auto it = range.first; it != range.second; ++it) { + if (it->second != &product + && it->second->name != product.name + && (!dependency.limitToSubProject + || haveSameSubProject(product, *it->second))) { + matchingProducts.push_back(it->second); + } + } + } + if (matchingProducts.empty()) { + qCDebug(lcModuleLoader) << "Depends.productTypes does not match anything." + << dependency.item->location(); + return {}; + } + for (ProductContext * const match : matchingProducts) + dependencies.emplace(match, dependency); + return dependencies; + } + + const QStringList profiles = dependency.profiles && !dependency.profiles->isEmpty() + ? *dependency.profiles : QStringList(QString()); + const QStringList multiplexIds = !dependency.multiplexIds.isEmpty() + ? dependency.multiplexIds : QStringList(QString()); + const QStringList subModules = !dependency.subModules.isEmpty() + ? dependency.subModules : QStringList(QString()); + for (const QString &profile : profiles) { + for (const QString &multiplexId : multiplexIds) { + for (const QString &subModule : subModules) { + QualifiedId name = dependency.name; + if (!subModule.isEmpty()) + name << subModule.split(QLatin1Char('.')); + dependencies.emplace(dependency, name, profile, multiplexId); + } + } + } + return dependencies; +} + +SearchPathsManager::SearchPathsManager(ItemReader &itemReader, const QStringList &extraSearchPaths) + : SearchPathsManager(itemReader, nullptr, extraSearchPaths) {} + +SearchPathsManager::SearchPathsManager(ItemReader &itemReader, ProductContext &product) + : SearchPathsManager(itemReader, &product, product.searchPaths) {} + +SearchPathsManager::SearchPathsManager(ItemReader &itemReader, ProductContext *product, + const QStringList &extraSearchPaths) + : m_itemReader(itemReader), m_product(product), + m_oldSize(itemReader.extraSearchPathsStack().size()) +{ + if (!extraSearchPaths.isEmpty()) + m_itemReader.pushExtraSearchPaths(extraSearchPaths); +} + +SearchPathsManager::~SearchPathsManager() +{ + while (m_itemReader.extraSearchPathsStack().size() > m_oldSize) { + if (m_product && m_itemReader.extraSearchPathsStack().size() > m_oldSize + 1) { + for (const QString &pathFromProvider : m_itemReader.extraSearchPathsStack().back()) + m_product->searchPaths.prepend(pathFromProvider); + } + m_itemReader.popExtraSearchPaths(); + } +} + +QString ProductContext::uniqueName() const +{ + return ResolvedProduct::uniqueName(name, multiplexConfigurationId); +} + +QString ProductContext::ResolvedAndMultiplexedDependsItem::id() const +{ + if (!item) { + QBS_CHECK(name.toString() == StringConstants::qbsModule()); + return {}; + } + return item->id(); +} + +CodeLocation ProductContext::ResolvedAndMultiplexedDependsItem::location() const +{ + if (!item) { + QBS_CHECK(name.toString() == StringConstants::qbsModule()); + return {}; + } + return item->location(); +} + +QString ProductContext::ResolvedAndMultiplexedDependsItem::displayName() const +{ + return ProductItemMultiplexer::fullProductDisplayName(name.toString(), multiplexId); +} + +ProjectTreeBuilder::Private::TempBaseModuleAttacher::TempBaseModuleAttacher( + ProjectTreeBuilder::Private *d, ProductContext &product) + : m_productItem(product.item) +{ + const ValuePtr qbsValue = m_productItem->property(StringConstants::qbsModule()); + + // Cloning is necessary because the original value will get "instantiated" now. + if (qbsValue) + m_origQbsValue = qbsValue->clone(); + + m_tempBaseModule = d->loadBaseModule(product, m_productItem); +} + +void ProjectTreeBuilder::Private::TempBaseModuleAttacher::drop() +{ + if (!m_tempBaseModule) + return; + + // "Unload" the qbs module again. + if (m_origQbsValue) + m_productItem->setProperty(StringConstants::qbsModule(), m_origQbsValue); + else + m_productItem->removeProperty(StringConstants::qbsModule()); + m_productItem->removeModules(); + m_tempBaseModule = nullptr; +} + +} // namespace qbs::Internal diff --git a/src/lib/corelib/language/projecttreebuilder.h b/src/lib/corelib/language/projecttreebuilder.h new file mode 100644 index 000000000..db2d621c5 --- /dev/null +++ b/src/lib/corelib/language/projecttreebuilder.h @@ -0,0 +1,227 @@ +/**************************************************************************** +** +** Copyright (C) 2023 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qbs. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#pragma once + +#include "forward_decls.h" +#include "filetags.h" +#include "moduleproviderinfo.h" +#include "qualifiedid.h" + +#include <tools/filetime.h> +#include <tools/stringconstants.h> +#include <tools/version.h> + +#include <QString> +#include <QVariant> + +#include <optional> +#include <queue> +#include <stack> + +namespace qbs { +class SetupProjectParameters; +namespace Internal { +class Evaluator; +class FileTime; +class Item; +class ItemPool; +class ProgressObserver; + +class ContextBase +{ +public: + Item *item = nullptr; + Item *scope = nullptr; + QString name; +}; + +class ProjectContext; + +enum class FallbackMode { Enabled, Disabled }; + +using ModulePropertiesPerGroup = std::unordered_map<const Item *, QualifiedIdSet>; + +// TODO: This class only needs to be known inside the ProjectResolver; no need to +// instantiate them separately when they always appear together. +// Possibly we can get rid of the Loader class altogether. +class ProjectTreeBuilder +{ +public: + ProjectTreeBuilder(const SetupProjectParameters ¶meters, ItemPool &itemPool, + Evaluator &evaluator, Logger &logger); + ~ProjectTreeBuilder(); + + struct Result + { + struct ProductInfo + { + std::vector<ProbeConstPtr> probes; + ModulePropertiesPerGroup modulePropertiesSetInGroups; + ErrorInfo delayedError; + }; + + Item *root = nullptr; + std::unordered_map<Item *, ProductInfo> productInfos; + std::vector<ProbeConstPtr> projectProbes; + StoredModuleProviderInfo storedModuleProviderInfo; + Set<QString> qbsFiles; + QVariantMap profileConfigs; + }; + Result load(); + + void setProgressObserver(ProgressObserver *progressObserver); + void setSearchPaths(const QStringList &searchPaths); + void setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes); + void setOldProductProbes(const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes); + void setLastResolveTime(const FileTime &time); + void setStoredProfiles(const QVariantMap &profiles); + void setStoredModuleProviderInfo(const StoredModuleProviderInfo &moduleProviderInfo); + +private: + class Private; + Private * const d; +}; + +class ProductContext : public ContextBase +{ +public: + ProjectContext *project = nullptr; + Item *mergedExportItem = nullptr; + ProjectTreeBuilder::Result::ProductInfo info; + QString profileName; + QString multiplexConfigurationId; + QVariantMap profileModuleProperties; // Tree-ified module properties from profile. + QVariantMap moduleProperties; // Tree-ified module properties from profile + overridden values. + QVariantMap defaultParameters; // In Export item. + QStringList searchPaths; + + std::optional<QVariantMap> theModuleProviderConfig; + + struct ResolvedDependsItem { + Item *item = nullptr; + QualifiedId name; + QStringList subModules; + FileTags productTypes; + QStringList multiplexIds; + std::optional<QStringList> profiles; + VersionRange versionRange; + QVariantMap parameters; + bool limitToSubProject = false; + FallbackMode fallbackMode = FallbackMode::Enabled; + bool requiredLocally = true; + bool requiredGlobally = true; + }; + struct ResolvedAndMultiplexedDependsItem { + ResolvedAndMultiplexedDependsItem(ProductContext *product, + const ResolvedDependsItem &dependency) + : product(product), item(dependency.item), name(product->name), + versionRange(dependency.versionRange), parameters(dependency.parameters), + fallbackMode(FallbackMode::Disabled), checkProduct(false) {} + ResolvedAndMultiplexedDependsItem(const ResolvedDependsItem &dependency, + const QualifiedId &name, + const QString &profile, const QString &multiplexId) + : item(dependency.item), name(name), profile(profile), multiplexId(multiplexId), + versionRange(dependency.versionRange), parameters(dependency.parameters), + limitToSubProject(dependency.limitToSubProject), fallbackMode(dependency.fallbackMode), + requiredLocally(dependency.requiredLocally), + requiredGlobally(dependency.requiredGlobally) {} + ResolvedAndMultiplexedDependsItem() = default; + static ResolvedAndMultiplexedDependsItem makeBaseDependency() { + ResolvedAndMultiplexedDependsItem item; + item.fallbackMode = FallbackMode::Disabled; + item.name = StringConstants::qbsModule(); + return item; + } + + QString id() const; + CodeLocation location() const; + QString displayName() const; + + ProductContext *product = nullptr; + Item *item = nullptr; + QualifiedId name; + QString profile; + QString multiplexId; + VersionRange versionRange; + QVariantMap parameters; + bool limitToSubProject = false; + FallbackMode fallbackMode = FallbackMode::Enabled; + bool requiredLocally = true; + bool requiredGlobally = true; + bool checkProduct = true; + }; + struct DependenciesResolvingState { + Item *loadingItem = nullptr; + ResolvedAndMultiplexedDependsItem loadingItemOrigin; + std::queue<Item *> pendingDependsItems; + std::optional<ResolvedDependsItem> currentDependsItem; + std::queue<ResolvedAndMultiplexedDependsItem> pendingResolvedDependencies; + bool requiredByLoadingItem = true; + }; + std::list<DependenciesResolvingState> resolveDependenciesState; + + QString uniqueName() const; +}; + +class TopLevelProjectContext +{ +public: + TopLevelProjectContext() = default; + TopLevelProjectContext(const TopLevelProjectContext &) = delete; + TopLevelProjectContext &operator=(const TopLevelProjectContext &) = delete; + ~TopLevelProjectContext() { qDeleteAll(projects); } + + std::vector<ProjectContext *> projects; + std::list<std::pair<ProductContext *, int>> productsToHandle; + std::vector<ProbeConstPtr> probes; + QString buildDirectory; +}; + +class ProjectContext : public ContextBase +{ +public: + TopLevelProjectContext *topLevelProject = nullptr; + ProjectTreeBuilder::Result *result = nullptr; + std::vector<ProductContext> products; + std::vector<QStringList> searchPathsStack; +}; + +} // namespace Internal +} // namespace qbs diff --git a/src/lib/corelib/language/propertydeclaration.cpp b/src/lib/corelib/language/propertydeclaration.cpp index f2ac019e9..215918462 100644 --- a/src/lib/corelib/language/propertydeclaration.cpp +++ b/src/lib/corelib/language/propertydeclaration.cpp @@ -40,11 +40,15 @@ #include "propertydeclaration.h" #include "deprecationinfo.h" -#include <api/languageinfo.h> +#include "filecontext.h" +#include "item.h" +#include "qualifiedid.h" +#include "value.h" +#include <api/languageinfo.h> #include <logging/translator.h> - #include <tools/error.h> +#include <tools/setupprojectparameters.h> #include <tools/qttools.h> #include <tools/stringconstants.h> @@ -304,5 +308,142 @@ QVariant PropertyDeclaration::convertToPropertyType(const QVariant &v, Type t, return c; } +namespace { +class PropertyDeclarationCheck : public ValueHandler +{ +public: + PropertyDeclarationCheck(const Set<Item *> &disabledItems, + const SetupProjectParameters ¶ms, Logger &logger) + : m_disabledItems(disabledItems) + , m_params(params) + , m_logger(logger) + { } + void operator()(Item *item) { handleItem(item); } + +private: + void handle(JSSourceValue *value) override + { + if (!value->createdByPropertiesBlock()) { + const ErrorInfo error(Tr::tr("Property '%1' is not declared.") + .arg(m_currentName), value->location()); + handlePropertyError(error, m_params, m_logger); + } + } + void handle(ItemValue *value) override + { + if (checkItemValue(value)) + handleItem(value->item()); + } + bool checkItemValue(ItemValue *value) + { + // TODO: Remove once QBS-1030 is fixed. + if (parentItem()->type() == ItemType::Artifact) + return false; + + if (parentItem()->type() == ItemType::Properties) + return false; + + // TODO: Check where the in-between module instances come from. + if (value->item()->type() == ItemType::ModuleInstancePlaceholder) { + for (auto it = m_parentItems.rbegin(); it != m_parentItems.rend(); ++it) { + if ((*it)->type() == ItemType::Group) + return false; + if ((*it)->type() == ItemType::ModulePrefix) + continue; + break; + } + } + + if (value->item()->type() != ItemType::ModuleInstance + && value->item()->type() != ItemType::ModulePrefix + && (!parentItem()->file() || !parentItem()->file()->idScope() + || !parentItem()->file()->idScope()->hasProperty(m_currentName)) + && !value->createdByPropertiesBlock()) { + CodeLocation location = value->location(); + for (int i = int(m_parentItems.size() - 1); !location.isValid() && i >= 0; --i) + location = m_parentItems.at(i)->location(); + const ErrorInfo error(Tr::tr("Item '%1' is not declared. " + "Did you forget to add a Depends item?") + .arg(m_currentModuleName.toString()), location); + handlePropertyError(error, m_params, m_logger); + return false; + } + + return true; + } + void handleItem(Item *item) + { + if (!m_handledItems.insert(item).second) + return; + if (m_disabledItems.contains(item) + || item->type() == ItemType::Module + || item->type() == ItemType::Export + || (item->type() == ItemType::ModuleInstance && !item->isPresentModule()) + || item->type() == ItemType::Properties + + // The Properties child of a SubProject item is not a regular item. + || item->type() == ItemType::PropertiesInSubProject) { + return; + } + + m_parentItems.push_back(item); + for (Item::PropertyMap::const_iterator it = item->properties().constBegin(); + it != item->properties().constEnd(); ++it) { + if (item->type() == ItemType::Product && it.key() == StringConstants::moduleProviders() + && it.value()->type() == Value::ItemValueType) + continue; + const PropertyDeclaration decl = item->propertyDeclaration(it.key()); + if (decl.isValid()) { + const ErrorInfo deprecationError = decl.checkForDeprecation( + m_params.deprecationWarningMode(), it.value()->location(), m_logger); + if (deprecationError.hasError()) + handlePropertyError(deprecationError, m_params, m_logger); + continue; + } + m_currentName = it.key(); + const QualifiedId oldModuleName = m_currentModuleName; + if (parentItem()->type() != ItemType::ModulePrefix) + m_currentModuleName.clear(); + m_currentModuleName.push_back(m_currentName); + it.value()->apply(this); + m_currentModuleName = oldModuleName; + } + m_parentItems.pop_back(); + for (Item * const child : item->children()) { + switch (child->type()) { + case ItemType::Export: + case ItemType::Depends: + case ItemType::Parameter: + case ItemType::Parameters: + break; + case ItemType::Group: + if (item->type() == ItemType::Module || item->type() == ItemType::ModuleInstance) + break; + Q_FALLTHROUGH(); + default: + handleItem(child); + } + } + } + void handle(VariantValue *) override { /* only created internally - no need to check */ } + + Item *parentItem() const { return m_parentItems.back(); } + + const Set<Item *> &m_disabledItems; + Set<Item *> m_handledItems; + std::vector<Item *> m_parentItems; + QualifiedId m_currentModuleName; + QString m_currentName; + const SetupProjectParameters &m_params; + Logger &m_logger; +}; +} // namespace + +void checkPropertyDeclarations(Item *topLevelItem, const Set<Item *> &disabledItems, + const SetupProjectParameters ¶ms, Logger &logger) +{ + PropertyDeclarationCheck(disabledItems, params, logger)(topLevelItem); +} + } // namespace Internal } // namespace qbs diff --git a/src/lib/corelib/language/propertydeclaration.h b/src/lib/corelib/language/propertydeclaration.h index d1e114296..8c87faedb 100644 --- a/src/lib/corelib/language/propertydeclaration.h +++ b/src/lib/corelib/language/propertydeclaration.h @@ -41,6 +41,7 @@ #define QBS_PROPERTYDECLARATION_H #include <tools/deprecationwarningmode.h> +#include <tools/set.h> #include <QtCore/qshareddata.h> #include <QtCore/qstring.h> @@ -52,9 +53,11 @@ QT_END_NAMESPACE namespace qbs { class CodeLocation; class ErrorInfo; +class SetupProjectParameters; namespace Internal { class DeprecationInfo; class PropertyDeclarationData; +class Item; class Logger; class PropertyDeclaration @@ -131,6 +134,10 @@ private: QSharedDataPointer<PropertyDeclarationData> d; }; +void checkPropertyDeclarations(Item *topLevelItem, const Set<Item *> &disabledItems, + const SetupProjectParameters ¶ms, Logger &logger); + + } // namespace Internal } // namespace qbs diff --git a/src/lib/corelib/language/value.cpp b/src/lib/corelib/language/value.cpp index 5a4da2c8f..7ba9ff384 100644 --- a/src/lib/corelib/language/value.cpp +++ b/src/lib/corelib/language/value.cpp @@ -48,29 +48,63 @@ namespace qbs { namespace Internal { -Value::Value(Type t, bool createdByPropertiesBlock) - : m_type(t), m_definingItem(nullptr), m_createdByPropertiesBlock(createdByPropertiesBlock) +Value::Value(Type t, bool createdByPropertiesBlock) : m_type(t) { + if (createdByPropertiesBlock) + m_flags |= OriginPropertiesBlock; } Value::Value(const Value &other) : m_type(other.m_type), - m_definingItem(other.m_definingItem), + m_scope(other.m_scope), m_next(other.m_next ? other.m_next->clone() : ValuePtr()), - m_createdByPropertiesBlock(other.m_createdByPropertiesBlock) + m_flags(other.m_flags) { } Value::~Value() = default; -Item *Value::definingItem() const +void Value::setScope(Item *scope, const QString &scopeName) { - return m_definingItem; + m_scope = scope; + m_scopeName = scopeName; } -void Value::setDefiningItem(Item *item) +int Value::priority(const Item *productItem) const { - m_definingItem = item; + if (m_priority == -1) + m_priority = calculatePriority(productItem); + return m_priority; +} + +int Value::calculatePriority(const Item *productItem) const +{ + if (setInternally()) + return INT_MAX; + if (setByCommandLine()) + return INT_MAX - 1; + if (setByProfile()) + return 2; + if (!scope()) + return 1; + if (scope()->type() == ItemType::Product) + return INT_MAX - 2; + if (!scope()->isPresentModule()) + return 0; + const auto it = std::find_if( + productItem->modules().begin(), productItem->modules().end(), + [this](const Item::Module &m) { return m.item == scope(); }); + QBS_CHECK(it != productItem->modules().end()); + return INT_MAX - 3 - it->maxDependsChainLength; +} + +void Value::resetPriority() +{ + m_priority = -1; + if (m_next) + m_next->resetPriority(); + for (const ValuePtr &v : m_candidates) + v->resetPriority(); } ValuePtr Value::next() const @@ -85,6 +119,11 @@ void Value::setNext(const ValuePtr &next) m_next = next; } +bool Value::setInternally() const +{ + return type() == VariantValueType && !setByProfile() && !setByCommandLine(); +} + JSSourceValue::JSSourceValue(bool createdByPropertiesBlock) : Value(JSSourceValueType, createdByPropertiesBlock) @@ -99,7 +138,6 @@ JSSourceValue::JSSourceValue(const JSSourceValue &other) : Value(other) m_line = other.m_line; m_column = other.m_column; m_file = other.m_file; - m_flags = other.m_flags; m_baseValue = other.m_baseValue ? std::static_pointer_cast<JSSourceValue>(other.m_baseValue->clone()) : JSSourceValuePtr(); @@ -142,24 +180,45 @@ CodeLocation JSSourceValue::location() const return CodeLocation(m_file->filePath(), m_line, m_column); } -void JSSourceValue::setHasFunctionForm(bool b) +void JSSourceValue::clearAlternatives() +{ + m_alternatives.clear(); +} + +void JSSourceValue::setScope(Item *scope, const QString &scopeName) { - if (b) - m_flags |= HasFunctionForm; - else - m_flags &= ~HasFunctionForm; + Value::setScope(scope, scopeName); + if (m_baseValue) + m_baseValue->setScope(scope, scopeName); + for (const JSSourceValue::Alternative &a : m_alternatives) + a.value->setScope(scope, scopeName); } -void JSSourceValue::clearAlternatives() +void JSSourceValue::resetPriority() { - m_alternatives.clear(); + Value::resetPriority(); + if (m_baseValue) + m_baseValue->resetPriority(); + for (const JSSourceValue::Alternative &a : m_alternatives) + a.value->resetPriority(); +} + +void JSSourceValue::addCandidate(const ValuePtr &v) +{ + Value::addCandidate(v); + if (m_baseValue) + m_baseValue->addCandidate(v); + for (const JSSourceValue::Alternative &a : m_alternatives) + a.value->addCandidate(v); } -void JSSourceValue::setDefiningItem(Item *item) +void JSSourceValue::setCandidates(const std::vector<ValuePtr> &candidates) { - Value::setDefiningItem(item); + Value::setCandidates(candidates); + if (m_baseValue) + m_baseValue->setCandidates(candidates); for (const JSSourceValue::Alternative &a : m_alternatives) - a.value->setDefiningItem(item); + a.value->setCandidates(candidates); } ItemValue::ItemValue(Item *item, bool createdByPropertiesBlock) diff --git a/src/lib/corelib/language/value.h b/src/lib/corelib/language/value.h index 5f6b5ca16..262813841 100644 --- a/src/lib/corelib/language/value.h +++ b/src/lib/corelib/language/value.h @@ -42,6 +42,7 @@ #include "forward_decls.h" #include <tools/codelocation.h> +#include <QtCore/qstring.h> #include <QtCore/qvariant.h> #include <vector> @@ -54,13 +55,26 @@ class ValueHandler; class Value { public: - enum Type - { + enum Type { JSSourceValueType, ItemValueType, VariantValueType }; + enum Flag { + NoFlags = 0x00, + SourceUsesBase = 0x01, + SourceUsesOuter = 0x02, + SourceUsesOriginal = 0x04, + HasFunctionForm = 0x08, + ExclusiveListValue = 0x10, + BuiltinDefaultValue = 0x20, + OriginPropertiesBlock = 0x40, + OriginProfile = 0x80, + OriginCommandLine = 0x100, + }; + Q_DECLARE_FLAGS(Flags, Flag) + Value(Type t, bool createdByPropertiesBlock); Value(const Value &other); virtual ~Value(); @@ -70,21 +84,50 @@ public: virtual ValuePtr clone() const = 0; virtual CodeLocation location() const { return {}; } - Item *definingItem() const; - virtual void setDefiningItem(Item *item); + Item *scope() const { return m_scope; } + virtual void setScope(Item *scope, const QString &scopeName); + QString scopeName() const { return m_scopeName; } + int priority(const Item *productItem) const; + virtual void resetPriority(); ValuePtr next() const; void setNext(const ValuePtr &next); - bool createdByPropertiesBlock() const { return m_createdByPropertiesBlock; } - void setCreatedByPropertiesBlock(bool b) { m_createdByPropertiesBlock = b; } - void clearCreatedByPropertiesBlock() { m_createdByPropertiesBlock = false; } + virtual void addCandidate(const ValuePtr &v) { m_candidates.push_back(v); } + const std::vector<ValuePtr> &candidates() const { return m_candidates; } + virtual void setCandidates(const std::vector<ValuePtr> &candidates) { m_candidates = candidates; } + + bool createdByPropertiesBlock() const { return m_flags & OriginPropertiesBlock; } + void markAsSetByProfile() { m_flags |= OriginProfile; } + bool setByProfile() const { return m_flags & OriginProfile; } + void markAsSetByCommandLine() { m_flags |= OriginCommandLine; } + bool setByCommandLine() const { return m_flags & OriginCommandLine; } + bool setInternally() const; + bool expired(const Item *productItem) const { return priority(productItem) == 0; } + + void setSourceUsesBase() { m_flags |= SourceUsesBase; } + bool sourceUsesBase() const { return m_flags.testFlag(SourceUsesBase); } + void setSourceUsesOuter() { m_flags |= SourceUsesOuter; } + bool sourceUsesOuter() const { return m_flags.testFlag(SourceUsesOuter); } + void setSourceUsesOriginal() { m_flags |= SourceUsesOriginal; } + bool sourceUsesOriginal() const { return m_flags.testFlag(SourceUsesOriginal); } + void setHasFunctionForm() { m_flags |= HasFunctionForm; } + bool hasFunctionForm() const { return m_flags.testFlag(HasFunctionForm); } + void setIsExclusiveListValue() { m_flags |= ExclusiveListValue; } + bool isExclusiveListValue() { return m_flags.testFlag(ExclusiveListValue); } + void setIsBuiltinDefaultValue() { m_flags |= BuiltinDefaultValue; } + bool isBuiltinDefaultValue() const { return m_flags.testFlag(BuiltinDefaultValue); } private: + int calculatePriority(const Item *productItem) const; + Type m_type; - Item *m_definingItem; + Item *m_scope = nullptr; + QString m_scopeName; ValuePtr m_next; - bool m_createdByPropertiesBlock; + std::vector<ValuePtr> m_candidates; + Flags m_flags; + mutable int m_priority = -1; }; class ValueHandler @@ -99,18 +142,6 @@ class JSSourceValue : public Value { friend class ItemReaderASTVisitor; - enum Flag - { - NoFlags = 0x00, - SourceUsesBase = 0x01, - SourceUsesOuter = 0x02, - SourceUsesOriginal = 0x04, - HasFunctionForm = 0x08, - ExclusiveListValue = 0x10, - BuiltinDefaultValue = 0x20, - }; - Q_DECLARE_FLAGS(Flags, Flag) - public: explicit JSSourceValue(bool createdByPropertiesBlock); JSSourceValue(const JSSourceValue &other); @@ -133,17 +164,6 @@ public: void setFile(const FileContextPtr &file) { m_file = file; } const FileContextPtr &file() const { return m_file; } - void setSourceUsesBaseFlag() { m_flags |= SourceUsesBase; } - bool sourceUsesBase() const { return m_flags.testFlag(SourceUsesBase); } - bool sourceUsesOuter() const { return m_flags.testFlag(SourceUsesOuter); } - bool sourceUsesOriginal() const { return m_flags.testFlag(SourceUsesOriginal); } - bool hasFunctionForm() const { return m_flags.testFlag(HasFunctionForm); } - void setHasFunctionForm(bool b); - void setIsExclusiveListValue() { m_flags |= ExclusiveListValue; } - bool isExclusiveListValue() { return m_flags.testFlag(ExclusiveListValue); } - void setIsBuiltinDefaultValue() { m_flags |= BuiltinDefaultValue; } - bool isBuiltinDefaultValue() const { return m_flags.testFlag(BuiltinDefaultValue); } - const JSSourceValuePtr &baseValue() const { return m_baseValue; } void setBaseValue(const JSSourceValuePtr &v) { m_baseValue = v; } @@ -176,14 +196,16 @@ public: void addAlternative(const Alternative &alternative) { m_alternatives.push_back(alternative); } void clearAlternatives(); - void setDefiningItem(Item *item) override; + void setScope(Item *scope, const QString &scopeName) override; + void resetPriority() override; + void addCandidate(const ValuePtr &v) override; + void setCandidates(const std::vector<ValuePtr> &candidates) override; private: QStringView m_sourceCode; int m_line; int m_column; FileContextPtr m_file; - Flags m_flags; JSSourceValuePtr m_baseValue; std::vector<Alternative> m_alternatives; }; |