shiboken6: Port AbstractMetaEnum/Value to use QSharedDataPointer

Change the client code to store it by value. For the various find()
and traverseEnum() functions, use a std::optional to replace the pointer.

Change-Id: Ie4e671bf95e569741fa3c9a399bfe239ceac0dec
Reviewed-by: Christian Tismer <tismer@stackless.com>

30 files changed, 688 insertions, 464 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index d84aa0f37..da086053e 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -73,7 +73,6 @@ AbstractMetaBuilderPrivate::AbstractMetaBuilderPrivate() :
 
 AbstractMetaBuilderPrivate::~AbstractMetaBuilderPrivate()
 {
-    qDeleteAll(m_globalEnums);
     qDeleteAll(m_globalFunctions);
     qDeleteAll(m_templates);
     qDeleteAll(m_smartPointers);
@@ -115,11 +114,15 @@ const AbstractMetaEnumList &AbstractMetaBuilder::globalEnums() const
     return d->m_globalEnums;
 }
 
-AbstractMetaEnum *AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const
+std::optional<AbstractMetaEnum>
+    AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const
 {
     if (typeEntry && typeEntry->isFlags())
         typeEntry = static_cast<const FlagsTypeEntry *>(typeEntry)->originator();
-    return d->m_enums.value(typeEntry);
+    const auto it = d->m_enums.constFind(typeEntry);
+    if (it == d->m_enums.constEnd())
+        return {};
+    return it.value();
 }
 
 void AbstractMetaBuilderPrivate::checkFunctionModifications()
@@ -401,10 +404,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     ReportHandler::startProgress("Generating enum model ("
                                  + QByteArray::number(enums.size()) + ")...");
     for (const EnumModelItem &item : enums) {
-        AbstractMetaEnum *metaEnum = traverseEnum(item, nullptr, QSet<QString>());
-        if (metaEnum) {
+        auto metaEnum = traverseEnum(item, nullptr, QSet<QString>());
+        if (metaEnum.has_value()) {
             if (metaEnum->typeEntry()->generateCode())
-                m_globalEnums << metaEnum;
+                m_globalEnums << metaEnum.value();
         }
     }
 
@@ -529,7 +532,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                 AbstractMetaClass *cls = AbstractMetaClass::findClass(m_metaClasses, name);
 
                 const bool enumFound = cls
-                    ? cls->findEnum(entry->targetLangEntryName()) != nullptr
+                    ? cls->findEnum(entry->targetLangEntryName()).has_value()
                     : m_enums.contains(entry);
 
                 if (!enumFound) {
@@ -629,8 +632,8 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     ReportHandler::endProgress();
 }
 
-static bool metaEnumLessThan(const AbstractMetaEnum *e1, const AbstractMetaEnum *e2)
-{ return e1->fullName() < e2->fullName(); }
+static bool metaEnumLessThan(const AbstractMetaEnum &e1, const AbstractMetaEnum &e2)
+{ return e1.fullName() < e2.fullName(); }
 
 static bool metaClassLessThan(const AbstractMetaClass *c1, const AbstractMetaClass *c2)
 { return c1->fullName() < c2->fullName(); }
@@ -768,9 +771,10 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     return metaClass;
 }
 
-AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem,
-                                                           AbstractMetaClass *enclosing,
-                                                           const QSet<QString> &enumsDeclarations)
+std::optional<AbstractMetaEnum>
+    AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem,
+                                             AbstractMetaClass *enclosing,
+                                             const QSet<QString> &enumsDeclarations)
 {
     QString qualifiedName = enumItem->qualifiedName().join(colonColon());
 
@@ -806,7 +810,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
         if (typeEntry)
             typeEntry->setCodeGeneration(TypeEntry::GenerateNothing);
         m_rejectedEnums.insert(qualifiedName + rejectReason, AbstractMetaBuilder::GenerationDisabled);
-        return nullptr;
+        return {};
     }
 
     const bool rejectionWarning = !enclosing || enclosing->typeEntry()->generateCode();
@@ -815,7 +819,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
         if (rejectionWarning)
             qCWarning(lcShiboken, "%s", qPrintable(msgNoEnumTypeEntry(enumItem, className)));
         m_rejectedEnums.insert(qualifiedName, AbstractMetaBuilder::NotInTypeSystem);
-        return nullptr;
+        return {};
     }
 
     if (!typeEntry->isEnum()) {
@@ -824,28 +828,28 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
                       qPrintable(msgNoEnumTypeConflict(enumItem, className, typeEntry)));
         }
         m_rejectedEnums.insert(qualifiedName, AbstractMetaBuilder::NotInTypeSystem);
-        return nullptr;
+        return {};
     }
 
-    auto *metaEnum = new AbstractMetaEnum;
-    metaEnum->setEnumKind(enumItem->enumKind());
-    metaEnum->setSigned(enumItem->isSigned());
+    AbstractMetaEnum metaEnum;
+    metaEnum.setEnumKind(enumItem->enumKind());
+    metaEnum.setSigned(enumItem->isSigned());
     if (enumsDeclarations.contains(qualifiedName)
         || enumsDeclarations.contains(enumName)) {
-        metaEnum->setHasQEnumsDeclaration(true);
+        metaEnum.setHasQEnumsDeclaration(true);
     }
 
     auto *enumTypeEntry = static_cast<EnumTypeEntry *>(typeEntry);
-    metaEnum->setTypeEntry(enumTypeEntry);
+    metaEnum.setTypeEntry(enumTypeEntry);
     switch (enumItem->accessPolicy()) {
     case CodeModel::Public:
-        *metaEnum += AbstractMetaAttributes::Public;
+        metaEnum += AbstractMetaAttributes::Public;
         break;
     case CodeModel::Protected:
-        *metaEnum += AbstractMetaAttributes::Protected;
+        metaEnum += AbstractMetaAttributes::Protected;
         break;
     case CodeModel::Private:
-        *metaEnum += AbstractMetaAttributes::Private;
+        metaEnum += AbstractMetaAttributes::Private;
         typeEntry->setCodeGeneration(TypeEntry::GenerateNothing);
         break;
     default:
@@ -855,21 +859,19 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
     const EnumeratorList &enums = enumItem->enumerators();
     for (const EnumeratorModelItem &value : enums) {
 
-        auto *metaEnumValue = new AbstractMetaEnumValue;
-        metaEnumValue->setName(value->name());
+        AbstractMetaEnumValue metaEnumValue;
+        metaEnumValue.setName(value->name());
         // Deciding the enum value...
 
-        metaEnumValue->setStringValue(value->stringValue());
-        metaEnumValue->setValue(value->value());
-        metaEnum->addEnumValue(metaEnumValue);
+        metaEnumValue.setStringValue(value->stringValue());
+        metaEnumValue.setValue(value->value());
+        metaEnum.addEnumValue(metaEnumValue);
     }
 
-    m_enums.insert(typeEntry, metaEnum);
-
-    if (!metaEnum->typeEntry()->include().isValid())
-        setInclude(metaEnum->typeEntry(), enumItem->fileName());
+    if (!metaEnum.typeEntry()->include().isValid())
+        setInclude(metaEnum.typeEntry(), enumItem->fileName());
 
-    metaEnum->setOriginalAttributes(metaEnum->attributes());
+    metaEnum.setOriginalAttributes(metaEnum.attributes());
 
     // Register all enum values on Type database
     const bool isScopedEnum = enumItem->enumKind() == EnumClass;
@@ -884,6 +886,9 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
             enumTypeEntry->setNullValue(enumValue);
     }
 
+    metaEnum.setEnclosingClass(enclosing);
+    m_enums.insert(typeEntry, metaEnum);
+
     return metaEnum;
 }
 
