1 files changed, 117 insertions, 34 deletions

diff --git a/src/lib/corelib/language/value.cpp b/src/lib/corelib/language/value.cpp
index 5a4da2c8f..634f54faf 100644
--- a/src/lib/corelib/language/value.cpp
+++ b/src/lib/corelib/language/value.cpp
@@ -48,29 +48,65 @@
 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)
+Value::Value(const Value &other, ItemPool &pool)
     : m_type(other.m_type),
-      m_definingItem(other.m_definingItem),
-      m_next(other.m_next ? other.m_next->clone() : ValuePtr()),
-      m_createdByPropertiesBlock(other.m_createdByPropertiesBlock)
+      m_scope(other.m_scope),
+      m_scopeName(other.m_scopeName),
+      m_next(other.m_next ? other.m_next->clone(pool) : ValuePtr()),
+      m_candidates(other.m_candidates),
+      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 +121,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)
@@ -93,19 +134,18 @@ JSSourceValue::JSSourceValue(bool createdByPropertiesBlock)
 {
 }
 
-JSSourceValue::JSSourceValue(const JSSourceValue &other) : Value(other)
+JSSourceValue::JSSourceValue(const JSSourceValue &other, ItemPool &pool) : Value(other, pool)
 {
     m_sourceCode = other.m_sourceCode;
     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())
+            ? std::static_pointer_cast<JSSourceValue>(other.m_baseValue->clone(pool))
             : JSSourceValuePtr();
     m_alternatives = transformed<std::vector<Alternative>>(
-        other.m_alternatives, [](const auto &alternative) {
-        return alternative.clone(); });
+        other.m_alternatives, [&pool](const auto &alternative) {
+        return alternative.clone(pool); });
 }
 
 JSSourceValuePtr JSSourceValue::create(bool createdByPropertiesBlock)
@@ -115,9 +155,9 @@ JSSourceValuePtr JSSourceValue::create(bool createdByPropertiesBlock)
 
 JSSourceValue::~JSSourceValue() = default;
 
-ValuePtr JSSourceValue::clone() const
+ValuePtr JSSourceValue::clone(ItemPool &pool) const
 {
-    return std::make_shared<JSSourceValue>(*this);
+    return std::make_shared<JSSourceValue>(*this, pool);
 }
 
 QString JSSourceValue::sourceCodeForEvaluation() const
@@ -142,24 +182,45 @@ CodeLocation JSSourceValue::location() const
     return CodeLocation(m_file->filePath(), m_line, m_column);
 }
 
-void JSSourceValue::setHasFunctionForm(bool b)
+void JSSourceValue::clearAlternatives()
 {
-    if (b)
-        m_flags |= HasFunctionForm;
-    else
-        m_flags &= ~HasFunctionForm;
+    m_alternatives.clear();
 }
 
-void JSSourceValue::clearAlternatives()
+void JSSourceValue::setScope(Item *scope, const QString &scopeName)
 {
-    m_alternatives.clear();
+    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::resetPriority()
+{
+    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)
@@ -174,29 +235,51 @@ ItemValuePtr ItemValue::create(Item *item, bool createdByPropertiesBlock)
     return std::make_shared<ItemValue>(item, createdByPropertiesBlock);
 }
 
-ValuePtr ItemValue::clone() const
+ValuePtr ItemValue::clone(ItemPool &pool) const
 {
-    return create(m_item->clone(), createdByPropertiesBlock());
+    return create(m_item->clone(pool), createdByPropertiesBlock());
 }
 
+class StoredVariantValue : public VariantValue
+{
+public:
+    explicit StoredVariantValue(QVariant v) : VariantValue(std::move(v)) {}
+
+    quintptr id() const override { return quintptr(this); }
+};
+
 VariantValue::VariantValue(QVariant v)
     : Value(VariantValueType, false)
     , m_value(std::move(v))
 {
 }
 
-VariantValuePtr VariantValue::create(const QVariant &v)
+VariantValue::VariantValue(const VariantValue &other, ItemPool &pool)
+    : Value(other, pool), m_value(other.m_value) {}
+
+template<typename T>
+VariantValuePtr createImpl(const QVariant &v)
 {
     if (!v.isValid())
-        return invalidValue();
+        return VariantValue::invalidValue();
     if (static_cast<QMetaType::Type>(v.userType()) == QMetaType::Bool)
         return v.toBool() ? VariantValue::trueValue() : VariantValue::falseValue();
-    return std::make_shared<VariantValue>(v);
+    return std::make_shared<T>(v);
+}
+
+VariantValuePtr VariantValue::create(const QVariant &v)
+{
+    return createImpl<VariantValue>(v);
+}
+
+VariantValuePtr VariantValue::createStored(const QVariant &v)
+{
+    return createImpl<StoredVariantValue>(v);
 }
 
-ValuePtr VariantValue::clone() const
+ValuePtr VariantValue::clone(ItemPool &pool) const
 {
-    return std::make_shared<VariantValue>(*this);
+    return std::make_shared<VariantValue>(*this, pool);
 }
 
 const VariantValuePtr &VariantValue::falseValue()