Fix QMetaObject naming of class enum flag

Adds an enumName to QMetaEnum to carry the name of the enum since for
flags that doesn't match the name of the Qt type, but is needed if the
flag is scoped.

Change-Id: I1c0f77eb9e40e6fd1eb6a59bea77caf0f33fcf43
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>

6 files changed, 71 insertions, 19 deletions

diff --git a/tests/auto/corelib/io/qdebug/tst_qdebug.cpp b/tests/auto/corelib/io/qdebug/tst_qdebug.cpp
index b43ea7cfa5..7b8b1df166 100644
--- a/tests/auto/corelib/io/qdebug/tst_qdebug.cpp
+++ b/tests/auto/corelib/io/qdebug/tst_qdebug.cpp
@@ -38,6 +38,13 @@
 class tst_QDebug: public QObject
 {
     Q_OBJECT
+public:
+    enum EnumType { EnumValue1 = 1, EnumValue2 = 2 };
+    enum FlagType { EnumFlag1 = 1, EnumFlag2 = 2 };
+    Q_ENUM(EnumType)
+    Q_DECLARE_FLAGS(Flags, FlagType)
+    Q_FLAG(Flags)
+
 private slots:
     void assignment() const;
     void warningWithoutDebug() const;
@@ -637,6 +644,15 @@ void tst_QDebug::qDebugQFlags() const
     QCOMPARE(s_line, line);
     QCOMPARE(QString::fromLatin1(s_function), function);
 
+    // Test the output of QFlags with an enum not declared with Q_DECLARE_FLAGS and Q_FLAGS
+    QFlags<EnumType> flags2(EnumValue2);
+    qDebug() << flags2;
+    QCOMPARE(s_msg, QString::fromLatin1("QFlags<tst_QDebug::EnumType>(EnumValue2)"));
+
+    // A now for one that was fully declared
+    tst_QDebug::Flags flags3(EnumFlag1);
+    qDebug() << flags3;
+    QCOMPARE(s_msg, QString::fromLatin1("QFlags<tst_QDebug::FlagType>(EnumFlag1)"));
 }
 
 void tst_QDebug::textStreamModifiers() const
diff --git a/tests/auto/corelib/kernel/qmetaenum/tst_qmetaenum.cpp b/tests/auto/corelib/kernel/qmetaenum/tst_qmetaenum.cpp
index e4aa8b80c0..bb111a9137 100644
--- a/tests/auto/corelib/kernel/qmetaenum/tst_qmetaenum.cpp
+++ b/tests/auto/corelib/kernel/qmetaenum/tst_qmetaenum.cpp
@@ -37,7 +37,10 @@ class tst_QMetaEnum : public QObject
     Q_OBJECT
 public:
     enum SuperEnum { SuperValue1 = 1 , SuperValue2 = 2 };
+    enum Flag { Flag1 = 1 , Flag2 = 2 };
+    Q_DECLARE_FLAGS(Flags, Flag)
     Q_ENUM(SuperEnum)
+    Q_FLAG(Flags)
 
 private slots:
     void fromType();
@@ -49,7 +52,17 @@ void tst_QMetaEnum::fromType()
 {
     QMetaEnum meta = QMetaEnum::fromType<SuperEnum>();
     QVERIFY(meta.isValid());
+    QVERIFY(!meta.isFlag());
     QCOMPARE(meta.name(), "SuperEnum");
+    QCOMPARE(meta.enumName(), "SuperEnum");
+    QCOMPARE(meta.enclosingMetaObject(), &staticMetaObject);
+    QCOMPARE(meta.keyCount(), 2);
+
+    meta = QMetaEnum::fromType<Flags>();
+    QVERIFY(meta.isValid());
+    QVERIFY(meta.isFlag());
+    QCOMPARE(meta.name(), "Flags");
+    QCOMPARE(meta.enumName(), "Flag");
     QCOMPARE(meta.enclosingMetaObject(), &staticMetaObject);
     QCOMPARE(meta.keyCount(), 2);
 }
diff --git a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
index 2d67e978f7..9c33dc4c4d 100644
--- a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
+++ b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
@@ -69,7 +69,13 @@ namespace MyNamespace {
             MyFlag2 = 0x02,
             MyFlag3 = 0x04
         };
+        enum class MyScopedFlag {
+            MyFlag1 = 0x10,
+            MyFlag2 = 0x20,
+            MyFlag3 = 0x40
+        };
         Q_DECLARE_FLAGS(MyFlags, MyFlag)
+        Q_DECLARE_FLAGS(MyScopedFlags, MyScopedFlag)
 
         MyEnum myEnum() const { return m_enum; }
         void setMyEnum(MyEnum val) { m_enum = val; }
