[Backport generator] Automatically add enums marked with Q_ENUM to TypeDatabase

If this is for a QObject-derived class, they are ignored automatically,
but if it is for a Q_GADGET, they obviously are intended for use with
scripting

(cherry picked from commit MeVisLab/pythonqt@e1e85a2)

Author: usiems

generator/abstractmetabuilder.cpp

@@ -430,6 +430,15 @@ bool AbstractMetaBuilder::build()
 
 
     // Start the generation...
+
+    // First automatically add all enums marked as QEnum into the TypeDatabase
+    // (if they don't contain an entry already). If there is an QEnum entry,
+    // the enum is obviously meant for scripting.
+    for (ClassModelItem item : typeMap.values()) {
+        autoAddQEnumsForClassItem(item);
+    }
+
+
     for (ClassModelItem item :  typeMap.values()) {
         AbstractMetaClass *cls = traverseClass(item);
         addAbstractMetaClass(cls);
@@ -609,6 +618,33 @@ bool AbstractMetaBuilder::build()
     return true;
 }
 
+void AbstractMetaBuilder::autoAddQEnumsForClassItem(ClassModelItem class_item)
+{
+    // also do this for sub-classes:
+    for (ClassModelItem sub_class : class_item->classMap().values()) {
+        autoAddQEnumsForClassItem(sub_class);
+    }
+
+    auto qEnumDeclarations = class_item->qEnumDeclarations();
+    for (EnumModelItem enum_item : class_item->enumMap().values()) {
+        if (enum_item) {
+            const auto& names = enum_item->qualifiedName();
+            QString qualified_name = names.join("::");
+            QString enum_name = enum_item->name();
+
+            bool hasQEnumDeclaration = qEnumDeclarations.contains(qualified_name)
+                                    || qEnumDeclarations.contains(enum_name);
+
+            TypeEntry* type_entry = TypeDatabase::instance()->findType(qualified_name);
+            if (hasQEnumDeclaration && !type_entry) {
+                // automatically add enum type declared as Q_ENUM
+                type_entry = new EnumTypeEntry(QStringList(names.mid(0, names.size() - 1)).join("::"), names.last());
+                TypeDatabase::instance()->addType(type_entry);
+            }
+        }
+    }
+}
+
 
 void AbstractMetaBuilder::addAbstractMetaClass(AbstractMetaClass *cls)
 {
@@ -664,7 +700,7 @@ AbstractMetaClass *AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
                                .arg(meta_class->package())
                                .arg(namespace_item->name()));
 
-    traverseEnums(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class, namespace_item->enumsDeclarations());
+    traverseEnums(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class, namespace_item->qEnumDeclarations());
     traverseFunctions(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class);
 //     traverseClasses(model_dynamic_cast<ScopeModelItem>(namespace_item));
 
@@ -1122,12 +1158,12 @@ AbstractMetaClass *AbstractMetaBuilder::traverseClass(ClassModelItem class_item)
     meta_class->setTemplateArguments(template_args);
     meta_class->setHasActualDeclaration(class_item->hasActualDeclaration());
 
-    parseQ_Property(meta_class, class_item->propertyDeclarations());
-
     traverseFunctions(model_dynamic_cast<ScopeModelItem>(class_item), meta_class);
-    traverseEnums(model_dynamic_cast<ScopeModelItem>(class_item), meta_class, class_item->enumsDeclarations());
+    traverseEnums(model_dynamic_cast<ScopeModelItem>(class_item), meta_class, class_item->qEnumDeclarations());
     traverseFields(model_dynamic_cast<ScopeModelItem>(class_item), meta_class);
 
+    parseQ_Property(meta_class, class_item->propertyDeclarations());
+
     // Inner classes
     {
         QList<ClassModelItem> inner_classes = class_item->classMap().values();
@@ -1465,17 +1501,11 @@ bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *meta_class)
     return true;
 }
 
