shiboken6: Port AbstractMetaField to use QSharedDataPointer

Fold AbstractMetaVariable into AbstractMetaField and use a
QSharedDataPointer for it. Change the client code to store it by value.
For the find() and traverseField() functions, use a std::optional to
replace the pointer.

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

21 files changed, 232 insertions, 201 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetaattributes.h b/sources/shiboken6/ApiExtractor/abstractmetaattributes.h
index c48fd1b3d..06d5e2372 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetaattributes.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetaattributes.h
@@ -37,8 +37,6 @@ class AbstractMetaAttributes
 {
     Q_GADGET
 public:
-    Q_DISABLE_COPY(AbstractMetaAttributes)
-
     AbstractMetaAttributes();
     virtual ~AbstractMetaAttributes();
 
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 9324ac56f..d84aa0f37 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -1125,30 +1125,31 @@ static inline QString qualifiedFieldSignatureWithType(const QString &className,
     return className + colonColon() + fieldSignatureWithType(field);
 }
 
-AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(const VariableModelItem &field,
-                                                             AbstractMetaClass *cls)
+std::optional<AbstractMetaField>
+    AbstractMetaBuilderPrivate::traverseField(const VariableModelItem &field,
+                                              AbstractMetaClass *cls)
 {
     QString fieldName = field->name();
     QString className = cls->typeEntry()->qualifiedCppName();
 
     // Ignore friend decl.
     if (field->isFriend())
-        return nullptr;
+        return {};
 
     if (field->accessPolicy() == CodeModel::Private)
-        return nullptr;
+        return {};
 
     QString rejectReason;
     if (TypeDatabase::instance()->isFieldRejected(className, fieldName, &rejectReason)) {
         m_rejectedFields.insert(qualifiedFieldSignatureWithType(className, field) + rejectReason,
                                 AbstractMetaBuilder::GenerationDisabled);
-        return nullptr;
+        return {};
     }
 
 
-    auto *metaField = new AbstractMetaField;
-    metaField->setName(fieldName);
-    metaField->setEnclosingClass(cls);
+    AbstractMetaField metaField;
+    metaField.setName(fieldName);
+    metaField.setEnclosingClass(cls);
 
     TypeInfo fieldType = field->type();
     AbstractMetaType metaType = translateType(fieldType, cls);
@@ -1159,11 +1160,10 @@ AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(const VariableModel
              qCWarning(lcShiboken, "%s",
                        qPrintable(msgSkippingField(field, cls->name(), type)));
         }
-        delete metaField;
-        return nullptr;
+        return {};
     }
 
-    metaField->setType(metaType);
+    metaField.setType(metaType);
 
     AbstractMetaAttributes::Attributes attr;
     if (field->isStatic())
@@ -1176,7 +1176,7 @@ AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(const VariableModel
         attr |= AbstractMetaAttributes::Protected;
     else
         attr |= AbstractMetaAttributes::Private;
-    metaField->setAttributes(attr);
+    metaField.setAttributes(attr);
 
     return metaField;
 }
@@ -1186,11 +1186,10 @@ void AbstractMetaBuilderPrivate::traverseFields(const ScopeModelItem &scope_item
 {
     const VariableList &variables = scope_item->variables();
     for (const VariableModelItem &field : variables) {
-        AbstractMetaField *metaField = traverseField(field, metaClass);
-
-        if (metaField && !metaField->isModifiedRemoved()) {
+        auto metaField = traverseField(field, metaClass);
+        if (metaField.has_value() && !metaField->isModifiedRemoved()) {
             metaField->setOriginalAttributes(metaField->attributes());
-            metaClass->addField(metaField);
+            metaClass->addField(*metaField);
         }
     }
 }
@@ -2412,8 +2411,8 @@ QString AbstractMetaBuilderPrivate::fixDefaultValue(const ArgumentModelItem &ite
             // Fix scope if the parameter is a field of the current class
             if (implementingClass) {
                 const AbstractMetaFieldList &fields = implementingClass->fields();
-                for (const AbstractMetaField *field : fields) {
-                    if (defaultMatch.hasMatch() && defaultMatch.captured(2) == field->name()) {
+                for (const AbstractMetaField &field : fields) {
+                    if (defaultMatch.hasMatch() && defaultMatch.captured(2) == field.name()) {
                         expr = defaultMatch.captured(1) + implementingClass->name()
                                + colonColon() + defaultMatch.captured(2) + defaultMatch.captured(3);
                         break;
@@ -2713,22 +2712,22 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub
      // Take copy
     const AbstractMetaFieldList existingSubclassFields = subclass->fields();
     const AbstractMetaFieldList &templateClassFields = templateClass->fields();
-    for (const AbstractMetaField *field : templateClassFields) {
+    for (const AbstractMetaField &field : templateClassFields) {
         // If the field is modified or the instantiation has a field named
         // the same as an existing field we have shadowing, so we need to skip it.
-        if (field->isModifiedRemoved(TypeSystem::All)
-            || field->attributes().testFlag(AbstractMetaAttributes::Static)
-            || AbstractMetaField::find(existingSubclassFields, field->name()) != nullptr) {
+        if (field.isModifiedRemoved(TypeSystem::All)
+            || field.attributes().testFlag(AbstractMetaAttributes::Static)
+            || AbstractMetaField::find(existingSubclassFields, field.name()).has_value()) {
             continue;
         }
 
-        QScopedPointer<AbstractMetaField> f(field->copy());
-        f->setEnclosingClass(subclass);
-        AbstractMetaType fieldType = inheritTemplateType(templateTypes, field->type());
+        AbstractMetaField f = field;
+        f.setEnclosingClass(subclass);
+        AbstractMetaType fieldType = inheritTemplateType(templateTypes, field.type());
         if (!fieldType)
             continue;
-        f->setType(fieldType);
-        subclass->addField(f.take());
+        f.setType(fieldType);
+        subclass->addField(f);
     }
 }
 
@@ -2982,9 +2981,8 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
             }
         }
         // Member fields need to be initialized
-        const AbstractMetaFieldList &fields = clazz->fields();
-        for (AbstractMetaField *field : fields) {
-            addClassDependency(field->type().typeEntry(), clazz, classIndex,
+        for (const AbstractMetaField &field : clazz->fields()) {
+            addClassDependency(field.type().typeEntry(), clazz, classIndex,
                                map, &graph);
         }
     }
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
index eb6f31c70..948593766 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
@@ -41,6 +41,8 @@
 #include <QFileInfo>
 #include <QVector>
 
+#include <optional>
+
 class TypeDatabase;
 
 class AbstractMetaBuilderPrivate
@@ -112,8 +114,8 @@ public:
                                            AbstractMetaClass *metaClass);
     AbstractMetaFunction *traverseFunction(const FunctionModelItem &function,
                                            AbstractMetaClass *currentClass);
-    AbstractMetaField *traverseField(const VariableModelItem &field,
-                                     AbstractMetaClass *cls);
+    std::optional<AbstractMetaField> traverseField(const VariableModelItem &field,
+                                                   AbstractMetaClass *cls);
     void checkFunctionModifications();
     void registerHashFunction(const FunctionModelItem &functionItem,
                               AbstractMetaClass *currentClass);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafield.cpp b/sources/shiboken6/ApiExtractor/abstractmetafield.cpp
index 2b5f42b21..a8f100a13 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafield.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafield.cpp
@@ -28,40 +28,44 @@
 
 #include "abstractmetafield.h"
 #include "abstractmetalang.h"
-#include "abstractmetalang_helpers.h"
+#include "abstractmetatype.h"
+#include "documentation.h"
 #include "modifications.h"
 #include "typesystem.h"
 
 #include <QtCore/QDebug>
 
-AbstractMetaVariable::AbstractMetaVariable() = default;
-
-AbstractMetaVariable::~AbstractMetaVariable() = default;
-
-void AbstractMetaVariable::assignMetaVariable(const AbstractMetaVariable &other)
+class AbstractMetaFieldData : public QSharedData
+{
+public:
+    QString m_originalName;
+    QString m_name;
+    AbstractMetaType m_type;
+    bool m_hasName = false;
+    Documentation m_doc;
+};
+
+AbstractMetaField::AbstractMetaField() : d(new AbstractMetaFieldData)
 {
-    m_originalName = other.m_originalName;
-    m_name = other.m_name;
-    m_type = other.m_type;
-    m_hasName = other.m_hasName;
-    m_doc = other.m_doc;
 }
 
-AbstractMetaField::AbstractMetaField() = default;
+AbstractMetaField::AbstractMetaField(const AbstractMetaField &) = default;
+AbstractMetaField &AbstractMetaField::operator=(const AbstractMetaField &) = default;
+AbstractMetaField::AbstractMetaField(AbstractMetaField &&) = default;
+AbstractMetaField &AbstractMetaField::operator=(AbstractMetaField &&) = default;
+AbstractMetaField::~AbstractMetaField() = default;
 
-AbstractMetaField *AbstractMetaField::copy() const
-{
-    auto *returned = new AbstractMetaField;
-    returned->assignMetaVariable(*this);
-    returned->assignMetaAttributes(*this);
-    returned->setEnclosingClass(nullptr);
-    return returned;
-}
+//    returned->setEnclosingClass(nullptr);
 
-AbstractMetaField *AbstractMetaField::find(const AbstractMetaFieldList &haystack,
-                                           const QString &needle)
+std::optional<AbstractMetaField>
+    AbstractMetaField::find(const AbstractMetaFieldList &haystack,
+                            const QString &needle)
 {
-    return findByName(haystack, needle);
+    for (const auto &f : haystack) {
+        if (f.name() == needle)
+            return f;
+    }
+    return {};
 }
 
 /*******************************************************************************
@@ -81,6 +85,62 @@ bool AbstractMetaField::isModifiedRemoved(int types) const
     return false;
 }
 
+const AbstractMetaType &AbstractMetaField::type() const
+{
+    return d->m_type;
+}
+
+void AbstractMetaField::setType(const AbstractMetaType &type)
+{
+    if (d->m_type != type)
+        d->m_type = type;
+}
+
+QString AbstractMetaField::name() const
+{
+    return d->m_name;
+}
+
+void AbstractMetaField::setName(const QString &name, bool realName)
+{
+    if (d->m_name != name || d->m_hasName != realName) {
+        d->m_name = name;
+        d->m_hasName = realName;
+    }
+}
+
+bool AbstractMetaField::hasName() const
+{
+    return d->m_hasName;
+}
+
+QString AbstractMetaField::qualifiedCppName() const
+{
+    return enclosingClass()->qualifiedCppName() + QLatin1String("::") + d->m_name;
+}
+
+QString AbstractMetaField::originalName() const
+{
+    return d->m_originalName;
+}
+
+void AbstractMetaField::setOriginalName(const QString &name)
+{
+    if (d->m_originalName != name)
+        d->m_originalName = name;
+}
+
+const Documentation &AbstractMetaField::documentation() const
+{
+    return d->m_doc;
+}
+
+void AbstractMetaField::setDocumentation(const Documentation &doc)
+{
+    if (d->m_doc != doc)
+        d->m_doc = doc;
+}
+
 FieldModificationList AbstractMetaField::modifications() const
 {
     const FieldModificationList &mods = enclosingClass()->typeEntry()->fieldModifications();
@@ -95,21 +155,6 @@ FieldModificationList AbstractMetaField::modifications() const
 }
 
 #ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug d, const AbstractMetaVariable *av)
-{
-    QDebugStateSaver saver(d);
-    d.noquote();
-    d.nospace();
-    d << "AbstractMetaVariable(";
-    if (av) {
-        d << av->type().name() << ' ' << av->name();
-    } else {
-        d << '0';
-      }
-    d << ')';
-    return d;
-}
-
 void AbstractMetaField::formatDebug(QDebug &d) const
 {
     AbstractMetaAttributes::formatMetaAttributes(d, attributes());
@@ -129,4 +174,15 @@ QDebug operator<<(QDebug d, const AbstractMetaField *af)
     d << ')';
     return d;
 }
+
+QDebug operator<<(QDebug d, const AbstractMetaField &af)
+{
+    QDebugStateSaver saver(d);
+    d.noquote();
+    d.nospace();
+    d << "AbstractMetaField(";
+    af.formatDebug(d);
+    d << ')';
+    return d;
+}
 #endif // !QT_NO_DEBUG_STREAM
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafield.h b/sources/shiboken6/ApiExtractor/abstractmetafield.h
index 64844cbb7..ccd597471 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafield.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafield.h
@@ -30,78 +30,61 @@
 #define ABSTRACTMETAFIELD_H
 
 #include "abstractmetalang_typedefs.h"
-#include "documentation.h"
 #include "typesystem_enums.h"
 #include "typesystem_typedefs.h"
 #include "abstractmetaattributes.h"
 #include "enclosingclassmixin.h"
-#include "abstractmetatype.h"
-#include "documentation.h"
 
-QT_FORWARD_DECLARE_CLASS(QDebug)
-
-class AbstractMetaVariable
-{
-    Q_DISABLE_COPY(AbstractMetaVariable)
-public:
-    AbstractMetaVariable();
-
-    virtual ~AbstractMetaVariable();
+#include <QtCore/QSharedDataPointer>
 
-    const AbstractMetaType &type() const { return m_type; }
-    void setType(const AbstractMetaType &type) { m_type = type; }
+#include <optional>
 
-    QString name() const { return m_name; }
-    void setName(const QString &name, bool realName = true)
-    {
-        m_name = name;
-        m_hasName = realName;
-    }
-    bool hasName() const { return m_hasName; }
-
-    QString originalName() const { return m_originalName; }
-    void setOriginalName(const QString& name) { m_originalName = name; }
-
-    Documentation documentation() const { return m_doc; }
-    void setDocumentation(const Documentation& doc) { m_doc = doc; }
-
-protected:
-    void assignMetaVariable(const AbstractMetaVariable &other);
-
-private:
-    QString m_originalName;
-    QString m_name;
-    AbstractMetaType m_type;
-    bool m_hasName = false;
-
-    Documentation m_doc;
-};
+QT_FORWARD_DECLARE_CLASS(QDebug)
 
-#ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug d, const AbstractMetaVariable *av);
-#endif
+class Documentation;
+class AbstractMetaFieldData;
 
-class AbstractMetaField : public AbstractMetaVariable, public AbstractMetaAttributes, public EnclosingClassMixin
+class AbstractMetaField : public AbstractMetaAttributes, public EnclosingClassMixin
 {
 public:
     AbstractMetaField();
+    AbstractMetaField(const AbstractMetaField &);
+    AbstractMetaField &operator=(const AbstractMetaField &);
+    AbstractMetaField(AbstractMetaField &&);
+    AbstractMetaField &operator=(AbstractMetaField &&);
+    ~AbstractMetaField();
 
     FieldModificationList modifications() const;
 
     bool isModifiedRemoved(int types = TypeSystem::All) const;
 
-    AbstractMetaField *copy() const;
+    const AbstractMetaType &type() const;
+    void setType(const AbstractMetaType &type);
 
-    static AbstractMetaField *
+    QString name() const;
+    void setName(const QString &name, bool realName = true);
+    bool hasName() const;
+    QString qualifiedCppName() const;
+
+    QString originalName() const;
+    void setOriginalName(const QString& name);
+
+    const Documentation &documentation() const;
+    void setDocumentation(const Documentation& doc);
+
+    static std::optional<AbstractMetaField>
         find(const AbstractMetaFieldList &haystack, const QString &needle);
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const;
 #endif
+private:
+    QSharedDataPointer<AbstractMetaFieldData> d;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d, const AbstractMetaField *af);
+QDebug operator<<(QDebug d, const AbstractMetaField &af);
 #endif
 
 #endif // ABSTRACTMETAFIELD_H
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index 16bf03e11..f5f8412c8 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -65,7 +65,6 @@ AbstractMetaClass::AbstractMetaClass()
 AbstractMetaClass::~AbstractMetaClass()
 {
     qDeleteAll(m_functions);
-    qDeleteAll(m_fields);
     qDeleteAll(m_enums);
     qDeleteAll(m_propertySpecs);
 }
@@ -345,8 +344,8 @@ bool AbstractMetaClass::hasProtectedFunctions() const
 
 bool AbstractMetaClass::hasProtectedFields() const
 {
-    for (const AbstractMetaField *field : m_fields) {
-        if (field->isProtected())
+    for (const AbstractMetaField &field : m_fields) {
+        if (field.isProtected())
             return true;
     }
     return false;
@@ -635,7 +634,8 @@ AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
     return queryFunctions(Signals | Visible | NotRemovedFromTargetLang);
 }
 
-AbstractMetaField *AbstractMetaClass::findField(const QString &name) const
+std::optional<AbstractMetaField>
+    AbstractMetaClass::findField(const QString &name) const
 {
     return AbstractMetaField::find(m_fields, name);
 }
@@ -1067,7 +1067,7 @@ void AbstractMetaClass::formatMembers(QDebug &d) const
         for (int i = 0; i < count; ++i) {
             if (i)
                 d << ", ";
-            m_fields.at(i)->formatDebug(d);
+            m_fields.at(i).formatDebug(d);
         }
         d << ')';
     }
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h
index 51e63a33d..111552432 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 "abstractmetafield.h"
 #include "enclosingclassmixin.h"
 #include "documentation.h"
 #include "sourcelocation.h"
@@ -162,10 +163,11 @@ public:
     bool hasLogicalOperatorOverload() const;
 
     const AbstractMetaFieldList &fields() const { return m_fields; }
+    AbstractMetaFieldList &fields() { return m_fields; }
     void setFields(const AbstractMetaFieldList &fields) { m_fields = fields; }
-    void addField(AbstractMetaField *field) { m_fields << field; }
+    void addField(const AbstractMetaField &field) { m_fields << field; }
 
-    AbstractMetaField *findField(const QString &name) const;
+    std::optional<AbstractMetaField> findField(const QString &name) const;
 
     const AbstractMetaEnumList &enums() const { return m_enums; }
     void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; }
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
index c32a49348..88b96cd8e 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
@@ -44,7 +44,7 @@ using AbstractMetaArgumentList = QVector<AbstractMetaArgument>;
 using AbstractMetaClassList = QVector<AbstractMetaClass *>;
 using AbstractMetaEnumList = QVector<AbstractMetaEnum *>;
 using AbstractMetaEnumValueList = QVector<AbstractMetaEnumValue *>;
-using AbstractMetaFieldList = QVector<AbstractMetaField *>;
+using AbstractMetaFieldList = QList<AbstractMetaField>;
 using AbstractMetaFunctionList = QVector<AbstractMetaFunction *>;
 using AbstractMetaFunctionCList = QVector<const AbstractMetaFunction *>;
 using AbstractMetaTypeList = QVector<AbstractMetaType>;
diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
index b835b7c55..435447133 100644
--- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp
+++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
@@ -181,15 +181,14 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 
     //Fields
-    const AbstractMetaFieldList &fields = metaClass->fields();
-    for (AbstractMetaField *field : fields) {
-        if (field->isPrivate())
+    for (AbstractMetaField &field : metaClass->fields()) {
+        if (field.isPrivate())
             return;
 
         Documentation fieldDoc;
         for (const auto &tag : docTags) {
             QString query = QLatin1String("/doxygen/compounddef/sectiondef/memberdef/name[text()=\"")
-                            + field->name() + QLatin1String("\"]/../") + tag.second;
+                            + field.name() + QLatin1String("\"]/../") + tag.second;
             QString doc = getDocumentation(xquery, query, DocModificationList());
             if (doc.isEmpty()) {
                 qCWarning(lcShibokenDoc, "%s",
@@ -199,7 +198,7 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
                 fieldDoc.setValue(doc, tag.first);
             }
         }
-        field->setDocumentation(fieldDoc);
+        field.setDocumentation(fieldDoc);
     }
 
     //Enums
diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp
index f81f58623..6c8d19601 100644
--- a/sources/shiboken6/ApiExtractor/messages.cpp
+++ b/sources/shiboken6/ApiExtractor/messages.cpp
@@ -431,11 +431,11 @@ QString msgCannotFindDocumentation(const QString &fileName,
 
 QString msgCannotFindDocumentation(const QString &fileName,
                                    const AbstractMetaClass *metaClass,
-                                   const AbstractMetaField *f,
+                                   const AbstractMetaField &f,
                                    const QString &query)
 {
     return msgCannotFindDocumentation(fileName, "field",
-                                      metaClass->name() + QLatin1String("::") + f->name(),
+                                      metaClass->name() + QLatin1String("::") + f.name(),
                                       query);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h
index 8292e491e..54e961237 100644
--- a/sources/shiboken6/ApiExtractor/messages.h
+++ b/sources/shiboken6/ApiExtractor/messages.h
@@ -149,7 +149,7 @@ QString msgCannotFindDocumentation(const QString &fileName,
 
 QString msgCannotFindDocumentation(const QString &fileName,
                                    const AbstractMetaClass *metaClass,
-                                   const AbstractMetaField *f,
+                                   const AbstractMetaField &f,
                                    const QString &query);
 
 QString msgXpathDocModificationError(const DocModificationList& mods,
diff --git a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
index 31a9e84a0..5fb2ff687 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
@@ -53,9 +53,8 @@ void TestRemoveField::testRemoveField()
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->fields().size(), 1);
-    const AbstractMetaField *fieldA = classA->fields().constFirst();
-    QVERIFY(fieldA);
-    QCOMPARE(fieldA->name(), QLatin1String("fieldA"));
+    const AbstractMetaField &fieldA = classA->fields().constFirst();
+    QCOMPARE(fieldA.name(), QLatin1String("fieldA"));
 }
 
 QTEST_APPLESS_MAIN(TestRemoveField)
diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
index 54842a27d..38199a869 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
@@ -585,15 +585,14 @@ void TestTemplates::testTemplateTypeDefs()
     QCOMPARE(xmlValueMethod->type().cppSignature(), QLatin1String("int"));
 
     // Check whether the m_value field is of type 'int'
-    const AbstractMetaField *valueField =
-        optionalInt->findField(QLatin1String("m_value"));
-    QVERIFY(valueField);
+    const auto valueField = optionalInt->findField(QLatin1String("m_value"));
+    QVERIFY(valueField.has_value());
     QCOMPARE(valueField->type().cppSignature(), QLatin1String("int"));
 
     // ditto for typesystem XML
-    const AbstractMetaField *xmlValueField =
+    const auto xmlValueField =
         xmlOptionalInt->findField(QLatin1String("m_value"));
-    QVERIFY(xmlValueField);
+    QVERIFY(xmlValueField.has_value());
     QCOMPARE(xmlValueField->type().cppSignature(), QLatin1String("int"));
 }
 
@@ -636,7 +635,7 @@ public:
 
     auto fields = testClass->fields();
     QCOMPARE(fields.count(), 1);
-    auto fieldType = testClass->fields().at(0)->type();
+    auto fieldType = testClass->fields().at(0).type();
     QCOMPARE(fieldType.name(), QLatin1String("Container1"));
     QCOMPARE(fieldType.instantiations().size(), 1);
 
diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp
index 750d3c3a4..42f53a6ec 100644
--- a/sources/shiboken6/generator/generator.cpp
+++ b/sources/shiboken6/generator/generator.cpp
@@ -312,9 +312,8 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
     const AbstractMetaFunctionList &funcs = metaClass->functions();
     for (const AbstractMetaFunction *func : funcs)
         collectInstantiatedContainersAndSmartPointers(func);
-    const AbstractMetaFieldList &fields = metaClass->fields();
-    for (const AbstractMetaField *field : fields)
-        addInstantiatedContainersAndSmartPointers(field->type(), field->name());
+    for (const AbstractMetaField &field : metaClass->fields())
+        addInstantiatedContainersAndSmartPointers(field.type(), field.name());
     const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
     for (AbstractMetaClass *innerClass : innerClasses)
         collectInstantiatedContainersAndSmartPointers(innerClass);
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index 7feaf5e1f..ec514c460 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -1780,10 +1780,9 @@ void QtDocGenerator::writeFields(QTextStream& s, const AbstractMetaClass* cppCla
 {
     static const QString section_title = QLatin1String(".. attribute:: ");
 
-    const AbstractMetaFieldList &fields = cppClass->fields();
-    for (AbstractMetaField *field : fields) {
-        s << section_title << cppClass->fullName() << "." << field->name() << Qt::endl << Qt::endl;
-        writeFormattedText(s, field->documentation().value(), cppClass);
+    for (const AbstractMetaField &field : cppClass->fields()) {
+        s << section_title << cppClass->fullName() << "." << field.name() << "\n\n";
+        writeFormattedText(s, field.documentation().value(), cppClass);
     }
 }
 
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index bd0bef574..c06f072d1 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -295,9 +295,9 @@ static bool isPointerToConst(const AbstractMetaType &t)
         && indirections.constLast() != Indirection::ConstPointer;
 }
 
-static inline bool canGenerateFieldSetter(const AbstractMetaField *field)
+static inline bool canGenerateFieldSetter(const AbstractMetaField &field)
 {
-    const AbstractMetaType &type = field->type();
+    const AbstractMetaType &type = field.type();
     return !type.isConstant() || isPointerToConst(type);
 }
 
@@ -704,8 +704,8 @@ void CppGenerator::generateClass(QTextStream &s, const GeneratorContext &classCo
 
     if (shouldGenerateGetSetList(metaClass) && !classContext.forSmartPointer()) {
         const AbstractMetaFieldList &fields = metaClass->fields();
-        for (const AbstractMetaField *metaField : fields) {
-            if (metaField->isStatic())
+        for (const AbstractMetaField &metaField : fields) {
+            if (metaField.isStatic())
                 continue;
             writeGetterFunction(s, metaField, classContext);
             if (canGenerateFieldSetter(metaField))
@@ -723,12 +723,12 @@ void CppGenerator::generateClass(QTextStream &s, const GeneratorContext &classCo
 
         s << "// Getters and Setters for " << metaClass->name() << Qt::endl;
         s << "static PyGetSetDef " << cpythonGettersSettersDefinitionName(metaClass) << "[] = {\n";
-        for (const AbstractMetaField *metaField : fields) {
-            if (!metaField->isStatic()) {
+        for (const AbstractMetaField &metaField : fields) {
+            if (!metaField.isStatic()) {
                 s << INDENT;
                 const QString setter = canGenerateFieldSetter(metaField)
                     ? cpythonSetterFunctionName(metaField) : QString();
-                writePyGetSetDefEntry(s, metaField->name(),
+                writePyGetSetDefEntry(s, metaField.name(),
                                       cpythonGetterFunctionName(metaField), setter);
             }
         }
@@ -4070,9 +4070,8 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass)
 
 bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass *metaClass)
 {
-    const AbstractMetaFieldList &fields = metaClass->fields();
-    for (const AbstractMetaField *f : fields) {
-        if (!f->isStatic())
+    for (const AbstractMetaField &f : metaClass->fields()) {
+        if (!f.isStatic())
             return true;
     }
     // Generate all user-added properties unless Pyside extensions are used,
@@ -4517,7 +4516,7 @@ static inline void writeGetterFunctionStart(QTextStream &s, const QString &funcN
 }
 
 void CppGenerator::writeGetterFunction(QTextStream &s,
-                                       const AbstractMetaField *metaField,
+                                       const AbstractMetaField &metaField,
                                        const GeneratorContext &context)
 {
     ErrorCode errorCode(QString::fromLatin1(NULL_PTR));
@@ -4525,17 +4524,17 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
 
     writeCppSelfDefinition(s, context);
 
-    AbstractMetaType fieldType = metaField->type();
+    AbstractMetaType fieldType = metaField.type();
     // Force use of pointer to return internal variable memory
     bool newWrapperSameObject = !fieldType.isConstant() && isWrapperType(fieldType) && !isPointer(fieldType);
 
     QString cppField;
-    if (avoidProtectedHack() && metaField->isProtected()) {
+    if (avoidProtectedHack() && metaField.isProtected()) {
         QTextStream(&cppField) << "static_cast<"
             << context.wrapperName() << " *>("
             << CPP_SELF_VAR << ")->" << protectedFieldGetterName(metaField) << "()";
     } else {
-        cppField = QLatin1String(CPP_SELF_VAR) + QLatin1String("->") + metaField->name();
+        cppField = QLatin1String(CPP_SELF_VAR) + QLatin1String("->") + metaField.name();
         if (newWrapperSameObject) {
             cppField.prepend(QLatin1String("&("));
             cppField.append(QLatin1Char(')'));
@@ -4544,7 +4543,7 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
     if (isCppIntegralPrimitive(fieldType) || fieldType.isEnum()) {
         s << INDENT << getFullTypeNameWithoutModifiers(fieldType) << " cppOut_local = " << cppField << ";\n";
         cppField = QLatin1String("cppOut_local");
-    } else if (avoidProtectedHack() && metaField->isProtected()) {
+    } else if (avoidProtectedHack() && metaField.isProtected()) {
         s << INDENT << getFullTypeNameWithoutModifiers(fieldType);
         if (fieldType.isContainer() || fieldType.isFlags() || fieldType.isSmartPointer()) {
             s << " &";
@@ -4594,7 +4593,7 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
         s << INDENT << "Shiboken::Object::setParent(self, pyOut)";
     } else {
         s << INDENT << "pyOut = ";
-        writeToPythonConversion(s, fieldType, metaField->enclosingClass(), cppField);
+        writeToPythonConversion(s, fieldType, metaField.enclosingClass(), cppField);
     }
     s << ";\n";
 
@@ -4652,18 +4651,18 @@ void CppGenerator::writeSetterFunctionPreamble(QTextStream &s, const QString &na
 }
 
 void CppGenerator::writeSetterFunction(QTextStream &s,
-                                       const AbstractMetaField *metaField,
+                                       const AbstractMetaField &metaField,
                                        const GeneratorContext &context)
 {
     ErrorCode errorCode(0);
 
-    const AbstractMetaType &fieldType = metaField->type();
-    writeSetterFunctionPreamble(s, metaField->name(), cpythonSetterFunctionName(metaField),
+    const AbstractMetaType &fieldType = metaField.type();
+    writeSetterFunctionPreamble(s, metaField.name(), cpythonSetterFunctionName(metaField),
                                 fieldType, context);
 
-    QString cppField = QString::fromLatin1("%1->%2").arg(QLatin1String(CPP_SELF_VAR), metaField->name());
+    QString cppField = QLatin1String(CPP_SELF_VAR) + QLatin1String("->") + metaField.name();
     s << INDENT;
-    if (avoidProtectedHack() && metaField->isProtected()) {
+    if (avoidProtectedHack() && metaField.isProtected()) {
         s << getFullTypeNameWithoutModifiers(fieldType);
         s << (fieldType.indirections() == 1 ? " *" : "") << " cppOut;\n";
         s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut);\n";
@@ -4686,7 +4685,7 @@ void CppGenerator::writeSetterFunction(QTextStream &s,
 
     if (isPointerToWrapperType(fieldType)) {
         s << INDENT << "Shiboken::Object::keepReference(reinterpret_cast<SbkObject *>(self), \"";
-        s << metaField->name() << "\", pyIn);\n";
+        s << metaField.name() << "\", pyIn);\n";
     }
 
     s << INDENT << "return 0;\n";
@@ -5438,12 +5437,12 @@ void CppGenerator::writeClassRegister(QTextStream &s,
 
     // Write static fields
     const AbstractMetaFieldList &fields = metaClass->fields();
-    for (const AbstractMetaField *field : fields) {
-        if (!field->isStatic())
+    for (const AbstractMetaField &field : fields) {
+        if (!field.isStatic())
             continue;
         s << INDENT << QLatin1String("PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(") + cpythonTypeName(metaClass) + QLatin1String(")->tp_dict, \"");
-        s << field->name() << "\", ";
-        writeToPythonConversion(s, field->type(), metaClass, metaClass->qualifiedCppName() + QLatin1String("::") + field->name());
+        s << field.name() << "\", ";
+        writeToPythonConversion(s, field.type(), metaClass, field.qualifiedCppName());
         s << ");\n";
     }
     s << Qt::endl;
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h
index 25d4b22db..b4b7f1a29 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.h
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.h
@@ -290,7 +290,7 @@ private:
     void writeCopyFunction(QTextStream &s, const GeneratorContext &context);
 
     void writeGetterFunction(QTextStream &s,
-                             const AbstractMetaField *metaField,
+                             const AbstractMetaField &metaField,
                              const GeneratorContext &context);
     void writeGetterFunction(QTextStream &s,
                              const QPropertySpec *property,
@@ -301,7 +301,7 @@ private:
                                      const AbstractMetaType &type,
                                      const GeneratorContext &context);
     void writeSetterFunction(QTextStream &s,
-                             const AbstractMetaField *metaField,
+                             const AbstractMetaField &metaField,
                              const GeneratorContext &context);
     void writeSetterFunction(QTextStream &s,
                              const QPropertySpec *property,
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp
index 3d707318c..83f42f687 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp
@@ -69,11 +69,11 @@ void HeaderGenerator::writeCopyCtor(QTextStream &s, const AbstractMetaClass *met
     s << INDENT << "}\n\n";
 }
 
-void HeaderGenerator::writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField *field) const
+void HeaderGenerator::writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField &field) const
 {
-    const AbstractMetaType &metaType = field->type();
+    const AbstractMetaType &metaType = field.type();
     QString fieldType = metaType.cppSignature();
-    QString fieldName = field->enclosingClass()->qualifiedCppName() + QLatin1String("::") + field->name();
+    const QString fieldName = field.qualifiedCppName();
 
     // Force use of pointer to return internal variable memory
     bool useReference = (!metaType.isConstant() &&
@@ -160,9 +160,8 @@ void HeaderGenerator::generateClass(QTextStream &s, const GeneratorContext &clas
             maxOverrides = 1;
 
         if (avoidProtectedHack() && metaClass->hasProtectedFields()) {
-            const AbstractMetaFieldList &fields = metaClass->fields();
-            for (AbstractMetaField *field : fields) {
-                if (!field->isProtected())
+            for (const AbstractMetaField &field : metaClass->fields()) {
+                if (!field.isProtected())
                     continue;
                 writeProtectedFieldAccessors(s, field);
             }
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h
index d02516b8d..3678a5e1f 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.h
+++ b/sources/shiboken6/generator/shiboken/headergenerator.h
@@ -53,7 +53,7 @@ protected:
 
 private:
     void writeCopyCtor(QTextStream &s, const AbstractMetaClass *metaClass) const;
-    void writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField *field) 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 AbstractMetaClass *cppClass);
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index d9733386f..09c9cc501 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -388,14 +388,14 @@ QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum *me
     return metaEnum->fullName().replace(QLatin1Char('.'), QLatin1Char('_')).replace(QLatin1String("::"), QLatin1String("_")) + QLatin1String("_Surrogate");
 }
 
-QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField *field)
+QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField &field)
 {
-    return QStringLiteral("protected_%1_getter").arg(field->name());
+    return QStringLiteral("protected_%1_getter").arg(field.name());
 }
 
-QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField *field)
+QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField &field)
 {
-    return QStringLiteral("protected_%1_setter").arg(field->name());
+    return QStringLiteral("protected_%1_setter").arg(field.name());
 }
 
 QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction *func)
@@ -457,14 +457,14 @@ QString ShibokenGenerator::cpythonSetterFunctionName(const QString &name,
     return cpythonBaseName(enclosingClass) + QStringLiteral("_set_") + name;
 }
 
-QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField *metaField)
+QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField &metaField)
 {
-    return cpythonGetterFunctionName(metaField->name(), metaField->enclosingClass());
+    return cpythonGetterFunctionName(metaField.name(), metaField.enclosingClass());
 }
 
-QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField *metaField)
+QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField &metaField)
 {
-    return cpythonSetterFunctionName(metaField->name(), metaField->enclosingClass());
+    return cpythonSetterFunctionName(metaField.name(), metaField.enclosingClass());
 }
 
 QString ShibokenGenerator::cpythonGetterFunctionName(const QPropertySpec *property,
@@ -608,11 +608,10 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction
         Q_ASSERT(unknowArgumentRegEx.isValid());
         const QRegularExpressionMatch match = unknowArgumentRegEx.match(value);
         if (match.hasMatch() && func->implementingClass()) {
-            const AbstractMetaFieldList &fields = func->implementingClass()->fields();
-            for (const AbstractMetaField *field : fields) {
-                if (match.captured(1).trimmed() == field->name()) {
-                    QString fieldName = field->name();
-                    if (field->isStatic()) {
+            for (const AbstractMetaField &field : func->implementingClass()->fields()) {
+                if (match.captured(1).trimmed() == field.name()) {
+                    QString fieldName = field.name();
+                    if (field.isStatic()) {
                         prefix = resolveScopePrefix(func->implementingClass(), value);
                         fieldName.prepend(prefix);
                         prefix.clear();
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h
index 0d49764ab..d2aaa5b1a 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.h
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h
@@ -240,8 +240,8 @@ protected:
     bool wrapperDiagnostics() const { return m_wrapperDiagnostics; }
 
     static QString protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum);
-    static QString protectedFieldGetterName(const AbstractMetaField *field);
-    static QString protectedFieldSetterName(const AbstractMetaField *field);
+    static QString protectedFieldGetterName(const AbstractMetaField &field);
+    static QString protectedFieldSetterName(const AbstractMetaField &field);
 
     static QString pythonPrimitiveTypeName(const QString &cppTypeName);
     static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry *type);
@@ -343,8 +343,8 @@ protected:
     QString cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass);
     static QString cpythonGetattroFunctionName(const AbstractMetaClass *metaClass);
     static QString cpythonSetattroFunctionName(const AbstractMetaClass *metaClass);
-    static QString cpythonGetterFunctionName(const AbstractMetaField *metaField);
-    static QString cpythonSetterFunctionName(const AbstractMetaField *metaField);
+    static QString cpythonGetterFunctionName(const AbstractMetaField &metaField);
+    static QString cpythonSetterFunctionName(const AbstractMetaField &metaField);
     static QString cpythonGetterFunctionName(const QPropertySpec *property,
                                              const AbstractMetaClass *metaClass);
     static QString cpythonSetterFunctionName(const QPropertySpec *property,