diff --git a/src/tools/moc/generator.cpp b/src/tools/moc/generator.cpp index 2d48c50c83..1af344e908 100644 --- a/src/tools/moc/generator.cpp +++ b/src/tools/moc/generator.cpp @@ -438,6 +438,9 @@ void Generator::generateCode() // Build extra array // QList extraList; + QHash 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::ConstIterator scopeIt = knownQObjectClasses.find(unqualifiedScope); - if (scopeIt == knownQObjectClasses.constEnd()) { - scopeIt = knownGadgets.find(unqualifiedScope); - if (scopeIt == knownGadgets.constEnd()) - continue; - } + QHash::ConstIterator scopeIt; + + QByteArray thisScope = cdef->qualified; + 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") diff --git a/tests/auto/tools/moc/moc.pro b/tests/auto/tools/moc/moc.pro index 70a1ecd476..cc8c2c671d 100644 --- a/tests/auto/tools/moc/moc.pro +++ b/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 diff --git a/tests/auto/tools/moc/related-metaobjects-name-conflict.h b/tests/auto/tools/moc/related-metaobjects-name-conflict.h new file mode 100644 index 0000000000..551ab461e3 --- /dev/null +++ b/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 + +#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 diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp index 72e24c282c..d4dfe54ab0 100644 --- a/tests/auto/tools/moc/tst_moc.cpp +++ b/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 QMetaObjects; + QTest::addColumn("dependingObject"); + QTest::addColumn("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 QMetaObjects; + QFETCH(const QMetaObject*, dependingObject); + QFETCH(QMetaObjects, relatedMetaObjects); + + // load all specified metaobjects int a set + QSet 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