Handle enum classes

Since the enum values can be duplicates (they only need to be unique in the scope of the enum class) I opted to prefix them with the enum class name (and an underscore) in the generated wrapper.
It would have been nice to use a Python Enum class instead, but after a quick look this seemed to be quite a lot of work.

Author: usiems

generator/abstractmetabuilder.cpp

@@ -1008,6 +1008,8 @@ AbstractMetaEnum *AbstractMetaBuilder::traverseEnum(EnumModelItem enum_item, Abs
        return 0;
     }
 
+    static_cast<EnumTypeEntry*>(type_entry)->setEnumClass(enum_item->isEnumClass());
+
     AbstractMetaEnum *meta_enum = createMetaEnum();
     if (   enumsDeclarations.contains(qualified_name)
         || enumsDeclarations.contains(enum_name)) {

generator/parser/ast.h

@@ -421,6 +421,7 @@ struct EnumSpecifierAST: public TypeSpecifierAST
 
   NameAST *name{};
   const ListNode<EnumeratorAST*> *enumerators{};
+  bool is_enum_class{};
 };
 
 struct EnumeratorAST: public AST

generator/parser/binder.cpp

@@ -796,6 +796,7 @@ void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
 
   _M_current_enum = model()->create<EnumModelItem>();
   _M_current_enum->setAccessPolicy(_M_current_access);
+  _M_current_enum->setEnumClass(node->is_enum_class);
   updateItemPosition (_M_current_enum->toItem(), node);
   _M_current_enum->setName(name);
   _M_current_enum->setScope(enumScope->qualifiedName());

generator/parser/codemodel.h

@@ -676,6 +676,9 @@ class _EnumModelItem: public _CodeModelItem
   CodeModel::AccessPolicy accessPolicy() const;
   void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 
+  bool isEnumClass() const { return _M_isEnumClass; }
+  void setEnumClass(bool isEnumClass) { _M_isEnumClass = isEnumClass; }
+
   EnumeratorList enumerators() const;
   void addEnumerator(EnumeratorModelItem item);
   void removeEnumerator(EnumeratorModelItem item);
@@ -689,6 +692,7 @@ class _EnumModelItem: public _CodeModelItem
 private:
   CodeModel::AccessPolicy _M_accessPolicy;
   EnumeratorList _M_enumerators;
+  bool _M_isEnumClass{};
 
 private:
   _EnumModelItem(const _EnumModelItem &other);

generator/parser/parser.cpp

@@ -1548,8 +1548,10 @@ bool Parser::parseEnumSpecifier(TypeSpecifierAST *&node)
 
   CHECK(Token_enum);
 
+  bool enum_class{};
   if (token_stream.lookAhead() == Token_class)
     {
+      enum_class = true;
       nextToken();
     }
 
@@ -1576,6 +1578,7 @@ bool Parser::parseEnumSpecifier(TypeSpecifierAST *&node)
 
   EnumSpecifierAST *ast = CreateNode<EnumSpecifierAST>(_M_pool);
   ast->name = name;
+  ast->is_enum_class = enum_class;
 
   EnumeratorAST *enumerator = 0;
   if (parseEnumerator(enumerator))

generator/shellheadergenerator.cpp

@@ -305,11 +305,27 @@ void ShellHeaderGenerator::write(QTextStream& s, const AbstractMetaClass* meta_c
       s << "enum " << enum1->name() << "{" << endl;
       bool first = true;
       QString scope = enum1->wasProtected() ? promoterClassName(meta_class) : meta_class->qualifiedCppName();
+      bool isEnumClass = enum1->typeEntry()->isEnumClass();
+      if (isEnumClass) {
+        scope += "::" + enum1->name();
+      }
 
       for (AbstractMetaEnumValue * value :  enum1->values()) {
         if (first) { first = false; }
         else { s << ", "; }
-        s << "  " << value->name() << " = " << scope << "::" << value->name();
+        QString assignedValue = scope + "::" + value->name();
+        if (isEnumClass) {
+          // prepend value name with class name, the value name on itself could be a duplicate
+          // 
+          // I thought about creating a enum class instead, and creating an Enum class in PythonQt for the wrapper
+          // (QMetaEnum has a isScoped method to check for enum classes),
+          // but the process seemed quite complicated.
+          s << "  " << enum1->name() << "_" << value->name() << " = " << "static_cast<int>(" << scope << "::" << value->name() << ")";
+        }
+        else {
+          s << "  " << value->name() << " = " << scope << "::" << value->name();
+
+        }
       }
       s << "};" << endl;
     }

generator/typesystem.h

@@ -730,6 +730,9 @@ class EnumTypeEntry : public TypeEntry
     void addEnumValueRedirection(const QString &rejected, const QString &usedValue);
     QString enumValueRedirection(const QString &value) const;
 
+    bool isEnumClass() const { return m_enum_class; }
+    void setEnumClass(bool enum_class) { m_enum_class = enum_class; }
+
     bool forceInteger() const { return m_force_integer; }
     void setForceInteger(bool force) { m_force_integer = force; }
 
@@ -748,6 +751,7 @@ class EnumTypeEntry : public TypeEntry
     FlagsTypeEntry *m_flags;
 
     bool m_extensible;
+    bool m_enum_class;
     bool m_force_integer;
 };