@@ -1448,10 +1453,9 @@ void AbstractMetaBuilderPrivate::traverseEnums(const ScopeModelItem &scopeItem,
     const EnumList &enums = scopeItem->enums();
     const QSet<QString> enumsDeclarationSet(enumsDeclarations.cbegin(), enumsDeclarations.cend());
     for (const EnumModelItem &enumItem : enums) {
-        AbstractMetaEnum* metaEnum = traverseEnum(enumItem, metaClass, enumsDeclarationSet);
-        if (metaEnum) {
-            metaClass->addEnum(metaEnum);
-            metaEnum->setEnclosingClass(metaClass);
+        auto metaEnum = traverseEnum(enumItem, metaClass, enumsDeclarationSet);
+        if (metaEnum.has_value()) {
+            metaClass->addEnum(metaEnum.value());
         }
     }
 }
@@ -2321,14 +2325,15 @@ qint64 AbstractMetaBuilderPrivate::findOutValueFromString(const QString &stringV
         return 0;
     }
 
-    AbstractMetaEnumValue *enumValue = AbstractMetaClass::findEnumValue(m_metaClasses, stringValue);
-    if (enumValue) {
+    auto enumValue = AbstractMetaClass::findEnumValue(m_metaClasses, stringValue);
+    if (enumValue.has_value()) {
         ok = true;
         return enumValue->value().value();
     }
 
-    for (AbstractMetaEnum *metaEnum : qAsConst(m_globalEnums)) {
-        if (const AbstractMetaEnumValue *ev = metaEnum->findEnumValue(stringValue)) {
+    for (const AbstractMetaEnum &metaEnum : qAsConst(m_globalEnums)) {
+        auto ev = metaEnum.findEnumValue(stringValue);
+        if (ev.has_value()) {
             ok = true;
             return ev->value().value();
         }
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
index 09c49b4fb..a11f2ec4f 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
@@ -37,6 +37,8 @@
 
 #include <QFileInfoList>
 
+#include <optional>
+
 QT_FORWARD_DECLARE_CLASS(QIODevice)
 
 class AbstractMetaBuilderPrivate;
@@ -68,7 +70,7 @@ public:
     const AbstractMetaClassList &smartPointers() const;
     const AbstractMetaFunctionList &globalFunctions() const;
     const AbstractMetaEnumList &globalEnums() const;
-    AbstractMetaEnum *findEnum(const TypeEntry *typeEntry) const;
+    std::optional<AbstractMetaEnum> findEnum(const TypeEntry *typeEntry) const;
 
     /**
     *   Sorts a list of classes topologically.
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
index 948593766..b943ad628 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
@@ -92,8 +92,9 @@ public:
     bool setupInheritance(AbstractMetaClass *metaClass);
     AbstractMetaClass *traverseNamespace(const FileModelItem &dom,
                                          const NamespaceModelItem &item);
-    AbstractMetaEnum *traverseEnum(const EnumModelItem &item, AbstractMetaClass *enclosing,
-                                   const QSet<QString> &enumsDeclarations);
+    std::optional<AbstractMetaEnum> traverseEnum(const EnumModelItem &item,
+                                                 AbstractMetaClass *enclosing,
+                                                 const QSet<QString> &enumsDeclarations);
     void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent,
                        const QStringList &enumsDeclarations);
     AbstractMetaFunctionList classFunctionList(const ScopeModelItem &scopeItem,
@@ -204,7 +205,7 @@ public:
     RejectMap m_rejectedFunctions;
     RejectMap m_rejectedFields;
 
-    QHash<const TypeEntry *, AbstractMetaEnum *> m_enums;
+    QHash<const TypeEntry *, AbstractMetaEnum> m_enums;
 
     QVector<NamespaceModelItem> m_scopes;
 
diff --git a/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp b/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp
index 5075836d3..0f1470272 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp
@@ -27,103 +27,284 @@
 ****************************************************************************/
 
 #include "abstractmetaenum.h"
+#include "abstractmetalang.h"
+#include "documentation.h"
 #include "typesystem.h"
+#include "parser/enumvalue.h"
 
 #include <QtCore/QDebug>
 
-AbstractMetaEnum::AbstractMetaEnum() :
-    m_hasQenumsDeclaration(false), m_signed(true)
+class AbstractMetaEnumValueData : public QSharedData
+{
+public:
+    QString m_name;
+    QString m_stringValue;
+    EnumValue m_value;
+    Documentation m_doc;
+};
+
+AbstractMetaEnumValue::AbstractMetaEnumValue() :
+    d(new AbstractMetaEnumValueData)
 {
 }
 
-AbstractMetaEnum::~AbstractMetaEnum()
+AbstractMetaEnumValue::AbstractMetaEnumValue(const AbstractMetaEnumValue &) = default;
+AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(const AbstractMetaEnumValue &) = default;
+AbstractMetaEnumValue::AbstractMetaEnumValue(AbstractMetaEnumValue &&) = default;
+AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(AbstractMetaEnumValue &&) = default;
+AbstractMetaEnumValue::~AbstractMetaEnumValue() = default;
+
+EnumValue AbstractMetaEnumValue::value() const
 {
-    qDeleteAll(m_enumValues);
+    return d->m_value;
 }
 
-template <class String>
-AbstractMetaEnumValue *findMatchingEnumValue(const AbstractMetaEnumValueList &list, const String &value)
+void AbstractMetaEnumValue::setValue(EnumValue value)
+{
+    if (d->m_value != value)
+        d->m_value = value;
+}
+
+QString AbstractMetaEnumValue::stringValue() const
+{
+    return d->m_stringValue;
+}
+
+void AbstractMetaEnumValue::setStringValue(const QString &v)
+{
+    if (d->m_stringValue != v)
+        d->m_stringValue = v;
+}
+
+QString AbstractMetaEnumValue::name() const
+{
+    return d->m_name;
+}
+
+void AbstractMetaEnumValue::setName(const QString &name)
+{
+    if (d->m_name != name)
+        d->m_name = name;
+}
+
+Documentation AbstractMetaEnumValue::documentation() const
+{
+    return d->m_doc;
+}
+
+void AbstractMetaEnumValue::setDocumentation(const Documentation &doc)
+{
+    if (d->m_doc != doc)
+        d->m_doc = doc;
+}
+
+// --------------------- AbstractMetaEnum
+
+class AbstractMetaEnumData : public QSharedData
 {
-    for (AbstractMetaEnumValue *enumValue : list) {
-        if (enumValue->name() == value)
+public:
+    AbstractMetaEnumData()  : m_hasQenumsDeclaration(false), m_signed(true)
+    {
+    }
+
+    AbstractMetaEnumValueList m_enumValues;
+
+    EnumTypeEntry *m_typeEntry = nullptr;
+    Documentation m_doc;
+
+    EnumKind m_enumKind = CEnum;
+    uint m_hasQenumsDeclaration : 1;
+    uint m_signed : 1;
+};
+
+AbstractMetaEnum::AbstractMetaEnum() : d(new AbstractMetaEnumData)
+{
+}
+
+AbstractMetaEnum::AbstractMetaEnum(const AbstractMetaEnum &) = default;
+AbstractMetaEnum &AbstractMetaEnum::operator=(const AbstractMetaEnum&) = default;
+AbstractMetaEnum::AbstractMetaEnum(AbstractMetaEnum &&) = default;
+AbstractMetaEnum &AbstractMetaEnum::operator=(AbstractMetaEnum &&) = default;
+AbstractMetaEnum::~AbstractMetaEnum() = default;
+
+const AbstractMetaEnumValueList &AbstractMetaEnum::values() const
+{
+    return d->m_enumValues;
+}
+
+void AbstractMetaEnum::addEnumValue(const AbstractMetaEnumValue &enumValue)
+{
+    d->m_enumValues << enumValue;
+}
+
+std::optional<AbstractMetaEnumValue>
+    findMatchingEnumValue(const AbstractMetaEnumValueList &list, QStringView value)
+{
+    for (const AbstractMetaEnumValue &enumValue : list) {
+        if (enumValue.name() == value)
             return enumValue;
     }
-    return nullptr;
+    return {};
 }
 
 // Find enum values for "enum Enum { e1 }" either for "e1" or "Enum::e1"
-AbstractMetaEnumValue *AbstractMetaEnum::findEnumValue(const QString &value) const
+std::optional<AbstractMetaEnumValue>
+    AbstractMetaEnum::findEnumValue(QStringView value) const
 {
     if (isAnonymous())
-        return findMatchingEnumValue(m_enumValues, value);
+        return findMatchingEnumValue(d->m_enumValues, value);
     const int sepPos = value.indexOf(QLatin1String("::"));
     if (sepPos == -1)
-        return findMatchingEnumValue(m_enumValues, value);
-    return name() == QStringView{value}.left(sepPos)
-        ? findMatchingEnumValue(m_enumValues, QStringView{value}.right(value.size() - sepPos - 2))
-        : nullptr;
+        return findMatchingEnumValue(d->m_enumValues, value);
+    if (name() == value.left(sepPos))
+        return findMatchingEnumValue(d->m_enumValues, value.right(value.size() - sepPos - 2));
+    return {};
 }
 
 QString AbstractMetaEnum::name() const
 {
-    return m_typeEntry->targetLangEntryName();
+    return d->m_typeEntry->targetLangEntryName();
+}
+
+QString AbstractMetaEnum::qualifiedCppName() const
+{
+    return enclosingClass()
+        ? enclosingClass()->qualifiedCppName() + QLatin1String("::") + name()
+        : name();
+}
+
+const Documentation &AbstractMetaEnum::documentation() const
+{
+    return d->m_doc;
+}
+
+void AbstractMetaEnum::setDocumentation(const Documentation &doc)
+{
+    if (d->m_doc != doc)
+        d->m_doc = doc;
 }
 
 QString AbstractMetaEnum::qualifier() const
 {
-    return m_typeEntry->targetLangQualifier();
+    return d->m_typeEntry->targetLangQualifier();
 }
 
 QString AbstractMetaEnum::package() const
 {
-    return m_typeEntry->targetLangPackage();
+    return d->m_typeEntry->targetLangPackage();
+}
+
+QString AbstractMetaEnum::fullName() const
+{
+    return package() + QLatin1Char('.') + qualifier()  + QLatin1Char('.') + name();
+}
+
+EnumKind AbstractMetaEnum::enumKind() const
+{
+    return d->m_enumKind;
+}
+
+void AbstractMetaEnum::setEnumKind(EnumKind kind)
+{
+    if (d->m_enumKind != kind)
+        d->m_enumKind = kind;
+}
+
+bool AbstractMetaEnum::isAnonymous() const
+{
+    return d->m_enumKind == AnonymousEnum;
+}
+
+bool AbstractMetaEnum::hasQEnumsDeclaration() const
+{
+    return d->m_hasQenumsDeclaration;
+}
+
+void AbstractMetaEnum::setHasQEnumsDeclaration(bool on)
+{
+    if (d->m_hasQenumsDeclaration != on)
+        d->m_hasQenumsDeclaration = on;
+}
+
+EnumTypeEntry *AbstractMetaEnum::typeEntry() const
+{
+    return d->m_typeEntry;
+}
+
+void AbstractMetaEnum::setTypeEntry(EnumTypeEntry *entry)
+{
+    if (d->m_typeEntry != entry)
+        d->m_typeEntry = entry;
+}
+
+bool AbstractMetaEnum::isSigned() const
+{
+    return d->m_signed;
+}
+
+void AbstractMetaEnum::setSigned(bool s)
+{
+    if (d->m_signed != s)
+        d->m_signed = s;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 
-static void formatMetaEnumValue(QDebug &d, const AbstractMetaEnumValue *v)
+static void formatMetaEnumValue(QDebug &d, const AbstractMetaEnumValue &v)
 {
-    const QString &name = v->stringValue();
+    const QString &name = v.stringValue();
     if (!name.isEmpty())
         d << name << '=';
-    d << v->value();
+    d << v.value();
 }
 
-QDebug operator<<(QDebug d, const AbstractMetaEnumValue *v)
+QDebug operator<<(QDebug d, const AbstractMetaEnumValue &v)
 {
     QDebugStateSaver saver(d);
     d.noquote();
     d.nospace();
     d << "AbstractMetaEnumValue(";
-    if (v)
-        formatMetaEnumValue(d, v);
-    else
-        d << '0';
+    formatMetaEnumValue(d, v);
     d << ')';
     return d;
 }
 
+static void formatMetaEnum(QDebug &d, const AbstractMetaEnum &e)
+{
+    d << e.fullName();
+    if (!e.isSigned())
+        d << " (unsigned) ";
+    d << '[';
+    const AbstractMetaEnumValueList &values = e.values();
+    for (int i = 0, count = values.size(); i < count; ++i) {
+        if (i)
+            d << ' ';
+        formatMetaEnumValue(d, values.at(i));
+    }
+    d << ']';
+}
+
 QDebug operator<<(QDebug d, const AbstractMetaEnum *ae)
 {
     QDebugStateSaver saver(d);
     d.noquote();
     d.nospace();
     d << "AbstractMetaEnum(";
-    if (ae) {
-        d << ae->fullName();
-        if (!ae->isSigned())
-            d << " (unsigned) ";
-        d << '[';
-        const AbstractMetaEnumValueList &values = ae->values();
-        for (int i = 0, count = values.size(); i < count; ++i) {
-            if (i)
-                d << ' ';
-            formatMetaEnumValue(d, values.at(i));
-        }
-        d << ']';
-    } else {
+    if (ae)
+         formatMetaEnum(d, *ae);
+    else
         d << '0';
-    }
+    d << ')';
+    return d;
+}
+
+QDebug operator<<(QDebug d, const AbstractMetaEnum &ae)
+{
+    QDebugStateSaver saver(d);
+    d.noquote();
+    d.nospace();
+    d << "AbstractMetaEnum(";
+    formatMetaEnum(d, ae);
     d << ')';
     return d;
 }
diff --git a/sources/shiboken6/ApiExtractor/abstractmetaenum.h b/sources/shiboken6/ApiExtractor/abstractmetaenum.h
index 1ee4f61b8..062ed2aaa 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaenum.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetaenum.h
@@ -1,4 +1,4 @@
-/****************************************************************************
+/****************************************************************************
 **
 ** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
@@ -31,100 +31,98 @@
 
 #include "abstractmetalang_typedefs.h"
 #include "abstractmetaattributes.h"
-#include "documentation.h"
 #include "enclosingclassmixin.h"
 #include "parser/codemodel_enums.h"
-#include "parser/enumvalue.h"
 
+#include <QtCore/QSharedDataPointer>
 #include <QtCore/QString>
 
+#include <optional>
+
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
+class AbstractMetaEnumData;
+class AbstractMetaEnumValueData;
+class Documentation;
+class EnumValue;
 class EnumTypeEntry;
 
 class AbstractMetaEnumValue
 {
 public:
-    AbstractMetaEnumValue() = default;
+    AbstractMetaEnumValue();
+    AbstractMetaEnumValue(const AbstractMetaEnumValue &);
+    AbstractMetaEnumValue &operator=(const AbstractMetaEnumValue &);
+    AbstractMetaEnumValue(AbstractMetaEnumValue &&);
+    AbstractMetaEnumValue &operator=(AbstractMetaEnumValue &&);
+    ~AbstractMetaEnumValue();
 
-    EnumValue value() const { return m_value; }
-    void setValue(EnumValue value) { m_value = value; }
+    EnumValue value() const;
+    void setValue(EnumValue value);
 
-    QString stringValue() const { return m_stringValue; }
-    void setStringValue(const QString &v) { m_stringValue = v; }
+    QString stringValue() const;
+    void setStringValue(const QString &v);
 
-    QString name() const { return m_name; }
-    void setName(const QString &name) { m_name = name; }
+    QString name() const;
+    void setName(const QString &name);
 
-    Documentation documentation() const { return m_doc; }
-    void setDocumentation(const Documentation& doc) { m_doc = doc; }
+    Documentation documentation() const;
+    void setDocumentation(const Documentation& doc);
 
 private:
-    QString m_name;
-    QString m_stringValue;
-
-    EnumValue m_value;
-
-    Documentation m_doc;
+    QSharedDataPointer<AbstractMetaEnumValueData> d;
 };
 
 class AbstractMetaEnum : public AbstractMetaAttributes, public EnclosingClassMixin
 {
 public:
     AbstractMetaEnum();
+    AbstractMetaEnum(const AbstractMetaEnum &);
+    AbstractMetaEnum &operator=(const AbstractMetaEnum &);
+    AbstractMetaEnum(AbstractMetaEnum &&);
+    AbstractMetaEnum &operator=(AbstractMetaEnum &&);
     ~AbstractMetaEnum();
 
-    const AbstractMetaEnumValueList &values() const { return m_enumValues; }
+    const AbstractMetaEnumValueList &values() const;
+    void addEnumValue(const AbstractMetaEnumValue &enumValue);
 
-    void addEnumValue(AbstractMetaEnumValue *enumValue)
-    {
-        m_enumValues << enumValue;
-    }
-
-    AbstractMetaEnumValue *findEnumValue(const QString &value) const;
+    std::optional<AbstractMetaEnumValue> findEnumValue(QStringView value) const;
 
     QString name() const;
+    QString qualifiedCppName() const;
 
-    const Documentation &documentation() const { return m_doc; }
-    void setDocumentation(const Documentation& doc) { m_doc = doc; }
+    const Documentation &documentation() const;
+    void setDocumentation(const Documentation& doc);
 
     QString qualifier() const;
 
     QString package() const;
 
-    QString fullName() const
-    {
-        return package() + QLatin1Char('.') + qualifier()  + QLatin1Char('.') + name();
-    }
+    QString fullName() const;
 
-    EnumKind enumKind() const { return m_enumKind; }
-    void setEnumKind(EnumKind kind) { m_enumKind = kind; }
+    EnumKind enumKind() const;
+    void setEnumKind(EnumKind kind);
 
-    bool isAnonymous() const { return m_enumKind == AnonymousEnum; }
+    bool isAnonymous() const;
 
     // Has the enum been declared inside a Q_ENUMS() macro in its enclosing class?
-    bool hasQEnumsDeclaration() const { return m_hasQenumsDeclaration; }
-    void setHasQEnumsDeclaration(bool on) { m_hasQenumsDeclaration = on; }
-
-    EnumTypeEntry *typeEntry() const { return m_typeEntry; }
+    bool hasQEnumsDeclaration() const;
+    void setHasQEnumsDeclaration(bool on);
 
-    void setTypeEntry(EnumTypeEntry *entry) { m_typeEntry = entry; }
+    EnumTypeEntry *typeEntry() const;
+    void setTypeEntry(EnumTypeEntry *entry);
 
-    bool isSigned() const { return m_signed; }
-    void setSigned(bool s) { m_signed = s; }
+    bool isSigned() const;
+    void setSigned(bool s);
 
 private:
-    AbstractMetaEnumValueList m_enumValues;
-    EnumTypeEntry *m_typeEntry = nullptr;
-    Documentation m_doc;
-
-    EnumKind m_enumKind = CEnum;
-    uint m_hasQenumsDeclaration : 1;
-    uint m_signed : 1;
+    QSharedDataPointer<AbstractMetaEnumData> d;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug d, const AbstractMetaEnumValue &ae);
 QDebug operator<<(QDebug d, const AbstractMetaEnum *ae);
+QDebug operator<<(QDebug d, const AbstractMetaEnum &ae);
 #endif
 
 #endif // ABSTRACTMETAENUM_H
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index f5f8412c8..d7393d82a 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -28,7 +28,6 @@
 
 #include "abstractmetalang.h"
 #include "abstractmetalang_helpers.h"
-#include "abstractmetaenum.h"
 #include "abstractmetafunction.h"
 #include "abstractmetafield.h"
 #include "modifications.h"
@@ -65,7 +64,6 @@ AbstractMetaClass::AbstractMetaClass()
 AbstractMetaClass::~AbstractMetaClass()
 {
     qDeleteAll(m_functions);
-    qDeleteAll(m_enums);
     qDeleteAll(m_propertySpecs);
 }
 
@@ -640,32 +638,37 @@ std::optional<AbstractMetaField>
     return AbstractMetaField::find(m_fields, name);
 }
 
-AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName)
+std::optional<AbstractMetaEnum>
+    AbstractMetaClass::findEnum(const QString &enumName) const
 {
-    if (AbstractMetaEnum *e = findByName(m_enums, enumName))
-        return e;
-    return nullptr;
+    for (const auto &e : m_enums) {
+        if (e.name() == enumName)
+            return e;
+    }
+    return {};
 }
 
 /*!  Recursively searches for the enum value named \a enumValueName in
   this class and its superclasses and interfaces.
 */
-AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValueName)
+std::optional<AbstractMetaEnumValue>
+    AbstractMetaClass::findEnumValue(const QString &enumValueName) const
 {
-    for (AbstractMetaEnum *e : qAsConst(m_enums)) {
-        if (AbstractMetaEnumValue *v = e->findEnumValue(enumValueName))
+    for (const AbstractMetaEnum &e : qAsConst(m_enums)) {
+        auto v = e.findEnumValue(enumValueName);
+        if (v.has_value())
             return v;
     }
     if (baseClass())
         return baseClass()->findEnumValue(enumValueName);
 
-    return nullptr;
+    return {};
 }
 
 void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const
 {
-    for (AbstractMetaEnum *metaEnum : m_enums) {
-        if (!metaEnum->isPrivate() && metaEnum->typeEntry()->generateCode())
+    for (const AbstractMetaEnum &metaEnum : m_enums) {
+        if (!metaEnum.isPrivate() && metaEnum.typeEntry()->generateCode())
             enumList->append(metaEnum);
     }
 }
@@ -915,8 +918,9 @@ void AbstractMetaClass::fixFunctions()
  */
 
 
-AbstractMetaEnum *AbstractMetaClass::findEnum(const AbstractMetaClassList &classes,
-                                              const EnumTypeEntry *entry)
+std::optional<AbstractMetaEnum>
+    AbstractMetaClass::findEnum(const AbstractMetaClassList &classes,
+                                const EnumTypeEntry *entry)
 {
     Q_ASSERT(entry->isEnum());
 
@@ -939,14 +943,15 @@ AbstractMetaEnum *AbstractMetaClass::findEnum(const AbstractMetaClassList &class
         qCWarning(lcShiboken).noquote().nospace()
             << QStringLiteral("AbstractMeta::findEnum(), unknown class '%1' in '%2'")
                               .arg(className, entry->qualifiedCppName());
-        return nullptr;
+        return {};
     }
 
     return metaClass->findEnum(enumName);
 }
 
-AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const AbstractMetaClassList &classes,
-                                                        const QString &name)
+std::optional<AbstractMetaEnumValue>
+    AbstractMetaClass::findEnumValue(const AbstractMetaClassList &classes,
+                                     const QString &name)
 {
     const auto lst = QStringView{name}.split(u"::");
 
@@ -958,13 +963,14 @@ AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const AbstractMetaClassL
     }
 
     for (AbstractMetaClass *metaClass : classes) {
-        if (AbstractMetaEnumValue *enumValue = metaClass->findEnumValue(name))
+        auto enumValue = metaClass->findEnumValue(name);
+        if (enumValue.has_value())
             return enumValue;
     }
 
     qCWarning(lcShiboken).noquote().nospace()
         << QStringLiteral("no matching enum '%1'").arg(name);
-    return nullptr;
+    return {};
 }
 
 /*!
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h
index 111552432..8de86ed2a 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h
@@ -31,6 +31,7 @@
 
 #include "abstractmetalang_typedefs.h"
 #include "abstractmetaattributes.h"
+#include "abstractmetaenum.h"
 #include "abstractmetafield.h"
 #include "enclosingclassmixin.h"
 #include "documentation.h"
@@ -170,11 +171,12 @@ public:
     std::optional<AbstractMetaField> findField(const QString &name) const;
 
     const AbstractMetaEnumList &enums() const { return m_enums; }
+    AbstractMetaEnumList &enums() { return m_enums; }
     void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; }
-    void addEnum(AbstractMetaEnum *e) { m_enums << e; }
+    void addEnum(const AbstractMetaEnum &e) { m_enums << e; }
 
-    AbstractMetaEnum *findEnum(const QString &enumName);
-    AbstractMetaEnumValue *findEnumValue(const QString &enumName);
+    std::optional<AbstractMetaEnum> findEnum(const QString &enumName) const;
+    std::optional<AbstractMetaEnumValue> findEnumValue(const QString &enumName) const;
     void getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const;
     void getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const;
 
@@ -338,10 +340,10 @@ public:
                                         const QString &name);
     static AbstractMetaClass *findClass(const AbstractMetaClassList &classes,
                                         const TypeEntry* typeEntry);
-    static AbstractMetaEnumValue *findEnumValue(const AbstractMetaClassList &classes,
-                                                const QString &string);
-    static AbstractMetaEnum *findEnum(const AbstractMetaClassList &classes,
-                                      const EnumTypeEntry *entry);
+    static std::optional<AbstractMetaEnumValue> findEnumValue(const AbstractMetaClassList &classes,
+                                                              const QString &string);
+    static  std::optional<AbstractMetaEnum> findEnum(const AbstractMetaClassList &classes,
+                                                     const EnumTypeEntry *entry);
 
     SourceLocation sourceLocation() const;
     void setSourceLocation(const SourceLocation &sourceLocation);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
index 88b96cd8e..a79cdbab3 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
@@ -42,8 +42,8 @@ class AbstractMetaType;
 
 using AbstractMetaArgumentList = QVector<AbstractMetaArgument>;
 using AbstractMetaClassList = QVector<AbstractMetaClass *>;
-using AbstractMetaEnumList = QVector<AbstractMetaEnum *>;
-using AbstractMetaEnumValueList = QVector<AbstractMetaEnumValue *>;
+using AbstractMetaEnumList = QList<AbstractMetaEnum>;
+using AbstractMetaEnumValueList = QList<AbstractMetaEnumValue>;
 using AbstractMetaFieldList = QList<AbstractMetaField>;
 using AbstractMetaFunctionList = QVector<AbstractMetaFunction *>;
 using AbstractMetaFunctionCList = QVector<const AbstractMetaFunction *>;
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp
index aa552cdd3..a6bdd3edb 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.cpp
+++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp
@@ -161,7 +161,8 @@ ContainerTypeEntryList ApiExtractor::containerTypes() const
     return TypeDatabase::instance()->containerTypes();
 }
 
-const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const TypeEntry* typeEntry) const
+std::optional<AbstractMetaEnum>
+    ApiExtractor::findAbstractMetaEnum(const TypeEntry* typeEntry) const
 {
     return m_builder->findEnum(typeEntry);
 }
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h
index 3168894e7..f9a33ae60 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.h
+++ b/sources/shiboken6/ApiExtractor/apiextractor.h
@@ -38,6 +38,8 @@
 #include <QFileInfoList>
 #include <QStringList>
 
+#include <optional>
+
 class AbstractMetaBuilder;
 class AbstractMetaClass;
 class AbstractMetaEnum;
@@ -88,7 +90,7 @@ public:
     PrimitiveTypeEntryList primitiveTypes() const;
     ContainerTypeEntryList containerTypes() const;
 
-    const AbstractMetaEnum* findAbstractMetaEnum(const TypeEntry* typeEntry) const;
+    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const TypeEntry* typeEntry) const;
 
     int classCount() const;
 
diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
index 435447133..723a5f022 100644
--- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp
+++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
@@ -202,15 +202,15 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 
     //Enums
-    for (AbstractMetaEnum *meta_enum : metaClass->enums()) {
+    for (AbstractMetaEnum &meta_enum : metaClass->enums()) {
         QString query = QLatin1String("/doxygen/compounddef/sectiondef/memberdef[@kind=\"enum\"]/name[text()=\"")
-            + meta_enum->name() + QLatin1String("\"]/..");
+            + meta_enum.name() + QLatin1String("\"]/..");
         QString doc = getDocumentation(xquery, query, DocModificationList());
         if (doc.isEmpty()) {
             qCWarning(lcShibokenDoc, "%s",
                       qPrintable(msgCannotFindDocumentation(doxyFilePath, metaClass, meta_enum, query)));
         }
-        meta_enum->setDocumentation(doc);
+        meta_enum.setDocumentation(doc);
     }
 
 }
diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp
index 6c8d19601..3447873f7 100644
--- a/sources/shiboken6/ApiExtractor/messages.cpp
+++ b/sources/shiboken6/ApiExtractor/messages.cpp
@@ -421,11 +421,11 @@ QString msgCannotFindDocumentation(const QString &fileName,
 
 QString msgCannotFindDocumentation(const QString &fileName,
                                    const AbstractMetaClass *metaClass,
-                                   const AbstractMetaEnum *e,
+                                   const AbstractMetaEnum &e,
                                    const QString &query)
 {
     return msgCannotFindDocumentation(fileName, "enum",
-                                      metaClass->name() + QLatin1String("::") + e->name(),
+                                      metaClass->name() + QLatin1String("::") + e.name(),
                                       query);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h
index 54e961237..60c14fc15 100644
--- a/sources/shiboken6/ApiExtractor/messages.h
+++ b/sources/shiboken6/ApiExtractor/messages.h
@@ -144,7 +144,7 @@ QString msgCannotFindDocumentation(const QString &fileName,
 
 QString msgCannotFindDocumentation(const QString &fileName,
                                    const AbstractMetaClass *metaClass,
-                                   const AbstractMetaEnum *e,
+                                   const AbstractMetaEnum &e,
                                    const QString &query);
 
 QString msgCannotFindDocumentation(const QString &fileName,
diff --git a/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp b/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp
index 513bb3532..2ee7398ea 100644
--- a/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp
@@ -50,6 +50,13 @@ void EnumValue::setUnsignedValue(quint64 v)
     m_type = Unsigned;
 }
 
+bool EnumValue::equals(const EnumValue &rhs) const
+{
+    if (m_type != rhs.m_type)
+        return false;
+    return m_type == Signed ? m_value == rhs.m_value : m_unsignedValue == rhs.m_unsignedValue;
+}
+
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d,const EnumValue &v)
 {
diff --git a/sources/shiboken6/ApiExtractor/parser/enumvalue.h b/sources/shiboken6/ApiExtractor/parser/enumvalue.h
index ea30c39bb..3cd7d01a4 100644
--- a/sources/shiboken6/ApiExtractor/parser/enumvalue.h
+++ b/sources/shiboken6/ApiExtractor/parser/enumvalue.h
@@ -54,6 +54,8 @@ public:
     void setValue(qint64 v);
     void setUnsignedValue(quint64 v);
 
+    bool equals(const EnumValue &rhs) const;
+
 private:
 #ifndef QT_NO_DEBUG_STREAM
     friend QDebug operator<<(QDebug, const EnumValue &);
@@ -68,4 +70,9 @@ private:
     Type m_type = Signed;
 };
 
+inline bool operator==(const EnumValue &e1, const EnumValue &e2)
+{ return e1.equals(e2); }
+inline bool operator!=(const EnumValue &e1, const EnumValue &e2)
+{ return !e1.equals(e2); }
+
 #endif // ENUMVALUE_H
diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.cpp b/sources/shiboken6/ApiExtractor/qtdocparser.cpp
index 0df8fff4a..6ce3432d7 100644
--- a/sources/shiboken6/ApiExtractor/qtdocparser.cpp
+++ b/sources/shiboken6/ApiExtractor/qtdocparser.cpp
@@ -289,16 +289,16 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 #endif
     // Enums
-    for (AbstractMetaEnum *meta_enum : metaClass->enums()) {
+    for (AbstractMetaEnum &meta_enum : metaClass->enums()) {
         query.clear();
         QTextStream(&query) << classQuery << "/enum[@name=\""
-            << meta_enum->name() << "\"]/description";
+            << meta_enum.name() << "\"]/description";
         doc.setValue(getDocumentation(xquery, query, DocModificationList()));
         if (doc.isEmpty()) {
             qCWarning(lcShibokenDoc, "%s",
                       qPrintable(msgCannotFindDocumentation(sourceFileName, metaClass, meta_enum, query)));
         }
-        meta_enum->setDocumentation(doc);
+        meta_enum.setDocumentation(doc);
     }
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
index fd50bf2ba..df6280725 100644
--- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
@@ -33,6 +33,7 @@
 #include <abstractmetafunction.h>
 #include <abstractmetalang.h>
 #include <typesystem.h>
+#include <parser/enumvalue.h>
 
 void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
 {
@@ -128,10 +129,10 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue()
     AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
-    AbstractMetaEnum* someEnum = classA->findEnum(QLatin1String("SomeEnum"));
-    QVERIFY(someEnum);
-    AbstractMetaEnumValue *nvalues = classA->findEnumValue(QLatin1String("NValues"));
-    QVERIFY(nvalues);
+    auto someEnum = classA->findEnum(QLatin1String("SomeEnum"));
+    QVERIFY(someEnum.has_value());
+    auto nvalues = classA->findEnumValue(QLatin1String("NValues"));
+    QVERIFY(nvalues.has_value());
 
     const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst();
     QVERIFY(arg.type().isArray());
@@ -159,10 +160,9 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
-    AbstractMetaEnum *someEnum = builder->globalEnums().constFirst();
-    QVERIFY(someEnum);
-    const AbstractMetaEnumValue *nvalues = someEnum->findEnumValue(QLatin1String("NValues"));
-    QVERIFY(nvalues);
+    AbstractMetaEnum someEnum = builder->globalEnums().constFirst();
+    auto nvalues = someEnum.findEnumValue(u"NValues");
+    QVERIFY(nvalues.has_value());
 
     const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst();
     QVERIFY(arg.type().isArray());
diff --git a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
index 7e98cdf40..20b0c12e0 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
@@ -88,7 +88,7 @@ void TestDropTypeEntries::testDropEntries()
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.count(), 1);
-    QCOMPARE(globalEnums.constFirst()->name(), QLatin1String("EnumA"));
+    QCOMPARE(globalEnums.constFirst().name(), QLatin1String("EnumA"));
 
     TypeDatabase* td = TypeDatabase::instance();
     QVERIFY(td->findType(QLatin1String("funcA")));
diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
index 39bf7931a..710361b47 100644
--- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
@@ -33,6 +33,7 @@
 #include <abstractmetafunction.h>
 #include <abstractmetalang.h>
 #include <typesystem.h>
+#include <parser/enumvalue.h>
 
 void TestEnum::testEnumCppSignature()
 {
@@ -60,7 +61,7 @@ void TestEnum::testEnumCppSignature()
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.count(), 1);
-    QCOMPARE(globalEnums.constFirst()->name(), QLatin1String("GlobalEnum"));
+    QCOMPARE(globalEnums.constFirst().name(), QLatin1String("GlobalEnum"));
 
     // enum as parameter of a function
     AbstractMetaFunctionList functions = builder->globalFunctions();
@@ -85,11 +86,12 @@ void TestEnum::testEnumCppSignature()
     QCOMPARE(arg.type().cppSignature(), QLatin1String("A::ClassEnum"));
 
     AbstractMetaEnumList classEnums = classA->enums();
-    QCOMPARE(classEnums.constFirst()->name(), QLatin1String("ClassEnum"));
-    AbstractMetaEnumValue *e = AbstractMetaClass::findEnumValue(classes, QLatin1String("CA"));
-    QVERIFY(e);
+    QVERIFY(!classEnums.isEmpty());
+    QCOMPARE(classEnums.constFirst().name(), QLatin1String("ClassEnum"));
+    auto e = AbstractMetaClass::findEnumValue(classes, QLatin1String("CA"));
+    QVERIFY(e.has_value());
     e = AbstractMetaClass::findEnumValue(classes, QLatin1String("ClassEnum::CA"));
-    QVERIFY(e);
+    QVERIFY(e.has_value());
 }
 
 void TestEnum::testEnumWithApiVersion()
@@ -139,43 +141,43 @@ void TestEnum::testAnonymousEnum()
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.count(), 1);
-    QCOMPARE(globalEnums.constFirst()->typeEntry()->qualifiedCppName(),
+    QCOMPARE(globalEnums.constFirst().typeEntry()->qualifiedCppName(),
              QLatin1String("Global0"));
-    QVERIFY(globalEnums.constFirst()->isAnonymous());
+    QVERIFY(globalEnums.constFirst().isAnonymous());
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 1);
     QCOMPARE(classes[0]->enums().count(), 2);
 
-    AbstractMetaEnum* anonEnumA1 = classes[0]->findEnum(QLatin1String("A1"));
-    QVERIFY(anonEnumA1);
+    auto anonEnumA1 = classes[0]->findEnum(QLatin1String("A1"));
+    QVERIFY(anonEnumA1.has_value());
     QVERIFY(anonEnumA1->isAnonymous());
     QCOMPARE(anonEnumA1->typeEntry()->qualifiedCppName(), QLatin1String("A::A1"));
 
-    AbstractMetaEnumValue* enumValueA0 = anonEnumA1->values().constFirst();
-    QCOMPARE(enumValueA0->name(), QLatin1String("A0"));
-    QCOMPARE(enumValueA0->value().value(), 0);
-    QCOMPARE(enumValueA0->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA0 = anonEnumA1->values().constFirst();
+    QCOMPARE(enumValueA0.name(), QLatin1String("A0"));
+    QCOMPARE(enumValueA0.value().value(), 0);
+    QCOMPARE(enumValueA0.stringValue(), QString());
 
-    AbstractMetaEnumValue *enumValueA1 = anonEnumA1->values().constLast();
-    QCOMPARE(enumValueA1->name(), QLatin1String("A1"));
-    QCOMPARE(enumValueA1->value().value(), 1);
-    QCOMPARE(enumValueA1->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA1 = anonEnumA1->values().constLast();
+    QCOMPARE(enumValueA1.name(), QLatin1String("A1"));
+    QCOMPARE(enumValueA1.value().value(), 1);
+    QCOMPARE(enumValueA1.stringValue(), QString());
 
-    AbstractMetaEnum* anonEnumIsThis = classes[0]->findEnum(QLatin1String("isThis"));
-    QVERIFY(anonEnumIsThis);
+    auto anonEnumIsThis = classes[0]->findEnum(QLatin1String("isThis"));
+    QVERIFY(anonEnumIsThis.has_value());
     QVERIFY(anonEnumIsThis->isAnonymous());
     QCOMPARE(anonEnumIsThis->typeEntry()->qualifiedCppName(), QLatin1String("A::isThis"));
 
-    AbstractMetaEnumValue* enumValueIsThis = anonEnumIsThis->values().constFirst();
-    QCOMPARE(enumValueIsThis->name(), QLatin1String("isThis"));
-    QCOMPARE(enumValueIsThis->value().value(), static_cast<int>(true));
-    QCOMPARE(enumValueIsThis->stringValue(), QLatin1String("true"));
+    AbstractMetaEnumValue enumValueIsThis = anonEnumIsThis->values().constFirst();
+    QCOMPARE(enumValueIsThis.name(), QLatin1String("isThis"));
+    QCOMPARE(enumValueIsThis.value().value(), static_cast<int>(true));
+    QCOMPARE(enumValueIsThis.stringValue(), QLatin1String("true"));
 
-    AbstractMetaEnumValue *enumValueIsThat = anonEnumIsThis->values().constLast();
-    QCOMPARE(enumValueIsThat->name(), QLatin1String("isThat"));
-    QCOMPARE(enumValueIsThat->value().value(), static_cast<int>(false));
-    QCOMPARE(enumValueIsThat->stringValue(), QLatin1String("false"));
+    AbstractMetaEnumValue enumValueIsThat = anonEnumIsThis->values().constLast();
+    QCOMPARE(enumValueIsThat.name(), QLatin1String("isThat"));
+    QCOMPARE(enumValueIsThat.value().value(), static_cast<int>(false));
+    QCOMPARE(enumValueIsThat.stringValue(), QLatin1String("false"));
 }
 
 void TestEnum::testGlobalEnums()
@@ -195,31 +197,31 @@ void TestEnum::testGlobalEnums()
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.count(), 2);
 
-    AbstractMetaEnum *enumA = globalEnums.constFirst();
-    QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("EnumA"));
+    AbstractMetaEnum enumA = globalEnums.constFirst();
+    QCOMPARE(enumA.typeEntry()->qualifiedCppName(), QLatin1String("EnumA"));
 
-    AbstractMetaEnumValue *enumValueA0 = enumA->values().constFirst();
-    QCOMPARE(enumValueA0->name(), QLatin1String("A0"));
-    QCOMPARE(enumValueA0->value().value(), 0);
-    QCOMPARE(enumValueA0->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA0 = enumA.values().constFirst();
+    QCOMPARE(enumValueA0.name(), QLatin1String("A0"));
+    QCOMPARE(enumValueA0.value().value(), 0);
+    QCOMPARE(enumValueA0.stringValue(), QString());
 
-    AbstractMetaEnumValue *enumValueA1 = enumA->values().constLast();
-    QCOMPARE(enumValueA1->name(), QLatin1String("A1"));
-    QCOMPARE(enumValueA1->value().value(), 1);
-    QCOMPARE(enumValueA1->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA1 = enumA.values().constLast();
+    QCOMPARE(enumValueA1.name(), QLatin1String("A1"));
+    QCOMPARE(enumValueA1.value().value(), 1);
+    QCOMPARE(enumValueA1.stringValue(), QString());
 
-    AbstractMetaEnum *enumB = globalEnums.constLast();
-    QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("EnumB"));
+    AbstractMetaEnum enumB = globalEnums.constLast();
+    QCOMPARE(enumB.typeEntry()->qualifiedCppName(), QLatin1String("EnumB"));
 
-    AbstractMetaEnumValue* enumValueB0 = enumB->values().constFirst();
-    QCOMPARE(enumValueB0->name(), QLatin1String("B0"));
-    QCOMPARE(enumValueB0->value().value(), 2);
-    QCOMPARE(enumValueB0->stringValue(), QLatin1String("2"));
+    AbstractMetaEnumValue enumValueB0 = enumB.values().constFirst();
+    QCOMPARE(enumValueB0.name(), QLatin1String("B0"));
+    QCOMPARE(enumValueB0.value().value(), 2);
+    QCOMPARE(enumValueB0.stringValue(), QLatin1String("2"));
 
-    AbstractMetaEnumValue *enumValueB1 = enumB->values().constLast();
-    QCOMPARE(enumValueB1->name(), QLatin1String("B1"));
-    QCOMPARE(enumValueB1->value().value(), 4);
-    QCOMPARE(enumValueB1->stringValue(), QLatin1String("0x4"));
+    AbstractMetaEnumValue enumValueB1 = enumB.values().constLast();
+    QCOMPARE(enumValueB1.name(), QLatin1String("B1"));
+    QCOMPARE(enumValueB1.value().value(), 4);
+    QCOMPARE(enumValueB1.stringValue(), QLatin1String("0x4"));
 }
 
 void TestEnum::testEnumValueFromNeighbourEnum()
@@ -244,33 +246,33 @@ void TestEnum::testEnumValueFromNeighbourEnum()
     QCOMPARE(classes.count(), 1);
     QCOMPARE(classes[0]->enums().count(), 2);
 
-    AbstractMetaEnum* enumA = classes[0]->findEnum(QLatin1String("EnumA"));
-    QVERIFY(enumA);
+    auto enumA = classes[0]->findEnum(QLatin1String("EnumA"));
+    QVERIFY(enumA.has_value());
     QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumA"));
 
-    AbstractMetaEnumValue* enumValueA0 = enumA->values().constFirst();
-    QCOMPARE(enumValueA0->name(), QLatin1String("ValueA0"));
-    QCOMPARE(enumValueA0->value().value(), 0);
-    QCOMPARE(enumValueA0->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA0 = enumA->values().constFirst();
+    QCOMPARE(enumValueA0.name(), QLatin1String("ValueA0"));
+    QCOMPARE(enumValueA0.value().value(), 0);
+    QCOMPARE(enumValueA0.stringValue(), QString());
 
-    AbstractMetaEnumValue* enumValueA1 = enumA->values().constLast();
-    QCOMPARE(enumValueA1->name(), QLatin1String("ValueA1"));
-    QCOMPARE(enumValueA1->value().value(), 1);
-    QCOMPARE(enumValueA1->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA1 = enumA->values().constLast();
+    QCOMPARE(enumValueA1.name(), QLatin1String("ValueA1"));
+    QCOMPARE(enumValueA1.value().value(), 1);
+    QCOMPARE(enumValueA1.stringValue(), QString());
 
-    AbstractMetaEnum* enumB = classes[0]->findEnum(QLatin1String("EnumB"));
-    QVERIFY(enumB);
+    auto enumB = classes[0]->findEnum(QLatin1String("EnumB"));
+    QVERIFY(enumB.has_value());
     QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumB"));
 
-    AbstractMetaEnumValue *enumValueB0 = enumB->values().constFirst();
-    QCOMPARE(enumValueB0->name(), QLatin1String("ValueB0"));
-    QCOMPARE(enumValueB0->value().value(), 1);
-    QCOMPARE(enumValueB0->stringValue(), QLatin1String("A::ValueA1"));
+    AbstractMetaEnumValue enumValueB0 = enumB->values().constFirst();
+    QCOMPARE(enumValueB0.name(), QLatin1String("ValueB0"));
+    QCOMPARE(enumValueB0.value().value(), 1);
+    QCOMPARE(enumValueB0.stringValue(), QLatin1String("A::ValueA1"));
 
-    AbstractMetaEnumValue *enumValueB1 = enumB->values().constLast();
-    QCOMPARE(enumValueB1->name(), QLatin1String("ValueB1"));
-    QCOMPARE(enumValueB1->value().value(), 0);
-    QCOMPARE(enumValueB1->stringValue(), QLatin1String("ValueA0"));
+    AbstractMetaEnumValue enumValueB1 = enumB->values().constLast();
+    QCOMPARE(enumValueB1.name(), QLatin1String("ValueB1"));
+    QCOMPARE(enumValueB1.value().value(), 0);
+    QCOMPARE(enumValueB1.stringValue(), QLatin1String("ValueA0"));
 }
 
 void TestEnum::testEnumValueFromExpression()
@@ -305,60 +307,60 @@ void TestEnum::testEnumValueFromExpression()
     AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
-    AbstractMetaEnum* enumA = classA->findEnum(QLatin1String("EnumA"));
-    QVERIFY(enumA);
+    auto enumA = classA->findEnum(QLatin1String("EnumA"));
+    QVERIFY(enumA.has_value());
     QVERIFY(!enumA->isSigned());
     QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumA"));
 
-    AbstractMetaEnumValue* valueA0 = enumA->values().at(0);
-    QCOMPARE(valueA0->name(), QLatin1String("ValueA0"));
-    QCOMPARE(valueA0->stringValue(), QLatin1String("3u"));
-    QCOMPARE(valueA0->value().unsignedValue(), 3u);
-
-    AbstractMetaEnumValue* valueA1 = enumA->values().at(1);
-    QCOMPARE(valueA1->name(), QLatin1String("ValueA1"));
-    QCOMPARE(valueA1->stringValue(), QLatin1String("~3u"));
-    QCOMPARE(valueA1->value().unsignedValue(), ~3u);
-
-    AbstractMetaEnumValue* valueA2 = enumA->values().at(2);
-    QCOMPARE(valueA2->name(), QLatin1String("ValueA2"));
-    QCOMPARE(valueA2->stringValue(), QLatin1String("0xffffffff"));
-    QCOMPARE(valueA2->value().unsignedValue(), 0xffffffffu);
-
-    AbstractMetaEnumValue* valueA3 = enumA->values().at(3);
-    QCOMPARE(valueA3->name(), QLatin1String("ValueA3"));
-    QCOMPARE(valueA3->stringValue(), QLatin1String("0xf0"));
-    QCOMPARE(valueA3->value().unsignedValue(), 0xf0u);
-
-    AbstractMetaEnumValue* valueA4 = enumA->values().at(4);
-    QCOMPARE(valueA4->name(), QLatin1String("ValueA4"));
-    QCOMPARE(valueA4->stringValue(), QLatin1String("8 |ValueA3"));
-    QCOMPARE(valueA4->value().unsignedValue(), 8|0xf0u);
-
-    AbstractMetaEnumValue* valueA5 = enumA->values().at(5);
-    QCOMPARE(valueA5->name(), QLatin1String("ValueA5"));
-    QCOMPARE(valueA5->stringValue(), QLatin1String("ValueA3|32"));
-    QCOMPARE(valueA5->value().unsignedValue(), 0xf0u|32);
-
-    AbstractMetaEnumValue* valueA6 = enumA->values().at(6);
-    QCOMPARE(valueA6->name(), QLatin1String("ValueA6"));
-    QCOMPARE(valueA6->stringValue(), QLatin1String("ValueA3 >> 1"));
-    QCOMPARE(valueA6->value().unsignedValue(), 0xf0u >> 1);
-
-    AbstractMetaEnumValue* valueA7 = enumA->values().at(7);
-    QCOMPARE(valueA7->name(), QLatin1String("ValueA7"));
-    QCOMPARE(valueA7->stringValue(), QLatin1String("ValueA3 << 1"));
-    QCOMPARE(valueA7->value().unsignedValue(), 0xf0u << 1);
-
-   const AbstractMetaEnum *enumB = classA->findEnum(QLatin1String("EnumB"));
-   QVERIFY(enumB);
+    AbstractMetaEnumValue valueA0 = enumA->values().at(0);
+    QCOMPARE(valueA0.name(), QLatin1String("ValueA0"));
+    QCOMPARE(valueA0.stringValue(), QLatin1String("3u"));
+    QCOMPARE(valueA0.value().unsignedValue(), 3u);
+
+    AbstractMetaEnumValue valueA1 = enumA->values().at(1);
+    QCOMPARE(valueA1.name(), QLatin1String("ValueA1"));
+    QCOMPARE(valueA1.stringValue(), QLatin1String("~3u"));
+    QCOMPARE(valueA1.value().unsignedValue(), ~3u);
+
+    AbstractMetaEnumValue valueA2 = enumA->values().at(2);
+    QCOMPARE(valueA2.name(), QLatin1String("ValueA2"));
+    QCOMPARE(valueA2.stringValue(), QLatin1String("0xffffffff"));
+    QCOMPARE(valueA2.value().unsignedValue(), 0xffffffffu);
+
+    AbstractMetaEnumValue valueA3 = enumA->values().at(3);
+    QCOMPARE(valueA3.name(), QLatin1String("ValueA3"));
+    QCOMPARE(valueA3.stringValue(), QLatin1String("0xf0"));
+    QCOMPARE(valueA3.value().unsignedValue(), 0xf0u);
+
+    AbstractMetaEnumValue valueA4 = enumA->values().at(4);
+    QCOMPARE(valueA4.name(), QLatin1String("ValueA4"));
+    QCOMPARE(valueA4.stringValue(), QLatin1String("8 |ValueA3"));
+    QCOMPARE(valueA4.value().unsignedValue(), 8|0xf0u);
+
+    AbstractMetaEnumValue valueA5 = enumA->values().at(5);
+    QCOMPARE(valueA5.name(), QLatin1String("ValueA5"));
+    QCOMPARE(valueA5.stringValue(), QLatin1String("ValueA3|32"));
+    QCOMPARE(valueA5.value().unsignedValue(), 0xf0u|32);
+
+    AbstractMetaEnumValue valueA6 = enumA->values().at(6);
+    QCOMPARE(valueA6.name(), QLatin1String("ValueA6"));
+    QCOMPARE(valueA6.stringValue(), QLatin1String("ValueA3 >> 1"));
+    QCOMPARE(valueA6.value().unsignedValue(), 0xf0u >> 1);
+
+    AbstractMetaEnumValue valueA7 = enumA->values().at(7);
+    QCOMPARE(valueA7.name(), QLatin1String("ValueA7"));
+    QCOMPARE(valueA7.stringValue(), QLatin1String("ValueA3 << 1"));
+    QCOMPARE(valueA7.value().unsignedValue(), 0xf0u << 1);
+
+   const auto enumB = classA->findEnum(QLatin1String("EnumB"));
+   QVERIFY(enumB.has_value());
    QVERIFY(enumB->isSigned());
    QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumB"));
    QCOMPARE(enumB->values().size(), 1);
-   const AbstractMetaEnumValue *valueB0 = enumB->values().at(0);
-   QCOMPARE(valueB0->name(), QLatin1String("ValueB0"));
-   QCOMPARE(valueB0->stringValue(), QLatin1String("~3"));
-   QCOMPARE(valueB0->value().value(), ~3);
+   const AbstractMetaEnumValue valueB0 = enumB->values().at(0);
+   QCOMPARE(valueB0.name(), QLatin1String("ValueB0"));
+   QCOMPARE(valueB0.stringValue(), QLatin1String("~3"));
+   QCOMPARE(valueB0.value().value(), ~3);
 }
 
 void TestEnum::testPrivateEnum()
@@ -384,24 +386,24 @@ void TestEnum::testPrivateEnum()
     QVERIFY(classA);
     QCOMPARE(classA->enums().count(), 2);
 
-    AbstractMetaEnum* privateEnum = classA->findEnum(QLatin1String("PrivateEnum"));
-    QVERIFY(privateEnum);
+    auto privateEnum = classA->findEnum(QLatin1String("PrivateEnum"));
+    QVERIFY(privateEnum.has_value());
     QVERIFY(privateEnum->isPrivate());
     QCOMPARE(privateEnum->typeEntry()->qualifiedCppName(), QLatin1String("A::PrivateEnum"));
 
-    AbstractMetaEnum* publicEnum = classA->findEnum(QLatin1String("PublicEnum"));
-    QVERIFY(publicEnum);
+    auto publicEnum = classA->findEnum(QLatin1String("PublicEnum"));
+    QVERIFY(publicEnum.has_value());
     QCOMPARE(publicEnum->typeEntry()->qualifiedCppName(), QLatin1String("A::PublicEnum"));
 
-    AbstractMetaEnumValue *pub0 = publicEnum->values().constFirst();
-    QCOMPARE(pub0->name(), QLatin1String("Pub0"));
-    QCOMPARE(pub0->value().value(), 0x0f);
-    QCOMPARE(pub0->stringValue(), QLatin1String("Priv0"));
+    AbstractMetaEnumValue pub0 = publicEnum->values().constFirst();
+    QCOMPARE(pub0.name(), QLatin1String("Pub0"));
+    QCOMPARE(pub0.value().value(), 0x0f);
+    QCOMPARE(pub0.stringValue(), QLatin1String("Priv0"));
 
-    AbstractMetaEnumValue *pub1 = publicEnum->values().constLast();
-    QCOMPARE(pub1->name(), QLatin1String("Pub1"));
-    QCOMPARE(pub1->value().value(), 0xf0);
-    QCOMPARE(pub1->stringValue(), QLatin1String("A::Priv1"));
+    AbstractMetaEnumValue pub1 = publicEnum->values().constLast();
+    QCOMPARE(pub1.name(), QLatin1String("Pub1"));
+    QCOMPARE(pub1.value().value(), 0xf0);
+    QCOMPARE(pub1.stringValue(), QLatin1String("A::Priv1"));
 }
 
 void TestEnum::testTypedefEnum()
@@ -422,18 +424,18 @@ void TestEnum::testTypedefEnum()
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.count(), 1);
 
-    AbstractMetaEnum *enumA = globalEnums.constFirst();
-    QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("EnumA"));
+    AbstractMetaEnum enumA = globalEnums.constFirst();
+    QCOMPARE(enumA.typeEntry()->qualifiedCppName(), QLatin1String("EnumA"));
 
-    AbstractMetaEnumValue *enumValueA0 = enumA->values().constFirst();
-    QCOMPARE(enumValueA0->name(), QLatin1String("A0"));
-    QCOMPARE(enumValueA0->value().value(), 0);
-    QCOMPARE(enumValueA0->stringValue(), QLatin1String(""));
+    AbstractMetaEnumValue enumValueA0 = enumA.values().constFirst();
+    QCOMPARE(enumValueA0.name(), QLatin1String("A0"));
+    QCOMPARE(enumValueA0.value().value(), 0);
+    QCOMPARE(enumValueA0.stringValue(), QLatin1String(""));
 
-    AbstractMetaEnumValue *enumValueA1 = enumA->values().constLast();
-    QCOMPARE(enumValueA1->name(), QLatin1String("A1"));
-    QCOMPARE(enumValueA1->value().value(), 1);
-    QCOMPARE(enumValueA1->stringValue(), QString());
+    AbstractMetaEnumValue enumValueA1 = enumA.values().constLast();
+    QCOMPARE(enumValueA1.name(), QLatin1String("A1"));
+    QCOMPARE(enumValueA1.value().value(), 1);
+    QCOMPARE(enumValueA1.stringValue(), QString());
 }
 
 QTEST_APPLESS_MAIN(TestEnum)
diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
index e3aad6b50..8bd830d14 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
@@ -54,8 +54,8 @@ void NamespaceTest::testNamespaceMembers()
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClass *ns = AbstractMetaClass::findClass(classes, QLatin1String("Namespace"));
     QVERIFY(ns);
-    const AbstractMetaEnum* metaEnum = ns->findEnum(QLatin1String("Option"));
-    QVERIFY(metaEnum);
+    auto metaEnum = ns->findEnum(QLatin1String("Option"));
+    QVERIFY(metaEnum.has_value());
     const AbstractMetaFunction* func = ns->findFunction(QLatin1String("foo"));
     QVERIFY(func);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
index 0f257b472..d8170f5e8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
@@ -59,11 +59,13 @@ void TestTypeRevision::testRevisionAttr()
     AbstractMetaClass *rev2 = AbstractMetaClass::findClass(classes, QLatin1String("Rev_2"));
     QCOMPARE(rev2->typeEntry()->revision(), 2);
 
-    AbstractMetaEnum* rev3 = rev2->findEnum(QLatin1String("Rev_3"));
+    auto rev3 = rev2->findEnum(QLatin1String("Rev_3"));
+    QVERIFY(rev3.has_value());
     QCOMPARE(rev3->typeEntry()->revision(), 3);
     FlagsTypeEntry* rev4 = rev3->typeEntry()->flags();
     QCOMPARE(rev4->revision(), 4);
-    AbstractMetaEnum* rev5 = rev2->findEnum(QLatin1String("Rev_5"));
+    auto rev5 = rev2->findEnum(QLatin1String("Rev_5"));
+    QVERIFY(rev5.has_value());
     const EnumTypeEntry *revEnumTypeEntry = rev5->typeEntry();
     QCOMPARE(revEnumTypeEntry->revision(), 5);
     QCOMPARE(revEnumTypeEntry->flags()->revision(), 5);
diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp
index 42f53a6ec..3e63ce5c0 100644
--- a/sources/shiboken6/generator/generator.cpp
+++ b/sources/shiboken6/generator/generator.cpp
@@ -382,12 +382,14 @@ ContainerTypeEntryList Generator::containerTypes() const
     return m_d->apiextractor->containerTypes();
 }
 
-const AbstractMetaEnum *Generator::findAbstractMetaEnum(const TypeEntry *typeEntry) const
+std::optional<AbstractMetaEnum>
+    Generator::findAbstractMetaEnum(const TypeEntry *typeEntry) const
 {
     return m_d->apiextractor->findAbstractMetaEnum(typeEntry);
 }
 
-const AbstractMetaEnum *Generator::findAbstractMetaEnum(const AbstractMetaType &metaType) const
+std::optional<AbstractMetaEnum>
+    Generator::findAbstractMetaEnum(const AbstractMetaType &metaType) const
 {
     return m_d->apiextractor->findAbstractMetaEnum(metaType.typeEntry());
 }
@@ -841,8 +843,8 @@ bool Generator::useEnumAsIntForProtectedHack(const AbstractMetaType &metaType) c
         return true;
     if (!metaType.isEnum())
         return false;
-    const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(metaType);
-    if (!metaEnum)
+    auto metaEnum = findAbstractMetaEnum(metaType);
+    if (!metaEnum.has_value())
         return true;
     if (metaEnum->attributes() & AbstractMetaAttributes::Public) // No reason, type is public
         return false;
@@ -945,9 +947,9 @@ QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includeP
     return getClassTargetFullName_(metaClass, includePackageName);
 }
 
-QString getClassTargetFullName(const AbstractMetaEnum *metaEnum, bool includePackageName)
+QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, bool includePackageName)
 {
-    return getClassTargetFullName_(metaEnum, includePackageName);
+    return getClassTargetFullName_(&metaEnum, includePackageName);
 }
 
 QString getClassTargetFullName(const AbstractMetaType &metaType, bool includePackageName)
diff --git a/sources/shiboken6/generator/generator.h b/sources/shiboken6/generator/generator.h
index 90470100e..c43544839 100644
--- a/sources/shiboken6/generator/generator.h
+++ b/sources/shiboken6/generator/generator.h
@@ -38,6 +38,8 @@
 #include <QtCore/QTextStream>
 #include <QtCore/QVector>
 
+#include <optional>
+
 class ApiExtractor;
 class AbstractMetaBuilder;
 class AbstractMetaFunction;
@@ -60,7 +62,7 @@ QTextStream &formatCode(QTextStream &s, const QString &code, Indentor &indentor)
 void verifyDirectoryFor(const QString &file);
 
 QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName = true);
-QString getClassTargetFullName(const AbstractMetaEnum *metaEnum, bool includePackageName = true);
+QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, bool includePackageName = true);
 QString getClassTargetFullName(const AbstractMetaType &metaType, bool includePackageName = true);
 QString getFilteredCppSignatureString(QString signature);
 
@@ -300,10 +302,10 @@ protected:
     ContainerTypeEntryList containerTypes() const;
 
     /// Returns an AbstractMetaEnum for a given TypeEntry that is an EnumTypeEntry, or nullptr if not found.
-    const AbstractMetaEnum *findAbstractMetaEnum(const TypeEntry *typeEntry) const;
+    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const TypeEntry *typeEntry) const;
 
     /// Returns an AbstractMetaEnum for a given AbstractMetaType that holds an EnumTypeEntry, or nullptr if not found.
-    const AbstractMetaEnum *findAbstractMetaEnum(const AbstractMetaType &metaType) const;
+    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const AbstractMetaType &metaType) const;
 
     virtual GeneratorContext contextForClass(const AbstractMetaClass *c) const;
     GeneratorContext contextForSmartPointer(const AbstractMetaClass *c,
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index ec514c460..78e785ae7 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -1766,10 +1766,10 @@ void QtDocGenerator::writeEnums(QTextStream& s, const AbstractMetaClass* cppClas
 {
     static const QString section_title = QLatin1String(".. attribute:: ");
 
-    for (AbstractMetaEnum *en : cppClass->enums()) {
-        s << section_title << cppClass->fullName() << '.' << en->name() << Qt::endl << Qt::endl;
-        writeFormattedText(s, en->documentation().value(), cppClass);
-        const auto version = versionOf(en->typeEntry());
+    for (const AbstractMetaEnum &en : cppClass->enums()) {
+        s << section_title << cppClass->fullName() << '.' << en.name() << "\n\n";
+        writeFormattedText(s, en.documentation().value(), cppClass);
+        const auto version = versionOf(en.typeEntry());
         if (!version.isNull())
             s << rstVersionAdded(version);
     }
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index e41ae5b80..65417229d 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -41,6 +41,7 @@
 #include <propertyspec.h>
 #include <reporthandler.h>
 #include <typedatabase.h>
+#include <parser/enumvalue.h>
 
 #include <QtCore/QDir>
 #include <QtCore/QMetaObject>
@@ -408,8 +409,8 @@ void CppGenerator::generateClass(QTextStream &s, const GeneratorContext &classCo
     QVector<Include> includes;
     if (!classContext.useWrapper())
         includes += metaClass->typeEntry()->extraIncludes();
-    for (AbstractMetaEnum *cppEnum : qAsConst(classEnums))
-        includes.append(cppEnum->typeEntry()->extraIncludes());
+    for (const AbstractMetaEnum &cppEnum : qAsConst(classEnums))
+        includes.append(cppEnum.typeEntry()->extraIncludes());
     if (!includes.isEmpty()) {
         s << "\n// Extra includes\n";
         std::sort(includes.begin(), includes.end());
@@ -849,9 +850,11 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
         return QLatin1Char('"') + typeEntry->qualifiedCppName() + QLatin1Char('"');
 
     if (avoidProtectedHack()) {
-        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(func->type());
-        if (metaEnum && metaEnum->isProtected())
-            return QLatin1Char('"') + protectedEnumSurrogateName(metaEnum) + QLatin1Char('"');
+        auto metaEnum = findAbstractMetaEnum(func->type());
+        if (metaEnum.has_value() && metaEnum->isProtected()) {
+            return QLatin1Char('"') + protectedEnumSurrogateName(metaEnum.value())
+                    + QLatin1Char('"');
+        }
     }
 
     if (func->type().isPrimitive())
@@ -1223,8 +1226,8 @@ void CppGenerator::writeVirtualMethodNative(QTextStream &s,
     if (!func->isVoid()) {
         s << INDENT << "return ";
         if (avoidProtectedHack() && retType->isEnum()) {
-            const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(retType);
-            bool isProtectedEnum = metaEnum && metaEnum->isProtected();
+            auto metaEnum = findAbstractMetaEnum(retType);
+            bool isProtectedEnum = metaEnum.has_value() && metaEnum->isProtected();
             if (isProtectedEnum) {
                 QString typeCast;
                 if (metaEnum->enclosingClass())
@@ -1296,11 +1299,11 @@ void CppGenerator::writeMetaCast(QTextStream &s, const GeneratorContext &classCo
     s << "}\n\n";
 }
 
-void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum *metaEnum)
+void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum &metaEnum)
 {
-    if (metaEnum->isPrivate() || metaEnum->isAnonymous())
+    if (metaEnum.isPrivate() || metaEnum.isAnonymous())
         return;
-    writeEnumConverterFunctions(s, metaEnum->typeEntry());
+    writeEnumConverterFunctions(s, metaEnum.typeEntry());
 }
 
 void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const TypeEntry *enumType)
@@ -1311,9 +1314,9 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const TypeEntry *
     QString enumPythonType = cpythonTypeNameExt(enumType);
     QString cppTypeName = getFullTypeName(enumType).trimmed();
     if (avoidProtectedHack()) {
-        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(enumType);
-        if (metaEnum && metaEnum->isProtected())
-            cppTypeName = protectedEnumSurrogateName(metaEnum);
+        auto metaEnum = findAbstractMetaEnum(enumType);
+        if (metaEnum.has_value() && metaEnum->isProtected())
+            cppTypeName = protectedEnumSurrogateName(metaEnum.value());
     }
     QString code;
     QTextStream c(&code);
@@ -1394,7 +1397,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     metaClass->getEnumsFromInvisibleNamespacesToBeGenerated(&classEnums);
     if (!classEnums.isEmpty())
         s << "// Python to C++ enum conversion.\n";
-    for (const AbstractMetaEnum *metaEnum : qAsConst(classEnums))
+    for (const AbstractMetaEnum &metaEnum : qAsConst(classEnums))
         writeEnumConverterFunctions(s, metaEnum);
 
     if (metaClass->isNamespace())
@@ -2539,8 +2542,8 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream &s,
         writeMinimalConstructorExpression(s, type, defaultValue);
         s << ";\n";
     } else if (avoidProtectedHack() && type.typeEntry()->isEnum()) {
-        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(type);
-        if (metaEnum && metaEnum->isProtected()) {
+        auto metaEnum = findAbstractMetaEnum(type);
+        if (metaEnum.has_value() && metaEnum->isProtected()) {
             typeName = QLatin1String("long");
             isProtectedEnum = true;
         }
@@ -3629,11 +3632,11 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
             } else if (!func->isVoid() && !func->isInplaceOperator()) {
                 bool writeReturnType = true;
                 if (avoidProtectedHack()) {
-                    const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(func->type());
-                    if (metaEnum) {
+                    auto metaEnum = findAbstractMetaEnum(func->type());
+                    if (metaEnum.has_value()) {
                         QString enumName;
                         if (metaEnum->isProtected())
-                            enumName = protectedEnumSurrogateName(metaEnum);
+                            enumName = protectedEnumSurrogateName(metaEnum.value());
                         else
                             enumName = func->type().cppSignature();
                         methodCall.prepend(enumName + QLatin1Char('('));
@@ -3875,11 +3878,11 @@ void CppGenerator::writePrimitiveConverterInitialization(QTextStream &s, const C
     writeCustomConverterRegister(s, customConversion, converter);
 }
 
-void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum)
+void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum &metaEnum)
 {
-    if (metaEnum->isPrivate() || metaEnum->isAnonymous())
+    if (metaEnum.isPrivate() || metaEnum.isAnonymous())
         return;
-    writeEnumConverterInitialization(s, metaEnum->typeEntry());
+    writeEnumConverterInitialization(s, metaEnum.typeEntry());
 }
 
 void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const TypeEntry *enumType)
@@ -4935,8 +4938,8 @@ void CppGenerator::writeEnumsInitialization(QTextStream &s, AbstractMetaEnumList
     if (enums.isEmpty())
         return;
     s << INDENT << "// Initialization of enums.\n\n";
-    for (const AbstractMetaEnum *cppEnum : qAsConst(enums)) {
-        if (cppEnum->isPrivate())
+    for (const AbstractMetaEnum &cppEnum : qAsConst(enums)) {
+        if (cppEnum.isPrivate())
             continue;
         writeEnumInitialization(s, cppEnum);
     }
@@ -4951,11 +4954,11 @@ static QString mangleName(QString name)
     return name;
 }
 
-void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
-    const AbstractMetaClass *enclosingClass = cppEnum->targetLangEnclosingClass();
+    const AbstractMetaClass *enclosingClass = cppEnum.targetLangEnclosingClass();
     bool hasUpperEnclosingClass = enclosingClass && enclosingClass->targetLangEnclosingClass() != nullptr;
-    const EnumTypeEntry *enumTypeEntry = cppEnum->typeEntry();
+    const EnumTypeEntry *enumTypeEntry = cppEnum.typeEntry();
     QString enclosingObjectVariable;
     if (enclosingClass)
         enclosingObjectVariable = cpythonTypeName(enclosingClass);
@@ -4965,11 +4968,11 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
         enclosingObjectVariable = QLatin1String("module");
 
     s << INDENT << "// Initialization of ";
-    s << (cppEnum->isAnonymous() ? "anonymous enum identified by enum value" : "enum");
-    s << " '" << cppEnum->name() << "'.\n";
+    s << (cppEnum.isAnonymous() ? "anonymous enum identified by enum value" : "enum");
+    s << " '" << cppEnum.name() << "'.\n";
 
     QString enumVarTypeObj;
-    if (!cppEnum->isAnonymous()) {
+    if (!cppEnum.isAnonymous()) {
         int packageLevel = packageName().count(QLatin1Char('.')) + 1;
         FlagsTypeEntry *flags = enumTypeEntry->flags();
         if (flags) {
@@ -4989,40 +4992,39 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
         s << '(' << enclosingObjectVariable << ',' << Qt::endl;
         {
             Indentation indent(INDENT);
-            s << INDENT << '"' << cppEnum->name() << "\",\n";
+            s << INDENT << '"' << cppEnum.name() << "\",\n";
             s << INDENT << '"' << packageLevel << ':' << getClassTargetFullName(cppEnum) << "\",\n";
-            s << INDENT << '"' << (cppEnum->enclosingClass() ? (cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::")) : QString());
-            s << cppEnum->name() << '"';
+            s << INDENT << '"' << cppEnum.qualifiedCppName() << '"';
             if (flags)
                 s << ',' << Qt::endl << INDENT << cpythonTypeNameExt(flags);
             s << ");\n";
         }
-        s << INDENT << "if (!" << cpythonTypeNameExt(cppEnum->typeEntry()) << ")\n";
+        s << INDENT << "if (!" << cpythonTypeNameExt(cppEnum.typeEntry()) << ")\n";
         {
             Indentation indent(INDENT);
             s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl << Qt::endl;
         }
     }
 
-    const AbstractMetaEnumValueList &enumValues = cppEnum->values();
-    for (const AbstractMetaEnumValue *enumValue : enumValues) {
-        if (enumTypeEntry->isEnumValueRejected(enumValue->name()))
+    for (const AbstractMetaEnumValue &enumValue : cppEnum.values()) {
+        if (enumTypeEntry->isEnumValueRejected(enumValue.name()))
             continue;
 
         QString enumValueText;
-        if (!avoidProtectedHack() || !cppEnum->isProtected()) {
+        if (!avoidProtectedHack() || !cppEnum.isProtected()) {
             enumValueText = QLatin1String("(long) ");
-            if (cppEnum->enclosingClass())
-                enumValueText += cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::");
+            if (cppEnum.enclosingClass())
+                enumValueText += cppEnum.enclosingClass()->qualifiedCppName() + QLatin1String("::");
             // Fully qualify the value which is required for C++ 11 enum classes.
-            if (!cppEnum->isAnonymous())
-                enumValueText += cppEnum->name() + QLatin1String("::");
-            enumValueText += enumValue->name();
+            if (!cppEnum.isAnonymous())
+                enumValueText += cppEnum.name() + QLatin1String("::");
+            enumValueText += enumValue.name();
         } else {
-            enumValueText += enumValue->value().toString();
+            enumValueText += enumValue.value().toString();
         }
 
-        switch (cppEnum->enumKind()) {
+        const QString mangledName = mangleName(enumValue.name());
+        switch (cppEnum.enumKind()) {
         case AnonymousEnum:
             if (enclosingClass || hasUpperEnclosingClass) {
                 s << INDENT << "{\n";
@@ -5030,7 +5032,7 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
                     Indentation indent(INDENT);
                     s << INDENT << "PyObject *anonEnumItem = PyInt_FromLong(" << enumValueText << ");\n";
                     s << INDENT << "if (PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(reinterpret_cast<SbkObjectType *>(" << enclosingObjectVariable
-                        << "))->tp_dict, \"" << mangleName(enumValue->name()) << "\", anonEnumItem) < 0)\n";
+                        << "))->tp_dict, \"" << mangledName << "\", anonEnumItem) < 0)\n";
                     {
                         Indentation indent(INDENT);
                         s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl;
@@ -5039,7 +5041,7 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
                 }
                 s << INDENT << "}\n";
             } else {
-                s << INDENT << "if (PyModule_AddIntConstant(module, \"" << mangleName(enumValue->name()) << "\", ";
+                s << INDENT << "if (PyModule_AddIntConstant(module, \"" << mangledName << "\", ";
                 s << enumValueText << ") < 0)\n";
                 {
                     Indentation indent(INDENT);
@@ -5052,7 +5054,7 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
             s << ((enclosingClass || hasUpperEnclosingClass) ? "createScopedEnumItem" : "createGlobalEnumItem");
             s << '(' << enumVarTypeObj << ',' << Qt::endl;
             Indentation indent(INDENT);
-            s << INDENT << enclosingObjectVariable << ", \"" << mangleName(enumValue->name()) << "\", ";
+            s << INDENT << enclosingObjectVariable << ", \"" << mangledName << "\", ";
             s << enumValueText << "))\n";
             s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl;
         }
@@ -5061,7 +5063,7 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
             s << INDENT << "if (!Shiboken::Enum::createScopedEnumItem("
                 << enumVarTypeObj << ',' << Qt::endl;
             Indentation indent(INDENT);
-            s << INDENT << enumVarTypeObj<< ", \"" << mangleName(enumValue->name()) << "\", "
+            s << INDENT << enumVarTypeObj<< ", \"" << mangledName << "\", "
                << enumValueText << "))\n"
                << INDENT << returnStatement(m_currentErrorCode) << Qt::endl;
         }
@@ -5071,8 +5073,8 @@ void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnu
 
     writeEnumConverterInitialization(s, cppEnum);
 
-    s << INDENT << "// End of '" << cppEnum->name() << "' enum";
-    if (cppEnum->typeEntry()->flags())
+    s << INDENT << "// End of '" << cppEnum.name() << "' enum";
+    if (cppEnum.typeEntry()->flags())
         s << "/flags";
     s << '.' << Qt::endl << Qt::endl;
 }
@@ -5103,9 +5105,9 @@ void CppGenerator::writeSignalInitialization(QTextStream &s, const AbstractMetaC
                 << metaClass->qualifiedCppName() << "::staticMetaObject);\n";
 }
 
-void CppGenerator::writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void CppGenerator::writeFlagsToLong(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
-    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags();
     if (!flagsEntry)
         return;
     s << "static PyObject *" << cpythonEnumName(cppEnum) << "_long(PyObject *self)\n";
@@ -5117,9 +5119,9 @@ void CppGenerator::writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppE
     s << "}\n";
 }
 
-void CppGenerator::writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void CppGenerator::writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
-    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags();
     if (!flagsEntry)
         return;
     s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject *self)\n";
@@ -5132,7 +5134,7 @@ void CppGenerator::writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cpp
     s << "}\n";
 }
 
-void CppGenerator::writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void CppGenerator::writeFlagsMethods(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
     writeFlagsBinaryOperator(s, cppEnum, QLatin1String("and"), QLatin1String("&"));
     writeFlagsBinaryOperator(s, cppEnum, QLatin1String("or"), QLatin1String("|"));
@@ -5145,7 +5147,7 @@ void CppGenerator::writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cpp
     s << Qt::endl;
 }
 
-void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
     QString cpythonName = cpythonEnumName(cppEnum);
 
@@ -5163,8 +5165,8 @@ void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream &s, const Abstr
 
 void CppGenerator::writeFlagsNumberMethodsDefinitions(QTextStream &s, const AbstractMetaEnumList &enums)
 {
-    for (AbstractMetaEnum *e : enums) {
-        if (!e->isAnonymous() && !e->isPrivate() && e->typeEntry()->flags()) {
+    for (const AbstractMetaEnum &e : enums) {
+        if (!e.isAnonymous() && !e.isPrivate() && e.typeEntry()->flags()) {
             writeFlagsMethods(s, e);
             writeFlagsNumberMethodsDefinition(s, e);
             s << '\n';
@@ -5172,10 +5174,10 @@ void CppGenerator::writeFlagsNumberMethodsDefinitions(QTextStream &s, const Abst
     }
 }
 
-void CppGenerator::writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
+void CppGenerator::writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum &cppEnum,
                                             const QString &pyOpName, const QString &cppOpName)
 {
-    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags();
     Q_ASSERT(flagsEntry);
 
     s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName
@@ -5194,11 +5196,11 @@ void CppGenerator::writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEn
     s<< "}\n\n";
 }
 
-void CppGenerator::writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
+void CppGenerator::writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum &cppEnum,
                                            const QString &pyOpName,
                                            const QString &cppOpName, bool boolResult)
 {
-    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum.typeEntry()->flags();
     Q_ASSERT(flagsEntry);
 
     s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName
@@ -5528,13 +5530,15 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, const Generat
         }
     }
 
-    for (AbstractMetaEnum *metaEnum : metaClass->enums()) {
-        if (!metaEnum->isPrivate() && !metaEnum->isAnonymous()) {
-            for (const QString &name : qAsConst(nameVariants))
-                s << INDENT << "qRegisterMetaType< ::" << metaEnum->typeEntry()->qualifiedCppName() << " >(\"" << name << "::" << metaEnum->name() << "\");\n";
-
-            if (metaEnum->typeEntry()->flags()) {
-                QString n = metaEnum->typeEntry()->flags()->originalName();
+    for (const AbstractMetaEnum &metaEnum : metaClass->enums()) {
+        if (!metaEnum.isPrivate() && !metaEnum.isAnonymous()) {
+            for (const QString &name : qAsConst(nameVariants)) {
+                s << INDENT << "qRegisterMetaType< ::"
+                    << metaEnum.typeEntry()->qualifiedCppName() << " >(\""
+                    << name << "::" << metaEnum.name() << "\");\n";
+            }
+            if (metaEnum.typeEntry()->flags()) {
+                QString n = metaEnum.typeEntry()->flags()->originalName();
                 s << INDENT << "qRegisterMetaType< ::" << n << " >(\"" << n << "\");\n";
             }
         }
@@ -5944,8 +5948,8 @@ bool CppGenerator::finishGeneration()
     //Extra includes
     s << Qt::endl << "// Extra includes\n";
     QVector<Include> extraIncludes = moduleEntry->extraIncludes();
-    for (AbstractMetaEnum *cppEnum : qAsConst(globalEnums))
-        extraIncludes.append(cppEnum->typeEntry()->extraIncludes());
+    for (const AbstractMetaEnum &cppEnum : qAsConst(globalEnums))
+        extraIncludes.append(cppEnum.typeEntry()->extraIncludes());
     std::sort(extraIncludes.begin(), extraIncludes.end());
     for (const Include &inc : qAsConst(extraIncludes))
         s << inc;
@@ -5996,8 +6000,8 @@ bool CppGenerator::finishGeneration()
 
         s << "// Enum definitions ";
         s << "------------------------------------------------------------\n";
-        for (const AbstractMetaEnum *cppEnum : qAsConst(globalEnums)) {
-            if (cppEnum->isAnonymous() || cppEnum->isPrivate())
+        for (const AbstractMetaEnum &cppEnum : qAsConst(globalEnums)) {
+            if (cppEnum.isAnonymous() || cppEnum.isPrivate())
                 continue;
             writeEnumConverterFunctions(s, cppEnum);
             s << Qt::endl;
@@ -6199,9 +6203,10 @@ bool CppGenerator::finishGeneration()
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode);
 
     if (usePySideExtensions()) {
-        for (AbstractMetaEnum *metaEnum : qAsConst(globalEnums))
-            if (!metaEnum->isAnonymous()) {
-                s << INDENT << "qRegisterMetaType< ::" << metaEnum->typeEntry()->qualifiedCppName() << " >(\"" << metaEnum->name() << "\");\n";
+        for (const AbstractMetaEnum &metaEnum : qAsConst(globalEnums))
+            if (!metaEnum.isAnonymous()) {
+                s << INDENT << "qRegisterMetaType< ::" << metaEnum.typeEntry()->qualifiedCppName()
+                  << " >(\"" << metaEnum.name() << "\");\n";
             }
 
         // cleanup staticMetaObject attribute
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h
index b4b7f1a29..5073f8524 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.h
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.h
@@ -71,7 +71,7 @@ private:
     void writeMetaCast(QTextStream &s, const GeneratorContext &classContext);
 
     void writeEnumConverterFunctions(QTextStream &s, const TypeEntry *enumType);
-    void writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum *metaEnum);
+    void writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum &metaEnum);
     void writeConverterFunctions(QTextStream &s, const AbstractMetaClass *metaClass,
                                  const GeneratorContext &classContext);
     void writeCustomConverterFunctions(QTextStream &s, const CustomConversion *customConversion);
@@ -310,18 +310,18 @@ private:
     void writeRichCompareFunction(QTextStream &s, const GeneratorContext &context);
 
     void writeEnumsInitialization(QTextStream &s, AbstractMetaEnumList &enums);
-    void writeEnumInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum);
+    void writeEnumInitialization(QTextStream &s, const AbstractMetaEnum &metaEnum);
 
     void writeSignalInitialization(QTextStream &s, const AbstractMetaClass *metaClass);
 
-    void writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cppEnum);
-    void writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppEnum);
-    void writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cppEnum);
-    void writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeFlagsMethods(QTextStream &s, const AbstractMetaEnum &cppEnum);
+    void writeFlagsToLong(QTextStream &s, const AbstractMetaEnum &cppEnum);
+    void writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum &cppEnum);
+    void writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum &cppEnum);
     void writeFlagsNumberMethodsDefinitions(QTextStream &s, const AbstractMetaEnumList &enums);
-    void writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
+    void writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum &cppEnum,
                                   const QString &pyOpName, const QString &cppOpName);
-    void writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
+    void writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum &cppEnum,
                                  const QString &pyOpName, const QString &cppOpName,
                                  bool boolResult = false);
 
@@ -332,7 +332,7 @@ private:
 
     void writePrimitiveConverterInitialization(QTextStream &s, const CustomConversion *customConversion);
     void writeEnumConverterInitialization(QTextStream &s, const TypeEntry *enumType);
-    void writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum);
+    void writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum &metaEnum);
     void writeContainerConverterInitialization(QTextStream &s, const AbstractMetaType &type);
     void writeSmartPointerConverterInitialization(QTextStream &s, const AbstractMetaType &ype);
     void writeExtendedConverterInitialization(QTextStream &s, const TypeEntry *externalType, const QVector<const AbstractMetaClass *>& conversions);
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp
index 83f42f687..19fac6b0f 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp
@@ -352,9 +352,9 @@ void HeaderGenerator::writeTypeIndexValueLines(QTextStream &s, const AbstractMet
     if (!typeEntry->generateCode())
         return;
     // enum indices are required for invisible namespaces as well.
-    for (const AbstractMetaEnum *metaEnum : metaClass->enums()) {
-        if (!metaEnum->isPrivate())
-            writeTypeIndexValueLine(s, metaEnum->typeEntry());
+    for (const AbstractMetaEnum &metaEnum : metaClass->enums()) {
+        if (!metaEnum.isPrivate())
+            writeTypeIndexValueLine(s, metaEnum.typeEntry());
     }
     if (NamespaceTypeEntry::isVisibleScope(typeEntry))
         writeTypeIndexValueLine(s, metaClass->typeEntry());
@@ -418,8 +418,8 @@ bool HeaderGenerator::finishGeneration()
     for (const AbstractMetaClass *metaClass : classList)
         writeTypeIndexValueLines(macrosStream, metaClass);
 
-    for (const AbstractMetaEnum *metaEnum : globalEnums())
-        writeTypeIndexValueLine(macrosStream, metaEnum->typeEntry());
+    for (const AbstractMetaEnum &metaEnum : globalEnums())
+        writeTypeIndexValueLine(macrosStream, metaEnum.typeEntry());
 
     // Write the smart pointer define indexes.
     int smartPointerCountIndex = getMaxTypeIndex();
@@ -493,9 +493,9 @@ bool HeaderGenerator::finishGeneration()
         typeFunctions << "QT_WARNING_PUSH\n";
         typeFunctions << "QT_WARNING_DISABLE_DEPRECATED\n";
     }
-    for (const AbstractMetaEnum *cppEnum : globalEnums()) {
-        if (!cppEnum->isAnonymous()) {
-            includes << cppEnum->typeEntry()->include();
+    for (const AbstractMetaEnum &cppEnum : globalEnums()) {
+        if (!cppEnum.isAnonymous()) {
+            includes << cppEnum.typeEntry()->include();
             writeSbkTypeFunction(typeFunctions, cppEnum);
         }
     }
@@ -508,10 +508,10 @@ bool HeaderGenerator::finishGeneration()
         const TypeEntry *classType = metaClass->typeEntry();
         includes << classType->include();
 
-        for (const AbstractMetaEnum *cppEnum : metaClass->enums()) {
-            if (cppEnum->isAnonymous() || cppEnum->isPrivate())
+        for (const AbstractMetaEnum &cppEnum : metaClass->enums()) {
+            if (cppEnum.isAnonymous() || cppEnum.isPrivate())
                 continue;
-            EnumTypeEntry *enumType = cppEnum->typeEntry();
+            EnumTypeEntry *enumType = cppEnum.typeEntry();
             includes << enumType->include();
             writeProtectedEnumSurrogate(protEnumsSurrogates, cppEnum);
             writeSbkTypeFunction(typeFunctions, cppEnum);
@@ -597,27 +597,22 @@ bool HeaderGenerator::finishGeneration()
     return file.done() != FileOut::Failure;
 }
 
-void HeaderGenerator::writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void HeaderGenerator::writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
-    if (avoidProtectedHack() && cppEnum->isProtected())
+    if (avoidProtectedHack() && cppEnum.isProtected())
         s << "enum " << protectedEnumSurrogateName(cppEnum) << " {};\n";
 }
 
-void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum *cppEnum)
+void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum &cppEnum)
 {
-    QString enumName;
-    if (avoidProtectedHack() && cppEnum->isProtected()) {
-        enumName = protectedEnumSurrogateName(cppEnum);
-    } else {
-        enumName = cppEnum->name();
-        if (cppEnum->enclosingClass())
-            enumName = cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::") + enumName;
-    }
+     const QString enumName = avoidProtectedHack() && cppEnum.isProtected()
+        ? protectedEnumSurrogateName(cppEnum)
+        : cppEnum.qualifiedCppName();
 
     s << "template<> inline PyTypeObject *SbkType< ::" << enumName << " >() ";
-    s << "{ return " << cpythonTypeNameExt(cppEnum->typeEntry()) << "; }\n";
+    s << "{ return " << cpythonTypeNameExt(cppEnum.typeEntry()) << "; }\n";
 
-    FlagsTypeEntry *flag = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flag = cppEnum.typeEntry()->flags();
     if (flag) {
         s <<  "template<> inline PyTypeObject *SbkType< ::" << flag->name() << " >() "
           << "{ return " << cpythonTypeNameExt(flag) << "; }\n";
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h
index 3678a5e1f..70a88af40 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.h
+++ b/sources/shiboken6/generator/shiboken/headergenerator.h
@@ -55,12 +55,12 @@ private:
     void writeCopyCtor(QTextStream &s, const AbstractMetaClass *metaClass) const;
     void writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField &field) const;
     void writeFunction(QTextStream &s, const AbstractMetaFunction *func);
-    void writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum &cppEnum);
     void writeSbkTypeFunction(QTextStream &s, const AbstractMetaClass *cppClass);
     void writeSbkTypeFunction(QTextStream &s, const AbstractMetaType &metaType);
     void writeTypeIndexValueLine(QTextStream &s, const TypeEntry *typeEntry);
     void writeTypeIndexValueLines(QTextStream &s, const AbstractMetaClass *metaClass);
-    void writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum &cppEnum);
     void writeInheritedOverloads(QTextStream &s);
 
     QSet<const AbstractMetaFunction *> m_inheritedOverloads;
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 328ca3a08..dd996d15a 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -113,15 +113,15 @@ static QString resolveScopePrefix(const AbstractMetaClass *scope, const QString
         : QString();
 }
 
-static QString resolveScopePrefix(const AbstractMetaEnum *metaEnum,
+static QString resolveScopePrefix(const AbstractMetaEnum &metaEnum,
                                   const QString &value)
 {
     QStringList parts;
-    if (const AbstractMetaClass *scope = metaEnum->enclosingClass())
+    if (const AbstractMetaClass *scope = metaEnum.enclosingClass())
         parts.append(splitClassScope(scope));
     // Fully qualify the value which is required for C++ 11 enum classes.
-    if (!metaEnum->isAnonymous())
-        parts.append(metaEnum->name());
+    if (!metaEnum.isAnonymous())
+        parts.append(metaEnum.name());
     return resolveScopePrefix(parts, value);
 }
 
@@ -294,9 +294,9 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType
         return translateTypeForWrapperMethod(*cType.arrayElementType(), context, options) + QLatin1String("[]");
 
     if (avoidProtectedHack() && cType.isEnum()) {
-        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(cType);
+        auto metaEnum = findAbstractMetaEnum(cType);
         if (metaEnum && metaEnum->isProtected())
-            return protectedEnumSurrogateName(metaEnum);
+            return protectedEnumSurrogateName(metaEnum.value());
     }
 
     return translateType(cType, context, options);
@@ -387,9 +387,12 @@ QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunction *fu
     return funcName;
 }
 
-QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum)
+QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum &metaEnum)
 {
-    return metaEnum->fullName().replace(QLatin1Char('.'), QLatin1Char('_')).replace(QLatin1String("::"), QLatin1String("_")) + QLatin1String("_Surrogate");
+    QString result = metaEnum.fullName();
+    result.replace(QLatin1Char('.'), QLatin1Char('_'));
+    result.replace(QLatin1String("::"), QLatin1String("_"));
+    return result + QLatin1String("_Surrogate");
 }
 
 QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField &field)
@@ -496,9 +499,9 @@ static QString searchForEnumScope(const AbstractMetaClass *metaClass, const QStr
 {
     if (!metaClass)
         return QString();
-    const AbstractMetaEnumList &enums = metaClass->enums();
-    for (const AbstractMetaEnum *metaEnum : enums) {
-        if (metaEnum->findEnumValue(value))
+    for (const AbstractMetaEnum &metaEnum : metaClass->enums()) {
+        auto v = metaEnum.findEnumValue(value);
+        if (v.has_value())
             return resolveScopePrefix(metaEnum, value);
     }
     // PYSIDE-331: We need to also search the base classes.
@@ -595,8 +598,9 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction
 
     QString prefix;
     if (arg.type().isEnum()) {
-        if (const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(arg.type()))
-            prefix = resolveScopePrefix(metaEnum, value);
+        auto metaEnum = findAbstractMetaEnum(arg.type());
+        if (metaEnum.has_value())
+            prefix = resolveScopePrefix(metaEnum.value(), value);
     } else if (arg.type().isFlags()) {
         value = guessScopeForDefaultFlagsValue(func, arg, value);
     } else if (arg.type().typeEntry()->isValue()) {
@@ -641,9 +645,9 @@ QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry *enumEntry)
     return cpythonEnumFlagsName(p, enumEntry->qualifiedCppName());
 }
 
-QString ShibokenGenerator::cpythonEnumName(const AbstractMetaEnum *metaEnum)
+QString ShibokenGenerator::cpythonEnumName(const AbstractMetaEnum &metaEnum)
 {
-    return cpythonEnumName(metaEnum->typeEntry());
+    return cpythonEnumName(metaEnum.typeEntry());
 }
 
 QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry *flagsEntry)
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h
index 0fc872848..91ddf8886 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.h
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h
@@ -239,7 +239,7 @@ protected:
 
     bool wrapperDiagnostics() const { return m_wrapperDiagnostics; }
 
-    static QString protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum);
+    static QString protectedEnumSurrogateName(const AbstractMetaEnum &metaEnum);
     static QString protectedFieldGetterName(const AbstractMetaField &field);
     static QString protectedFieldSetterName(const AbstractMetaField &field);
 
@@ -362,7 +362,7 @@ protected:
                                            const QString &value) const;
 
     static QString cpythonEnumName(const EnumTypeEntry *enumEntry);
-    static QString cpythonEnumName(const AbstractMetaEnum *metaEnum);
+    static QString cpythonEnumName(const AbstractMetaEnum &metaEnum);
 
     static QString cpythonFlagsName(const FlagsTypeEntry *flagsEntry);
     static QString cpythonFlagsName(const AbstractMetaEnum *metaEnum);