moc: use EnumFlags in EnumDef

Change-Id: I8a96935cf6c742259c9dfffd17e950a5230e2465
Reviewed-by: Fabian Kosmale <[email protected]>
Reviewed-by: Ahmad Samir <[email protected]>

3 files changed, 23 insertions, 26 deletions

diff --git a/src/tools/moc/generator.cpp b/src/tools/moc/generator.cpp
index b46cf35707b..a04da1bead4 100644
--- a/src/tools/moc/generator.cpp
+++ b/src/tools/moc/generator.cpp
@@ -907,11 +907,7 @@ void Generator::generateEnums(int index)
     int i;
     for (i = 0; i < cdef->enumList.size(); ++i) {
         const EnumDef &e = cdef->enumList.at(i);
-        int flags = 0;
-        if (cdef->enumDeclarations.value(e.name))
-            flags |= EnumIsFlag;
-        if (e.isEnumClass)
-            flags |= EnumIsScoped;
+        uint flags = e.flags | cdef->enumDeclarations.value(e.name);
         fprintf(out, "    %4d, %4d, 0x%.1x, %4d, %4d,\n",
                  stridx(e.name),
                  e.enumName.isNull() ? stridx(e.name) : stridx(e.enumName),
@@ -923,13 +919,12 @@ void Generator::generateEnums(int index)
 
     fprintf(out, "\n // enum data: key, value\n");
     for (const EnumDef &e : std::as_const(cdef->enumList)) {
+        QByteArray prefix = cdef->qualified;
+        if (e.flags & EnumIsScoped)
+            prefix += "::" + (e.enumName.isNull() ? e.name : e.enumName);
         for (const QByteArray &val : e.values) {
-            QByteArray code = cdef->qualified.constData();
-            if (e.isEnumClass)
-                code += "::" + (e.enumName.isNull() ? e.name : e.enumName);
-            code += "::" + val;
-            fprintf(out, "    %4d, uint(%s),\n",
-                    stridx(val), code.constData());
+            fprintf(out, "    %4d, uint(%s::%s),\n",
+                    stridx(val), prefix.constData(), val.constData());
         }
     }
 }
@@ -1289,7 +1284,7 @@ void Generator::generateStaticMetacall()
                 else if (p.gspec == PropertyDef::ReferenceSpec)
                     fprintf(out, "        case %d: _a[0] = const_cast<void*>(reinterpret_cast<const void*>(&%s%s())); break;\n",
                             propindex, prefix.constData(), p.read.constData());
-                else if (cdef->enumDeclarations.value(p.type, false))
+                else if (auto eflags = cdef->enumDeclarations.value(p.type); eflags & EnumIsFlag)
                     fprintf(out, "        case %d: *reinterpret_cast<int*>(_v) = QFlag(%s%s()); break;\n",
                             propindex, prefix.constData(), p.read.constData());
                 else if (p.read == "default")
@@ -1325,7 +1320,7 @@ void Generator::generateStaticMetacall()
                 if (p.inPrivateClass.size()) {
                     prefix += p.inPrivateClass + "->";
                 }
-                if (cdef->enumDeclarations.value(p.type, false)) {
+                if (auto eflags = cdef->enumDeclarations.value(p.type); eflags & EnumIsFlag) {
                     fprintf(out, "        case %d: %s%s(QFlag(*reinterpret_cast<int*>(_v))); break;\n",
                             propindex, prefix.constData(), p.write.constData());
                 } else if (p.write == "default") {
diff --git a/src/tools/moc/moc.cpp b/src/tools/moc/moc.cpp
index 184b7574288..960fa14fa82 100644
--- a/src/tools/moc/moc.cpp
+++ b/src/tools/moc/moc.cpp
@@ -13,6 +13,7 @@
 #include <QtCore/qjsondocument.h>
 
 // for normalizeTypeInternal
+#include <private/qmetaobject_p.h>
 #include <private/qmetaobject_moc_p.h>
 #include <private/qduplicatetracker_p.h>
 
@@ -242,7 +243,7 @@ bool Moc::parseEnum(EnumDef *def)
     bool isTypdefEnum = false; // typedef enum { ... } Foo;
 
     if (test(CLASS) || test(STRUCT))
-        def->isEnumClass = true;
+        def->flags |= EnumIsScoped;
 
     if (test(IDENTIFIER)) {
         def->name = lexem();
@@ -741,14 +742,14 @@ void Moc::parse()
                                 break;
                             case Q_ENUMS_TOKEN:
                             case Q_ENUM_NS_TOKEN:
-                                parseEnumOrFlag(&def, false);
+                                parseEnumOrFlag(&def, {});
                                 break;
                             case Q_ENUM_TOKEN:
                                 error("Q_ENUM can't be used in a Q_NAMESPACE, use Q_ENUM_NS instead");
                                 break;
                             case Q_FLAGS_TOKEN:
                             case Q_FLAG_NS_TOKEN:
-                                parseEnumOrFlag(&def, true);
+                                parseEnumOrFlag(&def, EnumIsFlag);
                                 break;
                             case Q_FLAG_TOKEN:
                                 error("Q_FLAG can't be used in a Q_NAMESPACE, use Q_FLAG_NS instead");
@@ -936,14 +937,14 @@ void Moc::parse()
                     break;
                 case Q_ENUMS_TOKEN:
                 case Q_ENUM_TOKEN:
-                    parseEnumOrFlag(&def, false);
+                    parseEnumOrFlag(&def, {});
                     break;
                 case Q_ENUM_NS_TOKEN:
                     error("Q_ENUM_NS can't be used in a Q_OBJECT/Q_GADGET, use Q_ENUM instead");
                     break;
                 case Q_FLAGS_TOKEN:
                 case Q_FLAG_TOKEN:
-                    parseEnumOrFlag(&def, true);
+                    parseEnumOrFlag(&def, EnumIsFlag);
                     break;
                 case Q_FLAG_NS_TOKEN:
                     error("Q_FLAG_NS can't be used in a Q_OBJECT/Q_GADGET, use Q_FLAG instead");
@@ -1599,7 +1600,7 @@ void Moc::parsePrivateProperty(ClassDef *def, Moc::PropertyMode mode)
     def->propertyList += propDef;
 }
 
-void Moc::parseEnumOrFlag(BaseDef *def, bool isFlag)
+void Moc::parseEnumOrFlag(BaseDef *def, EnumFlags flags)
 {
     next(LPAREN);
     QByteArray identifier;
@@ -1609,7 +1610,7 @@ void Moc::parseEnumOrFlag(BaseDef *def, bool isFlag)
             identifier += "::";
             identifier += lexem();
         }
-        def->enumDeclarations[identifier] = isFlag;
+        def->enumDeclarations[identifier] = flags;
     }
     next(RPAREN);
 }
@@ -2177,13 +2178,14 @@ QJsonObject PropertyDef::toJson() const
 QJsonObject EnumDef::toJson(const ClassDef &cdef) const
 {
     QJsonObject def;
+    uint flags = this->flags | cdef.enumDeclarations.value(name);
     def["name"_L1] = QString::fromUtf8(name);
     if (!enumName.isEmpty())
         def["alias"_L1] = QString::fromUtf8(enumName);
     if (!type.isEmpty())
         def["type"_L1] = QString::fromUtf8(type);
-    def["isFlag"_L1] = cdef.enumDeclarations.value(name);
-    def["isClass"_L1] = isEnumClass;
+    def["isFlag"_L1] = (flags & EnumIsFlag) != 0;
+    def["isClass"_L1] = (flags & EnumIsScoped) != 0;
 
     QJsonArray valueArr;
     for (const QByteArray &value: values)
diff --git a/src/tools/moc/moc.h b/src/tools/moc/moc.h
index 2680264aeaa..9b2f3fecefc 100644
--- a/src/tools/moc/moc.h
+++ b/src/tools/moc/moc.h
@@ -10,6 +10,7 @@
 #include <qjsondocument.h>
 #include <qjsonarray.h>
 #include <qjsonobject.h>
+#include <qtmocconstants.h>
 #include <qtyperevision.h>
 #include <stdio.h>
 
@@ -44,8 +45,7 @@ struct EnumDef
     QByteArray enumName;
     QByteArray type;
     QList<QByteArray> values;
-    bool isEnumClass; // c++11 enum class
-    EnumDef() : isEnumClass(false) {}
+    QFlags<QtMocConstants::EnumFlags> flags = {};
     QJsonObject toJson(const ClassDef &cdef) const;
     QByteArray qualifiedType(const ClassDef *cdef) const;
 };
@@ -148,7 +148,7 @@ struct BaseDef {
     QByteArray classname;
     QByteArray qualified;
     QList<ClassInfoDef> classInfoList;
-    QMap<QByteArray, bool> enumDeclarations;
+    QMap<QByteArray, QFlags<QtMocConstants::EnumFlags>> enumDeclarations;
     QList<EnumDef> enumList;
     QMap<QByteArray, QByteArray> flagAliases;
     qsizetype begin = 0;
@@ -261,7 +261,7 @@ public:
     void createPropertyDef(PropertyDef &def, int propertyIndex, PropertyMode mode);
 
     void parsePropertyAttributes(PropertyDef &propDef);
-    void parseEnumOrFlag(BaseDef *def, bool isFlag);
+    void parseEnumOrFlag(BaseDef *def, QtMocConstants::EnumFlags flags);
     void parseFlag(BaseDef *def);
     enum class EncounteredQmlMacro {Yes, No};
     EncounteredQmlMacro parseClassInfo(BaseDef *def);