@@ -87,6 +93,7 @@ namespace MyNamespace {
         Q_ENUM(MyScopedEnum)
         Q_ENUM(MyAnotherEnum)
         Q_FLAG(MyFlags)
+        Q_FLAG(MyScopedFlags)
 
         MyEnum m_enum;
         MyFlags m_flags;
@@ -1745,13 +1752,21 @@ void tst_QMetaObject::enumDebugStream()
     QTest::ignoreMessage(QtDebugMsg, "Qt::WindowTitleHint Qt::Window Qt::Desktop Qt::WindowSystemMenuHint");
     qDebug() << Qt::WindowTitleHint << Qt::Window << Qt::Desktop << Qt::WindowSystemMenuHint;
 
-    QTest::ignoreMessage(QtDebugMsg, "hello QFlags<MyNamespace::MyClass::MyFlags>(MyFlag1) world");
+    QTest::ignoreMessage(QtDebugMsg, "hello QFlags<MyNamespace::MyClass::MyFlag>(MyFlag1) world");
     MyNamespace::MyClass::MyFlags f1 = MyNamespace::MyClass::MyFlag1;
     qDebug() << "hello" << f1 << "world";
 
     MyNamespace::MyClass::MyFlags f2 = MyNamespace::MyClass::MyFlag2 | MyNamespace::MyClass::MyFlag3;
-    QTest::ignoreMessage(QtDebugMsg, "QFlags<MyNamespace::MyClass::MyFlags>(MyFlag1) QFlags<MyNamespace::MyClass::MyFlags>(MyFlag2|MyFlag3)");
+    QTest::ignoreMessage(QtDebugMsg, "QFlags<MyNamespace::MyClass::MyFlag>(MyFlag1) QFlags<MyNamespace::MyClass::MyFlag>(MyFlag2|MyFlag3)");
     qDebug() << f1 << f2;
+
+    QTest::ignoreMessage(QtDebugMsg, "QFlags<MyNamespace::MyClass::MyScopedFlag>(MyFlag2)");
+    MyNamespace::MyClass::MyScopedFlags f3 = MyNamespace::MyClass::MyScopedFlag::MyFlag2;
+    qDebug() << f3;
+
+    QTest::ignoreMessage(QtDebugMsg, "QFlags<MyNamespace::MyClass::MyScopedFlag>(MyFlag2|MyFlag3)");
+    f3 |= MyNamespace::MyClass::MyScopedFlag::MyFlag3;
+    qDebug() << f3;
 }
 
 void tst_QMetaObject::inherits_data()
diff --git a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
index 6bb031e357..56623773a2 100644
--- a/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
+++ b/tests/auto/corelib/kernel/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
@@ -830,6 +830,7 @@ void tst_QMetaObjectBuilder::enumerator()
     // Modify the attributes on enum1.
     enum1.setIsFlag(true);
     enum1.setIsScoped(true);
+    enum1.setEnumName(QByteArrayLiteral("fooFlag"));
     QCOMPARE(enum1.addKey("ABC", 0), 0);
     QCOMPARE(enum1.addKey("DEF", 1), 1);
     QCOMPARE(enum1.addKey("GHI", -1), 2);
@@ -838,6 +839,7 @@ void tst_QMetaObjectBuilder::enumerator()
     QCOMPARE(enum1.name(), QByteArray("foo"));
     QVERIFY(enum1.isFlag());
     QVERIFY(enum1.isScoped());
+    QCOMPARE(enum1.enumName(), QByteArray("fooFlag"));
     QCOMPARE(enum1.keyCount(), 3);
     QCOMPARE(enum1.index(), 0);
     QCOMPARE(enum1.key(0), QByteArray("ABC"));
diff --git a/tests/auto/tools/moc/cxx11-enums.h b/tests/auto/tools/moc/cxx11-enums.h
index 209ec4eb43..93ab16c157 100644
--- a/tests/auto/tools/moc/cxx11-enums.h
+++ b/tests/auto/tools/moc/cxx11-enums.h
@@ -39,7 +39,7 @@ public:
     enum TypedEnum : char { B0, B1 , B2, B3 };
     enum class TypedEnumClass : char { C0, C1, C2, C3 };
     enum NormalEnum { D2 = 2, D3, D0 =0 , D1 };
-    enum class ClassFlag { F0, F1, F2, F3 };
+    enum class ClassFlag { F0 = 1, F1 = 2, F2 = 4, F3 = 8};
     Q_DECLARE_FLAGS(ClassFlags, ClassFlag)
 
     Q_ENUM(EnumClass)
@@ -58,7 +58,7 @@ public:
     enum TypedEnum : char { B0, B1 , B2, B3 };
     enum class TypedEnumClass : char { C0, C1, C2, C3 };
     enum NormalEnum { D2 = 2, D3, D0 =0 , D1 };
-    enum class ClassFlag { F0, F1, F2, F3 };
+    enum class ClassFlag { F0 = 1, F1 = 2, F2 = 4, F3 = 8 };
     Q_DECLARE_FLAGS(ClassFlags, ClassFlag)
     Q_ENUMS(EnumClass TypedEnum TypedEnumClass NormalEnum)
     Q_FLAGS(ClassFlags)
diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp
index 8a08de9bc6..92a94055a4 100644
--- a/tests/auto/tools/moc/tst_moc.cpp
+++ b/tests/auto/tools/moc/tst_moc.cpp
@@ -2248,6 +2248,7 @@ void tst_Moc::privateClass()
 void tst_Moc::cxx11Enums_data()
 {
     QTest::addColumn<const QMetaObject *>("meta");
+    QTest::addColumn<QByteArray>("typeName");
     QTest::addColumn<QByteArray>("enumName");
     QTest::addColumn<char>("prefix");
     QTest::addColumn<bool>("isScoped");
@@ -2255,16 +2256,16 @@ void tst_Moc::cxx11Enums_data()
     const QMetaObject *meta1 = &CXX11Enums::staticMetaObject;
     const QMetaObject *meta2 = &CXX11Enums2::staticMetaObject;
 
-    QTest::newRow("EnumClass") << meta1 << QByteArray("EnumClass") << 'A' << true;
-    QTest::newRow("EnumClass 2") << meta2 << QByteArray("EnumClass") << 'A' << true;
-    QTest::newRow("TypedEnum") << meta1 << QByteArray("TypedEnum") << 'B' << false;
-    QTest::newRow("TypedEnum 2") << meta2 << QByteArray("TypedEnum") << 'B' << false;
-    QTest::newRow("TypedEnumClass") << meta1 << QByteArray("TypedEnumClass") << 'C' << true;
-    QTest::newRow("TypedEnumClass 2") << meta2 << QByteArray("TypedEnumClass") << 'C' << true;
-    QTest::newRow("NormalEnum") << meta1 << QByteArray("NormalEnum") << 'D' << false;
-    QTest::newRow("NormalEnum 2") << meta2 << QByteArray("NormalEnum") << 'D' << false;
-    QTest::newRow("ClassFlags") << meta1 << QByteArray("ClassFlags") << 'F' << true;
-    QTest::newRow("ClassFlags 2") << meta2 << QByteArray("ClassFlags") << 'F' << true;
+    QTest::newRow("EnumClass") << meta1 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true;
+    QTest::newRow("EnumClass 2") << meta2 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true;
+    QTest::newRow("TypedEnum") << meta1 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false;
+    QTest::newRow("TypedEnum 2") << meta2 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false;
+    QTest::newRow("TypedEnumClass") << meta1 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true;
+    QTest::newRow("TypedEnumClass 2") << meta2 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true;
+    QTest::newRow("NormalEnum") << meta1 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false;
+    QTest::newRow("NormalEnum 2") << meta2 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false;
+    QTest::newRow("ClassFlags") << meta1 << QByteArray("ClassFlags") << QByteArray("ClassFlag") << 'F' << true;
+    QTest::newRow("ClassFlags 2") << meta2 << QByteArray("ClassFlags") << QByteArray("ClassFlag") << 'F' << true;
 }
 
 void tst_Moc::cxx11Enums()
@@ -2272,21 +2273,26 @@ void tst_Moc::cxx11Enums()
     QFETCH(const QMetaObject *,meta);
     QCOMPARE(meta->enumeratorOffset(), 0);
 
+    QFETCH(QByteArray, typeName);
     QFETCH(QByteArray, enumName);
     QFETCH(char, prefix);
     QFETCH(bool, isScoped);
 
-    int idx;
-    idx = meta->indexOfEnumerator(enumName);
+    int idx = meta->indexOfEnumerator(typeName);
     QVERIFY(idx != -1);
+    QCOMPARE(meta->indexOfEnumerator(enumName), idx);
+
     QCOMPARE(meta->enumerator(idx).enclosingMetaObject(), meta);
     QCOMPARE(meta->enumerator(idx).isValid(), true);
     QCOMPARE(meta->enumerator(idx).keyCount(), 4);
-    QCOMPARE(meta->enumerator(idx).name(), enumName.constData());
+    QCOMPARE(meta->enumerator(idx).name(), typeName.constData());
+    QCOMPARE(meta->enumerator(idx).enumName(), enumName.constData());
+    bool isFlag = meta->enumerator(idx).isFlag();
     for (int i = 0; i < 4; i++) {
         QByteArray v = prefix + QByteArray::number(i);
-        QCOMPARE(meta->enumerator(idx).keyToValue(v), i);
-        QCOMPARE(meta->enumerator(idx).valueToKey(i), v.constData());
+        const int value = isFlag ? (1 << i) : i;
+        QCOMPARE(meta->enumerator(idx).keyToValue(v), value);
+        QCOMPARE(meta->enumerator(idx).valueToKey(value), v.constData());
     }
     QCOMPARE(meta->enumerator(idx).isScoped(), isScoped);
 }