Fix lack of deterministic behavior in moc.

Moc should check full scope of any related objects or
gadget when it constructs extra data.

Change-Id: Ibd1b607a389cd4e788c0916984464cd9103d9c59
Reviewed-by: Olivier Goffart <ogoffart@woboq.com>

src/tools/moc/generator.cpp

@@ -438,6 +438,9 @@ void Generator::generateCode()
 // Build extra array
 //
     QList<QByteArray> extraList;
+    QHash<QByteArray, QByteArray> knownExtraMetaObject = knownGadgets;
+    knownExtraMetaObject.unite(knownQObjectClasses);
+
     for (int i = 0; i < cdef->propertyList.count(); ++i) {
         const PropertyDef &p = cdef->propertyList.at(i);
         if (isBuiltinType(p.type))
@@ -453,12 +456,19 @@ void Generator::generateCode()
         QByteArray unqualifiedScope = p.type.left(s);
 
         // The scope may be a namespace for example, so it's only safe to include scopes that are known QObjects (QTBUG-2151)
-        QHash<QByteArray, QByteArray>::ConstIterator scopeIt = knownQObjectClasses.find(unqualifiedScope);
+        QHash<QByteArray, QByteArray>::ConstIterator scopeIt;
-        if (scopeIt == knownQObjectClasses.constEnd()) {
+
-            scopeIt = knownGadgets.find(unqualifiedScope);
+        QByteArray thisScope = cdef->qualified;
-            if (scopeIt == knownGadgets.constEnd())
+        do {
+            int s = thisScope.lastIndexOf("::");
+            thisScope = thisScope.left(s);
+            QByteArray currentScope = thisScope.isEmpty() ? unqualifiedScope : thisScope + "::" + unqualifiedScope;
+            scopeIt = knownExtraMetaObject.constFind(currentScope);
+        } while (!thisScope.isEmpty() && scopeIt == knownExtraMetaObject.constEnd());
+
+        if (scopeIt == knownExtraMetaObject.constEnd())
             continue;
-        }
+
         const QByteArray &scope = *scopeIt;
 
         if (scope == "Qt")

tests/auto/tools/moc/moc.pro

@@ -27,7 +27,8 @@ HEADERS += using-namespaces.h no-keywords.h task87883.h c-comments.h backslash-n
            single-quote-digit-separator-n3781.h \
            related-metaobjects-in-namespaces.h \
            qtbug-35657-gadget.h \
-           related-metaobjects-in-gadget.h
+           related-metaobjects-in-gadget.h \
+           related-metaobjects-name-conflict.h
 
 
 if(*-g++*|*-icc*|*-clang*|*-llvm):!irix-*:!win32-*: HEADERS += os9-newlines.h win-newlines.h

tests/auto/tools/moc/related-metaobjects-name-conflict.h

@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef RELATED_METAOBJECTS_NAME_CONFLICT_H
+#define RELATED_METAOBJECTS_NAME_CONFLICT_H
+
+#include <QObject>
+
+#define DECLARE_GADGET_AND_OBJECT_CLASSES \
+    class Gadget { \
+        Q_GADGET \
+        Q_ENUMS(SomeEnum) \
+    public: \
+        enum SomeEnum { SomeEnumValue = 0 }; \
+    }; \
+    class Object : public QObject{ \
+        Q_OBJECT \
+        Q_ENUMS(SomeEnum) \
+    public: \
+        enum SomeEnum { SomeEnumValue = 0 }; \
+    };
+
+#define DECLARE_DEPENDING_CLASSES \
+    class DependingObject : public QObject \
+    { \
+        Q_OBJECT \
+        Q_PROPERTY(Gadget::SomeEnum gadgetPoperty READ gadgetPoperty) \
+        Q_PROPERTY(Object::SomeEnum objectPoperty READ objectPoperty) \
+    public: \
+        Gadget::SomeEnum gadgetPoperty() const { return Gadget::SomeEnumValue; } \
+        Object::SomeEnum objectPoperty() const { return Object::SomeEnumValue; } \
+    };\
+    struct DependingNestedGadget : public QObject \
+    { \
+        Q_OBJECT \
+        Q_PROPERTY(Nested::Gadget::SomeEnum nestedGadgetPoperty READ nestedGadgetPoperty) \
+        Nested::Gadget::SomeEnum nestedGadgetPoperty() const { return Nested::Gadget::SomeEnumValue; } \
+    };\
+    struct DependingNestedObject : public QObject \
+    { \
+        Q_OBJECT \
+        Q_PROPERTY(Nested::Object::SomeEnum nestedObjectPoperty READ nestedObjectPoperty) \
+        Nested::Object::SomeEnum nestedObjectPoperty() const { return Nested::Object::SomeEnumValue; } \
+    };\
+
+
+namespace Unsused {
+    DECLARE_GADGET_AND_OBJECT_CLASSES
+} // Unused
+
+namespace NS1 {
+namespace Nested {
+    DECLARE_GADGET_AND_OBJECT_CLASSES
+} // Nested
+
+namespace NestedUnsused {
+    DECLARE_GADGET_AND_OBJECT_CLASSES
+} // NestedUnused
+
+DECLARE_GADGET_AND_OBJECT_CLASSES
+DECLARE_DEPENDING_CLASSES
+
+} // NS1
+
+namespace NS2 {
+namespace Nested {
+    DECLARE_GADGET_AND_OBJECT_CLASSES
+} // Nested
+
+namespace NestedUnsused {
+    DECLARE_GADGET_AND_OBJECT_CLASSES
+} // NestedUnused
+
+DECLARE_GADGET_AND_OBJECT_CLASSES
+DECLARE_DEPENDING_CLASSES
+
+} // NS2
+
+#endif // RELATED_METAOBJECTS_NAME_CONFLICT_H

tests/auto/tools/moc/tst_moc.cpp

@@ -78,6 +78,7 @@
 #include "parse-defines.h"
 #include "related-metaobjects-in-namespaces.h"
 #include "related-metaobjects-in-gadget.h"
+#include "related-metaobjects-name-conflict.h"
 
 QT_USE_NAMESPACE
 
@@ -573,6 +574,8 @@ private slots:
     void writeEnumFromUnrelatedClass();
     void relatedMetaObjectsWithinNamespaces();
     void relatedMetaObjectsInGadget();
+    void relatedMetaObjectsNameConflict_data();
+    void relatedMetaObjectsNameConflict();
 
 signals:
     void sigWithUnsignedArg(unsigned foo);
@@ -3176,6 +3179,59 @@ void tst_Moc::relatedMetaObjectsInGadget()
     QVERIFY(testMo->d.relatedMetaObjects[0] == relatedMo);
 }
 
