Take rules into account when tracking changes.

This will cause rebuilding if, for example, a rule in a module that
the product uses gets its source code changed (and the rule is actually
being used).

Change-Id: I009685c85fcc8fa0ae3ecc7c32194685a1558104
Reviewed-by: Joerg Bornemann <joerg.bornemann@digia.com>

3 files changed, 62 insertions, 0 deletions

diff --git a/src/lib/buildgraph/buildgraphloader.cpp b/src/lib/buildgraph/buildgraphloader.cpp
index 130784b31..aa2a5090e 100644
--- a/src/lib/buildgraph/buildgraphloader.cpp
+++ b/src/lib/buildgraph/buildgraphloader.cpp
@@ -413,6 +413,8 @@ bool BuildGraphLoader::checkProductForChanges(const ResolvedProductPtr &restored
 {
     return !transformerListsAreEqual(restoredProduct->transformers,
                                      newlyResolvedProduct->transformers)
+            || !ruleListsAreEqual(restoredProduct->rules.toList(),
+                                  newlyResolvedProduct->rules.toList())
             || !dependenciesAreEqual(restoredProduct, newlyResolvedProduct)
             || checkForPropertyChanges(restoredProduct, newlyResolvedProduct);
     // TODO: Check for more stuff.
diff --git a/src/lib/language/language.cpp b/src/lib/language/language.cpp
index 3fee4a759..79a0cd260 100644
--- a/src/lib/language/language.cpp
+++ b/src/lib/language/language.cpp
@@ -987,6 +987,7 @@ template<typename T> bool listsAreEqual(const QList<T> &l1, const QList<T> &l2)
 
 QString keyFromElem(const SourceArtifactPtr &sa) { return sa->absoluteFilePath; }
 QString keyFromElem(const ResolvedTransformerConstPtr &t) { return t->transform->sourceCode; }
+QString keyFromElem(const RulePtr &r) { return r->toString(); }
 
 bool operator==(const SourceArtifact &sa1, const SourceArtifact &sa2)
 {
@@ -1020,5 +1021,54 @@ bool transformerListsAreEqual(const QList<ResolvedTransformerConstPtr> &l1,
     return listsAreEqual(l1, l2);
 }
 
+bool operator==(const Rule &r1, const Rule &r2)
+{
+    if (&r1 == &r2)
+        return true;
+    if (!&r1 != !&r2)
+        return false;
+    if (r1.artifacts.count() != r2.artifacts.count())
+        return false;
+    for (int i = 0; i < r1.artifacts.count(); ++i) {
+        if (*r1.artifacts.at(i) != *r2.artifacts.at(i))
+            return false;
+    }
+
+    return r1.module->name == r2.module->name
+            && r1.script->sourceCode == r2.script->sourceCode
+            && r1.inputs == r2.inputs
+            && r1.auxiliaryInputs == r2.auxiliaryInputs
+            && r1.usings == r2.usings
+            && r1.explicitlyDependsOn == r2.explicitlyDependsOn
+            && r1.multiplex == r2.multiplex;
+}
+
+bool ruleListsAreEqual(const QList<RulePtr> &l1, const QList<RulePtr> &l2)
+{
+    return listsAreEqual(l1, l2);
+}
+
+bool operator==(const RuleArtifact &a1, const RuleArtifact &a2)
+{
+    if (&a1 == &a2)
+        return true;
+    if (!&a1 != !&a2)
+        return false;
+    return a1.fileName == a2.fileName
+            && a1.fileTags == a2.fileTags
+            && a1.alwaysUpdated == a2.alwaysUpdated
+            && a1.bindings.toList().toSet() == a2.bindings.toList().toSet();
+}
+
+bool operator==(const RuleArtifact::Binding &b1, const RuleArtifact::Binding &b2)
+{
+    return b1.code == b2.code && b1.name == b2.name;
+}
+
+uint qHash(const RuleArtifact::Binding &b)
+{
+    return qHash(qMakePair(b.code, b.name.join(QLatin1String(","))));
+}
+
 } // namespace Internal
 } // namespace qbs
diff --git a/src/lib/language/language.h b/src/lib/language/language.h
index a467adc4d..77f0425e4 100644
--- a/src/lib/language/language.h
+++ b/src/lib/language/language.h
@@ -116,6 +116,13 @@ private:
     void load(PersistentPool &pool);
     void store(PersistentPool &pool) const;
 };
+uint qHash(const RuleArtifact::Binding &b);
+bool operator==(const RuleArtifact::Binding &b1, const RuleArtifact::Binding &b2);
+inline bool operator!=(const RuleArtifact::Binding &b1, const RuleArtifact::Binding &b2) {
+    return !(b1 == b2);
+}
+bool operator==(const RuleArtifact &a1, const RuleArtifact &a2);
+inline bool operator!=(const RuleArtifact &a1, const RuleArtifact &a2) { return !(a1 == a2); }
 
 class SourceArtifact : public PersistentObject
 {
@@ -292,6 +299,9 @@ private:
     void load(PersistentPool &pool);
     void store(PersistentPool &pool) const;
 };
+bool operator==(const Rule &r1, const Rule &r2);
+inline bool operator!=(const Rule &r1, const Rule &r2) { return !(r1 == r2); }
+bool ruleListsAreEqual(const QList<RulePtr> &l1, const QList<RulePtr> &l2);
 
 class ResolvedTransformer : public PersistentObject
 {