-void AbstractMetaBuilder::traverseEnums(ScopeModelItem scope_item, AbstractMetaClass *meta_class, const QStringList &enumsDeclarations)
+void AbstractMetaBuilder::traverseEnums(ScopeModelItem scope_item, AbstractMetaClass *meta_class, const QSet<QString> &qEnumDeclarations)
 {
     EnumList enums = scope_item->enums();
     for (EnumModelItem enum_item :  enums) {
-        AbstractMetaEnum *meta_enum = traverseEnum(enum_item, meta_class,
-#if QT_VERSION < QT_VERSION_CHECK(5,14,0)
-            QSet<QString>::fromList(enumsDeclarations)
-#else
-            QSet<QString>(enumsDeclarations.begin(), enumsDeclarations.end())
-#endif
-        );
+        AbstractMetaEnum* meta_enum = traverseEnum(enum_item, meta_class, qEnumDeclarations);
         if (meta_enum) {
             meta_enum->setOriginalAttributes(meta_enum->attributes());
             meta_class->addEnum(meta_enum);

generator/abstractmetabuilder.h

@@ -82,6 +82,8 @@ class AbstractMetaBuilder
 
     bool build();
 
+    void autoAddQEnumsForClassItem(ClassModelItem item);
+
     void figureOutEnumValuesForClass(AbstractMetaClass *meta_class, QSet<AbstractMetaClass *> *classes);
     int figureOutEnumValue(const QString &name, int value, AbstractMetaEnum *meta_enum, AbstractMetaFunction *meta_function = 0);
     void figureOutEnumValues();
@@ -92,7 +94,7 @@ class AbstractMetaBuilder
     bool setupInheritance(AbstractMetaClass *meta_class);
     AbstractMetaClass *traverseNamespace(NamespaceModelItem item);
     AbstractMetaEnum *traverseEnum(EnumModelItem item, AbstractMetaClass *enclosing, const QSet<QString> &enumsDeclarations);
-    void traverseEnums(ScopeModelItem item, AbstractMetaClass *parent, const QStringList &enumsDeclarations);
+    void traverseEnums(ScopeModelItem item, AbstractMetaClass *parent, const QSet<QString> &enumsDeclarations);
     void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent);
     void traverseFields(ScopeModelItem item, AbstractMetaClass *parent);
     void traverseStreamOperator(FunctionModelItem function_item);

generator/parser/binder.cpp

@@ -856,7 +856,7 @@ void Binder::visitQEnums(QEnumsAST *node)
     //if (node->isQEnum) {
     //  std::cout << enum_list.at(i).toLatin1().constData() << std::endl;
     //}
-    scope->addEnumsDeclaration(enum_list.at(i));
+    scope->addQEnumDeclaration(enum_list.at(i));
   }
 }
 

generator/parser/codemodel.cpp

@@ -429,9 +429,9 @@ FunctionList _ScopeModelItem::functions() const
   return _M_functions.values();
 }
 
-void _ScopeModelItem::addEnumsDeclaration(const QString &enumsDeclaration)
+void _ScopeModelItem::addQEnumDeclaration(const QString &qEnumDeclaration)
 {
-    _M_enumsDeclarations << enumsDeclaration;
+  _M_qEnumDeclarations.insert(qEnumDeclaration);
 }
 
 FunctionDefinitionList _ScopeModelItem::functionDefinitions() const

generator/parser/codemodel.h

@@ -51,6 +51,7 @@
 #include <QtCore/QString>
 #include <QtCore/QStringList>
 #include <QtCore/QVector>
+#include <QtCore/QSet>
 
 #define DECLARE_MODEL_NODE(k) \
     enum { __node_kind = Kind_##k }; \
@@ -307,8 +308,8 @@ class _ScopeModelItem: public _CodeModelItem
   TypeAliasModelItem findTypeAlias(const QString &name) const;
   VariableModelItem findVariable(const QString &name) const;
 
-  void addEnumsDeclaration(const QString &enumsDeclaration);
-  QStringList enumsDeclarations() const { return _M_enumsDeclarations; }
+  void addQEnumDeclaration(const QString &qEnumDeclaration);
+  QSet<QString> qEnumDeclarations() const { return _M_qEnumDeclarations; }
 
   inline QHash<QString, ClassModelItem> classMap() const { return _M_classes; }
   inline QHash<QString, EnumModelItem> enumMap() const { return _M_enums; }
@@ -335,7 +336,7 @@ class _ScopeModelItem: public _CodeModelItem
   _ScopeModelItem(const _ScopeModelItem &other);
   void operator = (const _ScopeModelItem &other);
 
-  QStringList _M_enumsDeclarations;
+  QSet<QString> _M_qEnumDeclarations;
 };
 
 class _ClassModelItem: public _ScopeModelItem