+void tst_Moc::relatedMetaObjectsNameConflict_data()
+{
+    typedef QVector<const QMetaObject*> QMetaObjects;
+    QTest::addColumn<const QMetaObject*>("dependingObject");
+    QTest::addColumn<QMetaObjects>("relatedMetaObjects");
+
+    //NS1
+    const QMetaObject *n1gadget = &NS1::Gadget::staticMetaObject;
+    const QMetaObject *n1object = &NS1::Object::staticMetaObject;
+    const QMetaObject *n1nestedGadget = &NS1::Nested::Gadget::staticMetaObject;
+    const QMetaObject *n1nestedObject = &NS1::Nested::Object::staticMetaObject;
+    //N2
+    const QMetaObject *n2gadget = &NS2::Gadget::staticMetaObject;
+    const QMetaObject *n2object = &NS2::Object::staticMetaObject;
+    const QMetaObject *n2nestedGadget = &NS2::Nested::Gadget::staticMetaObject;
+    const QMetaObject *n2nestedObject = &NS2::Nested::Object::staticMetaObject;
+
+    QTest::newRow("N1::dependingObject") << &NS1::DependingObject::staticMetaObject
+                                        <<  (QMetaObjects() << n1gadget << n1object);
+    QTest::newRow("N2::dependingObject") << &NS2::DependingObject::staticMetaObject
+                                        <<  (QMetaObjects() << n2gadget << n2object);
+    QTest::newRow("N1::dependingNestedObject") << &NS1::DependingNestedObject::staticMetaObject
+                                        <<  (QMetaObjects() << n1nestedObject);
+    QTest::newRow("N2::dependingNestedObject") << &NS2::DependingNestedObject::staticMetaObject
+                                        <<  (QMetaObjects() << n2nestedObject);
+    QTest::newRow("N1::dependingNestedGadget") << &NS1::DependingNestedGadget::staticMetaObject
+                                        <<  (QMetaObjects() << n1nestedGadget);
+    QTest::newRow("N2::dependingNestedGadget") << &NS2::DependingNestedGadget::staticMetaObject
+                                        <<  (QMetaObjects() << n2nestedGadget);
+}
+
+void tst_Moc::relatedMetaObjectsNameConflict()
+{
+    typedef QVector<const QMetaObject*> QMetaObjects;
+    QFETCH(const QMetaObject*, dependingObject);
+    QFETCH(QMetaObjects, relatedMetaObjects);
+
+    // load all specified metaobjects int a set
+    QSet<const QMetaObject*> dependency;
+    const QMetaObject *const *i = dependingObject->d.relatedMetaObjects;
+    while (*i) {
+        dependency.insert(*i);
+        ++i;
+    }
+
+    // check if all required metaobjects are specified
+    foreach (const QMetaObject *mo, relatedMetaObjects)
+        QVERIFY(dependency.contains(mo));
+
+    // check if no additional metaobjects ara specified
+    QCOMPARE(dependency.size(), relatedMetaObjects.size());
+}
+
 QTEST_MAIN(tst_Moc)
 
 // the generated code must compile with QT_NO_KEYWORDS