shiboken6: Store AbstractMetaFunction using a QSharedPointer

Store the list functions (global / class member) as a
QList<QSharedPointer<const AbstractMetaFunction> instead of a raw
pointer list. This makes passing around function lists easier and
solves the memory leaks caused by mixing cloned and unmodified
functions while collecting the overload lists in the generators.

- Change the function signatures accordingly
- Add a qSharedPointerConstCast() for non-const access.
- Restructure the traversing of added functions
  in the AbstractMetaBuilder
- Remove some unused typedefs and functions unearthed by
  the change

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

51 files changed, 724 insertions, 760 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 33eb85ace..686a28993 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -72,7 +72,6 @@ AbstractMetaBuilderPrivate::AbstractMetaBuilderPrivate() :
 
 AbstractMetaBuilderPrivate::~AbstractMetaBuilderPrivate()
 {
-    qDeleteAll(m_globalFunctions);
     qDeleteAll(m_templates);
     qDeleteAll(m_smartPointers);
     qDeleteAll(m_metaClasses);
@@ -103,7 +102,7 @@ const AbstractMetaClassList &AbstractMetaBuilder::smartPointers() const
     return d->m_smartPointers;
 }
 
-const AbstractMetaFunctionList &AbstractMetaBuilder::globalFunctions() const
+const AbstractMetaFunctionCList &AbstractMetaBuilder::globalFunctions() const
 {
     return d->m_globalFunctions;
 }
@@ -152,10 +151,9 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
             if (!clazz)
                 continue;
 
-            const AbstractMetaFunctionList functions = clazz->functions();
             bool found = false;
             QStringList possibleSignatures;
-            for (AbstractMetaFunction *function : functions) {
+            for (const auto &function : clazz->functions()) {
                 if (function->implementingClass() == clazz
                     && modification.matches(function->minimalSignature())) {
                     found = true;
@@ -172,7 +170,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
                 qCWarning(lcShiboken).noquote().nospace()
                     << msgNoFunctionForModification(clazz, signature,
                                                     modification.originalSignature(),
-                                                    possibleSignatures, functions);
+                                                    possibleSignatures, clazz->functions());
             }
         }
     }
@@ -290,7 +288,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
             metaFunction->setVisibility(AbstractMetaFunction::Public);
             metaFunction->setOriginalAttributes(metaFunction->attributes());
             setupFunctionDefaults(metaFunction, baseoperandClass);
-            baseoperandClass->addFunction(metaFunction);
+            baseoperandClass->addFunction(AbstractMetaFunctionCPtr(metaFunction));
             Q_ASSERT(!metaFunction->wasPrivate());
         } else {
             delete metaFunction;
@@ -338,7 +336,7 @@ void AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem
                 }
 
                 setupFunctionDefaults(streamFunction, funcClass);
-                funcClass->addFunction(streamFunction);
+                funcClass->addFunction(AbstractMetaFunctionCPtr(streamFunction));
                 if (funcClass == streamClass)
                     funcClass->typeEntry()->addExtraInclude(streamedClass->typeEntry()->include());
                 else
@@ -449,10 +447,9 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
         if (!metaFunc)
             continue;
 
-        if (!funcEntry->hasSignature(metaFunc->minimalSignature())) {
-            delete metaFunc;
+        AbstractMetaFunctionCPtr metaFuncPtr(metaFunc);
+        if (!funcEntry->hasSignature(metaFunc->minimalSignature()))
             continue;
-        }
 
         applyFunctionModifications(metaFunc);
 
@@ -461,7 +458,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
             delete metaFunc->typeEntry();
 
         metaFunc->setTypeEntry(funcEntry);
-        m_globalFunctions << metaFunc;
+        m_globalFunctions << metaFuncPtr;
     }
 
     ReportHandler::startProgress("Fixing class inheritance...");
@@ -509,7 +506,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                 const QStringList &signatures = fte->signatures();
                 for (const QString &signature : signatures) {
                     bool ok = false;
-                    for (AbstractMetaFunction *func : qAsConst(m_globalFunctions)) {
+                    for (const auto &func : qAsConst(m_globalFunctions)) {
                         if (signature == func->minimalSignature()) {
                             ok = true;
                             break;
@@ -612,13 +609,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     // Functions added to the module on the type system.
     const AddedFunctionList &globalUserFunctions = types->globalUserFunctions();
     for (const AddedFunctionPtr &addedFunc : globalUserFunctions) {
-        AbstractMetaFunction *metaFunc = traverseFunction(addedFunc);
-        if (Q_UNLIKELY(!metaFunc)) {
+        if (!traverseAddedGlobalFunction(addedFunc)) {
             qFatal("Unable to traverse added global function \"%s\".",
                    qPrintable(addedFunc->name()));
         }
-        metaFunc->setFunctionType(AbstractMetaFunction::NormalFunction);
-        m_globalFunctions << metaFunc;
     }
 
     m_itemToClass.clear();
@@ -633,7 +627,7 @@ static bool metaEnumLessThan(const AbstractMetaEnum &e1, const AbstractMetaEnum
 static bool metaClassLessThan(const AbstractMetaClass *c1, const AbstractMetaClass *c2)
 { return c1->fullName() < c2->fullName(); }
 
-static bool metaFunctionLessThan(const AbstractMetaFunction *f1, const AbstractMetaFunction *f2)
+static bool metaFunctionLessThan(const AbstractMetaFunctionCPtr &f1, const AbstractMetaFunctionCPtr &f2)
 { return f1->name() < f2->name(); }
 
 bool AbstractMetaBuilder::build(const QByteArrayList &arguments,
@@ -1233,12 +1227,13 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF
     metaFunction->setType(metaType);
 }
 
-AbstractMetaFunctionList AbstractMetaBuilderPrivate::classFunctionList(const ScopeModelItem &scopeItem,
-                                                                       AbstractMetaClass::Attributes *constructorAttributes,
-                                                                       AbstractMetaClass *currentClass)
+AbstractMetaFunctionRawPtrList
+    AbstractMetaBuilderPrivate::classFunctionList(const ScopeModelItem &scopeItem,
+                                                  AbstractMetaClass::Attributes *constructorAttributes,
+                                                  AbstractMetaClass *currentClass)
 {
     *constructorAttributes = {};
-    AbstractMetaFunctionList result;
+    AbstractMetaFunctionRawPtrList result;
     const FunctionList &scopeFunctionList = scopeItem->functions();
     result.reserve(scopeFunctionList.size());
     for (const FunctionModelItem &function : scopeFunctionList) {
@@ -1258,7 +1253,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
                                                    AbstractMetaClass *metaClass)
 {
     AbstractMetaAttributes::Attributes constructorAttributes;
-    const AbstractMetaFunctionList functions =
+    const AbstractMetaFunctionRawPtrList functions =
         classFunctionList(scopeItem, &constructorAttributes, metaClass);
     metaClass->setAttributes(metaClass->attributes() | constructorAttributes);
 
@@ -1325,7 +1320,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
             if (metaFunction->isConversionOperator())
                 fixReturnTypeOfConversionOperator(metaFunction);
 
-            metaClass->addFunction(metaFunction);
+            metaClass->addFunction(AbstractMetaFunctionCPtr(metaFunction));
             applyFunctionModifications(metaFunction);
         } else if (metaFunction->isDestructor()) {
             metaClass->setHasPrivateDestructor(metaFunction->isPrivate());
@@ -1346,7 +1341,7 @@ void AbstractMetaBuilderPrivate::fillAddedFunctions(AbstractMetaClass *metaClass
     // Add the functions added by the typesystem
     const AddedFunctionList &addedFunctions = metaClass->typeEntry()->addedFunctions();
     for (const AddedFunctionPtr &addedFunc : addedFunctions) {
-        if (!traverseFunction(addedFunc, metaClass)) {
+        if (!traverseAddedMemberFunction(addedFunc, metaClass)) {
                 qFatal("Unable to traverse function \"%s\" added to \"%s\".",
                        qPrintable(addedFunc->name()), qPrintable(metaClass->name()));
         }
@@ -1496,13 +1491,19 @@ static void applyDefaultExpressionModifications(const FunctionModificationList &
     }
 }
 
-AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFunctionPtr &addedFunc)
+bool AbstractMetaBuilderPrivate::traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc)
 {
-    return traverseFunction(addedFunc, nullptr);
+    AbstractMetaFunction *metaFunction = traverseAddedFunctionHelper(addedFunc);
+    if (metaFunction == nullptr)
+        return false;
+    metaFunction->setFunctionType(AbstractMetaFunction::NormalFunction);
+    m_globalFunctions << AbstractMetaFunctionCPtr(metaFunction);
+    return true;
 }
 
-AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFunctionPtr &addedFunc,
-                                                                   AbstractMetaClass *metaClass)
+AbstractMetaFunction *
+    AbstractMetaBuilderPrivate::traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc,
+                                                            AbstractMetaClass *metaClass)
 {
     QString errorMessage;
 
@@ -1581,35 +1582,42 @@ AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFu
     if (!metaArguments.isEmpty())
         fixArgumentNames(metaFunction, metaFunction->modifications(metaClass));
 
-    if (metaClass) {
-        const AbstractMetaArgumentList fargs = metaFunction->arguments();
-        if (metaClass->isNamespace())
-            *metaFunction += AbstractMetaFunction::Static;
-        if (metaFunction->name() == metaClass->name()) {
-            metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction);
-            if (fargs.size() == 1) {
-                const TypeEntry *te = fargs.constFirst().type().typeEntry();
-                if (te->isCustom())
-                    metaFunction->setExplicit(true);
-                if (te->name() == metaFunction->name())
-                    metaFunction->setFunctionType(AbstractMetaFunction::CopyConstructorFunction);
-            }
-        } else {
-            auto type = AbstractMetaFunction::NormalFunction;
-            if (metaFunction->name() == QLatin1String("__getattro__"))
-                type = AbstractMetaFunction::GetAttroFunction;
-            else if (metaFunction->name() == QLatin1String("__setattro__"))
-                type = AbstractMetaFunction::SetAttroFunction;
-            metaFunction->setFunctionType(type);
-        }
+    return metaFunction;
+}
+
+bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc,
+                                                             AbstractMetaClass *metaClass)
+{
+    AbstractMetaFunction *metaFunction = traverseAddedFunctionHelper(addedFunc, metaClass);
+    if (metaFunction == nullptr)
+        return false;
 
-        metaFunction->setDeclaringClass(metaClass);
-        metaFunction->setImplementingClass(metaClass);
-        metaClass->addFunction(metaFunction);
-        metaClass->setHasNonPrivateConstructor(true);
+    const AbstractMetaArgumentList fargs = metaFunction->arguments();
+    if (metaClass->isNamespace())
+        *metaFunction += AbstractMetaFunction::Static;
+    if (metaFunction->name() == metaClass->name()) {
+        metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction);
+        if (fargs.size() == 1) {
+            const TypeEntry *te = fargs.constFirst().type().typeEntry();
+            if (te->isCustom())
+                metaFunction->setExplicit(true);
+            if (te->name() == metaFunction->name())
+                metaFunction->setFunctionType(AbstractMetaFunction::CopyConstructorFunction);
+        }
+    } else {
+        auto type = AbstractMetaFunction::NormalFunction;
+        if (metaFunction->name() == QLatin1String("__getattro__"))
+            type = AbstractMetaFunction::GetAttroFunction;
+        else if (metaFunction->name() == QLatin1String("__setattro__"))
+            type = AbstractMetaFunction::SetAttroFunction;
+        metaFunction->setFunctionType(type);
     }
 
-    return metaFunction;
+    metaFunction->setDeclaringClass(metaClass);
+    metaFunction->setImplementingClass(metaClass);
+    metaClass->addFunction(AbstractMetaFunctionCPtr(metaFunction));
+    metaClass->setHasNonPrivateConstructor(true);
+    return true;
 }
 
 void AbstractMetaBuilderPrivate::fixArgumentNames(AbstractMetaFunction *func, const FunctionModificationList &mods)
@@ -2640,10 +2648,10 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub
     }
 
     const auto &templateTypes = subclass->templateBaseClassInstantiations();
-    const AbstractMetaFunctionList existingSubclassFuncs =
+    const AbstractMetaFunctionCList existingSubclassFuncs =
         subclass->functions(); // Take copy
-    const AbstractMetaFunctionList &templateClassFunctions = templateClass->functions();
-    for (const AbstractMetaFunction *function : templateClassFunctions) {
+    const auto &templateClassFunctions = templateClass->functions();
+    for (const auto &function : templateClassFunctions) {
         // If the function is modified or the instantiation has an equally named
         // function we have shadowing, so we need to skip it.
         if (function->isModifiedRemoved(TypeSystem::All)
@@ -2721,7 +2729,7 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub
                       qPrintable(subclass->name()), qPrintable(templateClass->name()),
                       qPrintable(errorMessage));
         }
-        subclass->addFunction(f.release());
+        subclass->addFunction(AbstractMetaFunctionCPtr(f.release()));
     }
 
      // Take copy
@@ -2786,17 +2794,14 @@ void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass,
     }
 }
 
-static AbstractMetaFunction* findCopyCtor(AbstractMetaClass* cls)
+static AbstractMetaFunctionCPtr findCopyCtor(AbstractMetaClass* cls)
 {
-
-    const auto &functions = cls->functions();
-
-    for (AbstractMetaFunction *f : qAsConst(functions)) {
+    for (const auto &f : cls->functions()) {
         const AbstractMetaFunction::FunctionType t = f->functionType();
         if (t == AbstractMetaFunction::CopyConstructorFunction || t == AbstractMetaFunction::AssignmentOperatorFunction)
             return f;
     }
-    return nullptr;
+    return {};
 }
 
 void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls)
@@ -2804,8 +2809,8 @@ void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls)
     bool result = true;
 
     // find copy ctor for the current class
-    AbstractMetaFunction* copyCtor = findCopyCtor(cls);
-    if (copyCtor) { // if exists a copy ctor in this class
+    auto copyCtor = findCopyCtor(cls);
+    if (!copyCtor.isNull()) { // if exists a copy ctor in this class
         result = copyCtor->isPublic();
     } else { // else... lets find one in the parent class
         QQueue<AbstractMetaClass*> baseClasses;
@@ -2829,8 +2834,8 @@ void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls)
 
 void AbstractMetaBuilderPrivate::setupExternalConversion(AbstractMetaClass *cls)
 {
-    const AbstractMetaFunctionList &convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp);
-    for (AbstractMetaFunction *func : convOps) {
+    const auto &convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp);
+    for (const auto &func : convOps) {
         if (func->isModifiedRemoved())
             continue;
         AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, func->type().typeEntry());
@@ -2981,8 +2986,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
                 graph.addEdge(baseIt.value(), classIndex);
         }
 
-        const AbstractMetaFunctionList &functions = clazz->functions();
-        for (AbstractMetaFunction *func : functions) {
+        for (const auto &func : clazz->functions()) {
             const AbstractMetaArgumentList &arguments = func->arguments();
             for (const AbstractMetaArgument &arg : arguments) {
                 // Check methods with default args: If a class is instantiated by value,
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
index 45459a16e..cd9f36ca9 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
@@ -68,7 +68,7 @@ public:
     const AbstractMetaClassList &classes() const;
     const AbstractMetaClassList &templates() const;
     const AbstractMetaClassList &smartPointers() const;
-    const AbstractMetaFunctionList &globalFunctions() const;
+    const AbstractMetaFunctionCList &globalFunctions() const;
     const AbstractMetaEnumList &globalEnums() const;
     std::optional<AbstractMetaEnum> findEnum(const TypeEntry *typeEntry) const;
 
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
index 0fe66fe38..1dc1dd3d7 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
@@ -97,12 +97,9 @@ public:
                                                  const QSet<QString> &enumsDeclarations);
     void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent,
                        const QStringList &enumsDeclarations);
-    AbstractMetaFunctionList classFunctionList(const ScopeModelItem &scopeItem,
-                                               AbstractMetaClass::Attributes *constructorAttributes,
-                                               AbstractMetaClass *currentClass);
-    AbstractMetaFunctionList templateClassFunctionList(const ScopeModelItem &scopeItem,
-                                                       AbstractMetaClass *metaClass,
-                                                       bool *constructorRejected);
+    AbstractMetaFunctionRawPtrList classFunctionList(const ScopeModelItem &scopeItem,
+                                                     AbstractMetaClass::Attributes *constructorAttributes,
+                                                     AbstractMetaClass *currentClass);
     void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent);
     void applyFunctionModifications(AbstractMetaFunction* func);
     void traverseFields(const ScopeModelItem &item, AbstractMetaClass *parent);
@@ -110,9 +107,11 @@ public:
                                 AbstractMetaClass *currentClass);
     void traverseOperatorFunction(const FunctionModelItem &item,
                                   AbstractMetaClass *currentClass);
-    AbstractMetaFunction* traverseFunction(const AddedFunctionPtr &addedFunc);
-    AbstractMetaFunction* traverseFunction(const AddedFunctionPtr &addedFunc,
-                                           AbstractMetaClass *metaClass);
+    AbstractMetaFunction *traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc,
+                                                      AbstractMetaClass *metaClass = nullptr);
+    bool traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc);
+    bool traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc,
+                                     AbstractMetaClass *metaClass);
     AbstractMetaFunction *traverseFunction(const FunctionModelItem &function,
                                            AbstractMetaClass *currentClass);
     std::optional<AbstractMetaField> traverseField(const VariableModelItem &field,
@@ -193,7 +192,7 @@ public:
     AbstractMetaClassList m_templates;
     AbstractMetaClassList m_smartPointers;
     QHash<const _CodeModelItem *, AbstractMetaClass *> m_itemToClass;
-    AbstractMetaFunctionList m_globalFunctions;
+    AbstractMetaFunctionCList m_globalFunctions;
     AbstractMetaEnumList m_globalEnums;
 
     using RejectMap = QMap<QString, AbstractMetaBuilder::RejectReason>;
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
index 79c542f26..df0ce2a1c 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
@@ -1108,11 +1108,15 @@ QString AbstractMetaFunction::modifiedName() const
     return d->modifiedName(this);
 }
 
-AbstractMetaFunction *
-AbstractMetaFunction::find(const AbstractMetaFunctionList &haystack,
+AbstractMetaFunctionCPtr
+AbstractMetaFunction::find(const AbstractMetaFunctionCList &haystack,
                            const QString &needle)
 {
-    return findByName(haystack, needle);
+    for (const auto &f : haystack) {
+        if (f->name() == needle)
+            return f;
+    }
+    return {};
 }
 
 void AbstractMetaFunction::setAllowThreadModification(TypeSystem::AllowThread am)
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
index 2db47daeb..9628224af 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
@@ -276,8 +276,8 @@ public:
 
     bool isCallOperator() const;
 
-    static AbstractMetaFunction *
-        find(const AbstractMetaFunctionList &haystack, const QString &needle);
+    static AbstractMetaFunctionCPtr
+        find(const AbstractMetaFunctionCList &haystack, const QString &needle);
 
     // for the meta builder only
     void setAllowThreadModification(TypeSystem::AllowThread am);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index bdddfed6e..4b923309e 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -42,7 +42,7 @@
 
 #include <QtCore/QDebug>
 
-bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b)
+bool function_sorter(const AbstractMetaFunctionCPtr &a, const AbstractMetaFunctionCPtr &b)
 {
     return a->signature() < b->signature();
 }
@@ -68,11 +68,6 @@ public:
     {
     }
 
-    ~AbstractMetaClassPrivate()
-    {
-        qDeleteAll(m_functions);
-    }
-
     uint m_hasVirtuals : 1;
     uint m_isPolymorphic : 1;
     uint m_hasNonpublic : 1;
@@ -97,13 +92,13 @@ public:
     AbstractMetaClass *m_extendedNamespace = nullptr;
 
     const AbstractMetaClass *m_templateBaseClass = nullptr;
-    AbstractMetaFunctionList m_functions;
+    AbstractMetaFunctionCList m_functions;
     AbstractMetaFieldList m_fields;
     AbstractMetaEnumList m_enums;
     QList<QPropertySpec> m_propertySpecs;
     AbstractMetaClassList m_innerClasses;
 
-    AbstractMetaFunctionList m_externalConversionOperators;
+    AbstractMetaFunctionCList m_externalConversionOperators;
 
     QStringList m_baseClassNames;  // Base class names from C++, including rejected
     TypeEntries m_templateArgs;
@@ -146,10 +141,10 @@ bool AbstractMetaClass::isPolymorphic() const
 /*******************************************************************************
  * Returns a list of all the functions with a given name
  */
-AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const
+AbstractMetaFunctionCList AbstractMetaClass::queryFunctionsByName(const QString &name) const
 {
-    AbstractMetaFunctionList returned;
-    for (AbstractMetaFunction *function : d->m_functions) {
+    AbstractMetaFunctionCList returned;
+    for (const auto &function : d->m_functions) {
         if (function->name() == name)
             returned.append(function);
     }
@@ -161,7 +156,7 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &
  * Returns a list of all the functions retrieved during parsing which should
  * be added to the API.
  */
-AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
+AbstractMetaFunctionCList AbstractMetaClass::functionsInTargetLang() const
 {
     FunctionQueryOptions default_flags = NormalFunctions | Visible | NotRemovedFromTargetLang;
 
@@ -172,7 +167,7 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
         public_flags |= WasPublic;
 
     // Constructors
-    AbstractMetaFunctionList returned = queryFunctions(Constructors | default_flags | public_flags);
+    AbstractMetaFunctionCList returned = queryFunctions(Constructors | default_flags | public_flags);
 
     // Final functions
     returned += queryFunctions(FinalInTargetLangFunctions | NonStaticFunctions | default_flags | public_flags);
@@ -189,18 +184,18 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
     return returned;
 }
 
-AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
+AbstractMetaFunctionCList AbstractMetaClass::implicitConversions() const
 {
     if (!hasCloneOperator() && !hasExternalConversionOperators())
-        return AbstractMetaFunctionList();
+        return {};
 
-    AbstractMetaFunctionList returned;
-    const AbstractMetaFunctionList list = queryFunctions(Constructors) + externalConversionOperators();
+    AbstractMetaFunctionCList returned;
+    const auto list = queryFunctions(Constructors) + externalConversionOperators();
 
     // Exclude anything that uses rvalue references, be it a move
     // constructor "QPolygon(QPolygon &&)" or something else like
     // "QPolygon(QVector<QPoint> &&)".
-    for (AbstractMetaFunction *f : list) {
+    for (const auto &f : list) {
         if ((f->actualMinimumArgumentCount() == 1 || f->arguments().size() == 1 || f->isConversionOperator())
             && !f->isExplicit()
             && f->functionType() != AbstractMetaFunction::CopyConstructorFunction
@@ -213,11 +208,11 @@ AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
     return returned;
 }
 
-AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptions query) const
+AbstractMetaFunctionCList AbstractMetaClass::operatorOverloads(OperatorQueryOptions query) const
 {
-    const AbstractMetaFunctionList &list = queryFunctions(OperatorOverloads | Visible);
-    AbstractMetaFunctionList returned;
-    for (AbstractMetaFunction *f : list) {
+    const auto &list = queryFunctions(OperatorOverloads | Visible);
+    AbstractMetaFunctionCList returned;
+    for (const auto &f : list) {
         if (((query & ArithmeticOp) && f->isArithmeticOperator())
             || ((query & BitwiseOp) && f->isBitwiseOperator())
             || ((query & ComparisonOp) && f->isComparisonOperator())
@@ -234,7 +229,7 @@ AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptio
 
 bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : d->m_functions) {
+    for (const auto & f: d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isArithmeticOperator() && !f->isPrivate())
             return true;
     }
@@ -243,7 +238,7 @@ bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 
 bool AbstractMetaClass::hasBitwiseOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : d->m_functions) {
+    for (const auto & f: d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isBitwiseOperator() && !f->isPrivate())
             return true;
     }
@@ -252,7 +247,7 @@ bool AbstractMetaClass::hasBitwiseOperatorOverload() const
 
 bool AbstractMetaClass::hasComparisonOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : d->m_functions) {
+    for (const auto &f : d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isComparisonOperator() && !f->isPrivate())
             return true;
     }
@@ -261,7 +256,7 @@ bool AbstractMetaClass::hasComparisonOperatorOverload() const
 
 bool AbstractMetaClass::hasLogicalOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : d->m_functions) {
+    for (const auto &f : d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isLogicalOperator() && !f->isPrivate())
             return true;
     }
@@ -303,20 +298,20 @@ void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClass *cls)
     d->m_templateBaseClass = cls;
 }
 
-const AbstractMetaFunctionList &AbstractMetaClass::functions() const
+const AbstractMetaFunctionCList &AbstractMetaClass::functions() const
 {
     return d->m_functions;
 }
 
-void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
+void AbstractMetaClass::setFunctions(const AbstractMetaFunctionCList &functions)
 {
     d->m_functions = functions;
 
     // Functions must be sorted by name before next loop
     sortFunctions();
 
-    for (AbstractMetaFunction *f : qAsConst(d->m_functions)) {
-        f->setOwnerClass(this);
+    for (const auto &f : qAsConst(d->m_functions)) {
+        qSharedPointerConstCast<AbstractMetaFunction>(f)->setOwnerClass(this);
         if (!f->isPublic())
             d->m_hasNonpublic = true;
     }
@@ -324,8 +319,8 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
 
 bool AbstractMetaClass::hasDefaultToStringFunction() const
 {
-    const AbstractMetaFunctionList &funcs = queryFunctionsByName(QLatin1String("toString"));
-    for (const AbstractMetaFunction *f : funcs) {
+    const auto &funcs = queryFunctionsByName(QLatin1String("toString"));
+    for (const auto &f : funcs) {
         if (!f->actualMinimumArgumentCount())
             return true;
     }
@@ -362,10 +357,10 @@ void AbstractMetaClass::addPropertySpec(const QPropertySpec &spec)
     d->m_propertySpecs << spec;
 }
 
-void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
+void AbstractMetaClass::addFunction(const AbstractMetaFunctionCPtr &function)
 {
     Q_ASSERT(!function->signature().startsWith(QLatin1Char('(')));
-    function->setOwnerClass(this);
+    qSharedPointerConstCast<AbstractMetaFunction>(function)->setOwnerClass(this);
 
     if (!function->isDestructor())
         d->m_functions << function;
@@ -382,7 +377,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
     if (!other->isSignal())
         return false;
 
-    for (const AbstractMetaFunction *f : d->m_functions) {
+    for (const auto &f : d->m_functions) {
         if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName)
             return other->modifiedName() == f->modifiedName();
     }
@@ -535,17 +530,17 @@ QString AbstractMetaClass::qualifiedCppName() const
 
 bool AbstractMetaClass::hasFunction(const QString &str) const
 {
-    return findFunction(str);
+    return !findFunction(str).isNull();
 }
 
-const AbstractMetaFunction *AbstractMetaClass::findFunction(const QString &functionName) const
+AbstractMetaFunctionCPtr AbstractMetaClass::findFunction(const QString &functionName) const
 {
     return AbstractMetaFunction::find(d->m_functions, functionName);
 }
 
 bool AbstractMetaClass::hasProtectedFunctions() const
 {
-    for (AbstractMetaFunction *func : d->m_functions) {
+    for (const auto &func : d->m_functions) {
         if (func->isProtected())
             return true;
     }
@@ -637,12 +632,12 @@ std::optional<QPropertySpec>
     return {};
 }
 
-AbstractMetaFunctionList AbstractMetaClass::externalConversionOperators() const
+const AbstractMetaFunctionCList &AbstractMetaClass::externalConversionOperators() const
 {
     return d->m_externalConversionOperators;
 }
 
-void AbstractMetaClass::addExternalConversionOperator(AbstractMetaFunction *conversionOp)
+void AbstractMetaClass::addExternalConversionOperator(const AbstractMetaFunctionCPtr &conversionOp)
 {
     if (!d->m_externalConversionOperators.contains(conversionOp))
         d->m_externalConversionOperators.append(conversionOp);
@@ -712,27 +707,18 @@ bool AbstractMetaClass::deleteInMainThread() const
             || (!d->m_baseClasses.isEmpty() && d->m_baseClasses.constFirst()->deleteInMainThread());
 }
 
-static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func)
-{
-    for (const AbstractMetaFunction *f : l) {
-        if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar)
-            return true;
-    }
-    return false;
-}
-
 bool AbstractMetaClass::hasConstructors() const
 {
     return AbstractMetaClass::queryFirstFunction(d->m_functions, Constructors) != nullptr;
 }
 
-const AbstractMetaFunction *AbstractMetaClass::copyConstructor() const
+AbstractMetaFunctionCPtr AbstractMetaClass::copyConstructor() const
 {
-    for (const AbstractMetaFunction *f : d->m_functions) {
+    for (const auto &f : d->m_functions) {
         if (f->functionType() == AbstractMetaFunction::CopyConstructorFunction)
             return f;
     }
-    return nullptr;
+    return {};
 }
 
 bool AbstractMetaClass::hasCopyConstructor() const
@@ -742,8 +728,8 @@ bool AbstractMetaClass::hasCopyConstructor() const
 
 bool AbstractMetaClass::hasPrivateCopyConstructor() const
 {
-    const AbstractMetaFunction *copyCt = copyConstructor();
-    return copyCt && copyCt->isPrivate();
+    const auto copyCt = copyConstructor();
+    return !copyCt.isNull() && copyCt->isPrivate();
 }
 
 void AbstractMetaClass::addDefaultConstructor()
@@ -761,7 +747,7 @@ void AbstractMetaClass::addDefaultConstructor()
     f->setImplementingClass(this);
     f->setOriginalAttributes(f->attributes());
 
-    addFunction(f);
+    addFunction(AbstractMetaFunctionCPtr(f));
     this->setHasNonPrivateConstructor(true);
 }
 
@@ -794,7 +780,7 @@ void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate)
     f->setImplementingClass(this);
     f->setOriginalAttributes(f->attributes());
 
-    addFunction(f);
+    addFunction(AbstractMetaFunctionCPtr(f));
 }
 
 bool AbstractMetaClass::hasNonPrivateConstructor() const
@@ -854,11 +840,6 @@ bool AbstractMetaClass::isConstructible() const
     return (hasNonPrivateConstructor() || !hasPrivateConstructor()) && !hasPrivateDestructor();
 }
 
-bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const
-{
-    return functions_contains(d->m_functions, f);
-}
-
 bool AbstractMetaClass::generateExceptionHandling() const
 {
     return queryFirstFunction(d->m_functions, AbstractMetaClass::Visible
@@ -949,29 +930,29 @@ bool AbstractMetaClass::queryFunction(const AbstractMetaFunction *f, FunctionQue
     return true;
 }
 
-AbstractMetaFunctionList AbstractMetaClass::queryFunctionList(const AbstractMetaFunctionList &list,
+AbstractMetaFunctionCList AbstractMetaClass::queryFunctionList(const AbstractMetaFunctionCList &list,
                                                               FunctionQueryOptions query)
 {
-    AbstractMetaFunctionList result;
-    for (AbstractMetaFunction *f : list) {
-        if (queryFunction(f, query))
+    AbstractMetaFunctionCList result;
+    for (const auto &f : list) {
+        if (queryFunction(f.data(), query))
             result.append(f);
     }
     return result;
 }
 
-const AbstractMetaFunction *AbstractMetaClass::queryFirstFunction(const AbstractMetaFunctionList &list,
+AbstractMetaFunctionCPtr AbstractMetaClass::queryFirstFunction(const AbstractMetaFunctionCList &list,
                                                                FunctionQueryOptions query)
 {
-    AbstractMetaFunctionList result;
-    for (AbstractMetaFunction *f : list) {
-        if (queryFunction(f, query))
+    AbstractMetaFunctionCList result;
+    for (const auto &f : list) {
+        if (queryFunction(f.data(), query))
             return f;
     }
-    return nullptr;
+    return {};
 }
 
-AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const
+AbstractMetaFunctionCList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const
 {
     return AbstractMetaClass::queryFunctionList(d->m_functions, query);
 }
@@ -981,7 +962,7 @@ bool AbstractMetaClass::hasSignals() const
     return queryFirstFunction(d->m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr;
 }
 
-AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
+AbstractMetaFunctionCList AbstractMetaClass::cppSignalFunctions() const
 {
     return queryFunctions(Signals | Visible | NotRemovedFromTargetLang);
 }
@@ -1056,7 +1037,7 @@ void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMet
     }
 }
 
-void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionList *funcList) const
+void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionCList *funcList) const
 {
     if (isNamespace()) {
         invisibleNamespaceRecursion([funcList](AbstractMetaClass *c) {
@@ -1088,7 +1069,8 @@ static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractM
     }
 }
 
-static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, const AbstractMetaFunction *meta_function)
+static void addExtraIncludesForFunction(AbstractMetaClass *metaClass,
+                                        const AbstractMetaFunctionCPtr &meta_function)
 {
     Q_ASSERT(metaClass);
     Q_ASSERT(meta_function);
@@ -1106,13 +1088,13 @@ void AbstractMetaClass::fixFunctions()
 
     d->m_functionsFixed = true;
 
-    AbstractMetaFunctionList funcs = functions();
-    AbstractMetaFunctionList nonRemovedFuncs;
+    AbstractMetaFunctionCList funcs = functions();
+    AbstractMetaFunctionCList nonRemovedFuncs;
     nonRemovedFuncs.reserve(funcs.size());
     for (auto f : qAsConst(funcs)) {
         // Fishy: Setting up of implementing/declaring/base classes changes
         // the applicable modifications; clear cached ones.
-        f->clearModificationsCache();
+        qSharedPointerConstCast<AbstractMetaFunction>(f)->clearModificationsCache();
         if (!f->isRemovedFromAllLanguages(f->implementingClass()))
             nonRemovedFuncs.append(f);
     }
@@ -1122,7 +1104,7 @@ void AbstractMetaClass::fixFunctions()
         // Since we always traverse the complete hierarchy we are only
         // interrested in what each super class implements, not what
         // we may have propagated from their base classes again.
-        AbstractMetaFunctionList superFuncs;
+        AbstractMetaFunctionCList superFuncs;
         // Super classes can never be final
         if (superClass->isFinalInTargetLang()) {
             qCWarning(lcShiboken).noquote().nospace()
@@ -1130,11 +1112,11 @@ void AbstractMetaClass::fixFunctions()
             *superClass -= AbstractMetaAttributes::FinalInTargetLang;
         }
         superFuncs = superClass->queryFunctions(AbstractMetaClass::ClassImplements);
-        AbstractMetaFunctionList virtuals = superClass->queryFunctions(AbstractMetaClass::VirtualInCppFunctions);
+        const auto virtuals = superClass->queryFunctions(AbstractMetaClass::VirtualInCppFunctions);
         superFuncs += virtuals;
 
-        QSet<AbstractMetaFunction *> funcsToAdd;
-        for (auto sf : qAsConst(superFuncs)) {
+        QSet<AbstractMetaFunctionCPtr> funcsToAdd;
+        for (const auto &sf : qAsConst(superFuncs)) {
             if (sf->isRemovedFromAllLanguages(sf->implementingClass()))
                 continue;
 
@@ -1145,8 +1127,9 @@ void AbstractMetaClass::fixFunctions()
             // we generally don't care about private functions, but we have to get the ones that are
             // virtual in case they override abstract functions.
             bool add = (sf->isNormal() || sf->isSignal() || sf->isEmptyFunction());
-            for (AbstractMetaFunction *f : qAsConst(nonRemovedFuncs)) {
-                const AbstractMetaFunction::CompareResult cmp = f->compareTo(sf);
+            for (const auto &cf : qAsConst(nonRemovedFuncs)) {
+                AbstractMetaFunctionPtr f(qSharedPointerConstCast<AbstractMetaFunction>(cf));
+                const AbstractMetaFunction::CompareResult cmp = cf->compareTo(sf.data());
 
                 if (cmp & AbstractMetaFunction::EqualModifiedName) {
                     add = false;
@@ -1172,7 +1155,7 @@ void AbstractMetaClass::fixFunctions()
 
                         if (f->visibility() != sf->visibility()) {
                             qCWarning(lcShiboken, "%s",
-                                      qPrintable(msgFunctionVisibilityModified(this, f)));
+                                      qPrintable(msgFunctionVisibilityModified(this, f.data())));
 #if 0
                             // If new visibility is private, we can't
                             // do anything. If it isn't, then we
@@ -1216,7 +1199,7 @@ void AbstractMetaClass::fixFunctions()
 
                                 if (!hasNonFinalModifier && !isBaseImplPrivate) {
                                     qCWarning(lcShiboken, "%s",
-                                              qPrintable(msgShadowingFunction(sf, f)));
+                                              qPrintable(msgShadowingFunction(sf.data(), f.data())));
                                 }
                             }
                         }
@@ -1248,19 +1231,19 @@ void AbstractMetaClass::fixFunctions()
                 funcsToAdd << sf;
         }
 
-        for (AbstractMetaFunction *f : qAsConst(funcsToAdd)) {
+        for (const auto &f : qAsConst(funcsToAdd)) {
             AbstractMetaFunction *copy = f->copy();
             (*copy) += AddedMethod;
-            funcs.append(copy);
+            funcs.append(AbstractMetaFunctionCPtr(copy));
         }
     }
 
     bool hasPrivateConstructors = false;
     bool hasPublicConstructors = false;
-    for (AbstractMetaFunction *func : qAsConst(funcs)) {
+    for (const auto &func : qAsConst(funcs)) {
         for (const auto &mod : func->modifications(this)) {
             if (mod.isRenameModifier())
-                func->setName(mod.renamedToName());
+                qSharedPointerConstCast<AbstractMetaFunction>(func)->setName(mod.renamedToName());
         }
 
         // Make sure class is abstract if one of the functions is
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h
index b72acfe8c..f0c08d673 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h
@@ -99,16 +99,15 @@ public:
 
     void fixFunctions();
 
-    const AbstractMetaFunctionList &functions() const;
-    void setFunctions(const AbstractMetaFunctionList &functions);
-    void addFunction(AbstractMetaFunction *function);
-    bool hasFunction(const AbstractMetaFunction *f) const;
+    const AbstractMetaFunctionCList &functions() const;
+    void setFunctions(const AbstractMetaFunctionCList &functions);
+    void addFunction(const AbstractMetaFunctionCPtr &function);
     bool hasFunction(const QString &str) const;
-    const AbstractMetaFunction* findFunction(const QString& functionName) const;
+    AbstractMetaFunctionCPtr findFunction(const QString& functionName) const;
     bool hasSignal(const AbstractMetaFunction *f) const;
 
     bool hasConstructors() const;
-    const AbstractMetaFunction *copyConstructor() const;
+    AbstractMetaFunctionCPtr copyConstructor() const;
     bool hasCopyConstructor() const;
     bool hasPrivateCopyConstructor() const;
 
@@ -134,17 +133,17 @@ public:
 
     bool generateExceptionHandling() const;
 
-    AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
+    AbstractMetaFunctionCList queryFunctionsByName(const QString &name) const;
     static bool queryFunction(const AbstractMetaFunction *f, FunctionQueryOptions query);
-    static AbstractMetaFunctionList queryFunctionList(const AbstractMetaFunctionList &list,
+    static AbstractMetaFunctionCList queryFunctionList(const AbstractMetaFunctionCList &list,
                                                       FunctionQueryOptions query);
-    static const AbstractMetaFunction *queryFirstFunction(const AbstractMetaFunctionList &list,
-                                                          FunctionQueryOptions query);
+    static AbstractMetaFunctionCPtr queryFirstFunction(const AbstractMetaFunctionCList &list,
+                                                       FunctionQueryOptions query);
 
-    AbstractMetaFunctionList queryFunctions(FunctionQueryOptions query) const;
-    AbstractMetaFunctionList functionsInTargetLang() const;
-    AbstractMetaFunctionList cppSignalFunctions() const;
-    AbstractMetaFunctionList implicitConversions() const;
+    AbstractMetaFunctionCList queryFunctions(FunctionQueryOptions query) const;
+    AbstractMetaFunctionCList functionsInTargetLang() const;
+    AbstractMetaFunctionCList cppSignalFunctions() const;
+    AbstractMetaFunctionCList implicitConversions() const;
 
     /**
      *   Retrieves all class' operator overloads that meet
@@ -154,7 +153,7 @@ public:
      *   /return list of operator overload methods that meet the
      *   query criteria
      */
-    AbstractMetaFunctionList operatorOverloads(OperatorQueryOptions query = AllOperators) const;
+    AbstractMetaFunctionCList operatorOverloads(OperatorQueryOptions query = AllOperators) const;
 
     bool hasArithmeticOperatorOverload() const;
     bool hasBitwiseOperatorOverload() const;
@@ -178,7 +177,7 @@ public:
     void getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const;
     void getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const;
 
-    void getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionList *funcList) const;
+    void getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionCList *funcList) const;
 
     QString fullName() const;
 
@@ -300,9 +299,9 @@ public:
 
     /// Returns a list of conversion operators for this class. The conversion
     /// operators are defined in other classes of the same module.
-    AbstractMetaFunctionList externalConversionOperators() const;
+    const AbstractMetaFunctionCList &externalConversionOperators() const;
     /// Adds a converter operator for this class.
-    void addExternalConversionOperator(AbstractMetaFunction* conversionOp);
+    void addExternalConversionOperator(const AbstractMetaFunctionCPtr &conversionOp);
     /// Returns true if this class has any converter operators defined elsewhere.
     bool hasExternalConversionOperators() const;
 
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
index 91a029c06..66e6e467f 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h
@@ -40,14 +40,17 @@ class AbstractMetaEnumValue;
 class AbstractMetaFunction;
 class AbstractMetaType;
 
+using AbstractMetaFunctionPtr = QSharedPointer<AbstractMetaFunction>;
+using AbstractMetaFunctionCPtr = QSharedPointer<const AbstractMetaFunction>;
+
 using AbstractMetaArgumentList = QList<AbstractMetaArgument>;
 using AbstractMetaClassList = QList<AbstractMetaClass *>;
 using AbstractMetaClassCList = QList<const AbstractMetaClass *>;
 using AbstractMetaEnumList = QList<AbstractMetaEnum>;
 using AbstractMetaEnumValueList = QList<AbstractMetaEnumValue>;
 using AbstractMetaFieldList = QList<AbstractMetaField>;
-using AbstractMetaFunctionList = QList<AbstractMetaFunction *>;
-using AbstractMetaFunctionCList = QList<const AbstractMetaFunction *>;
+using AbstractMetaFunctionRawPtrList = QList<AbstractMetaFunction *>;
+using AbstractMetaFunctionCList = QList<AbstractMetaFunctionCPtr>;
 using AbstractMetaTypeList = QList<AbstractMetaType>;
 
 #endif // ABSTRACTMETALANG_TYPEDEFS_H
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp
index dba0d23da..5e9d18729 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.cpp
+++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp
@@ -128,7 +128,7 @@ const AbstractMetaEnumList &ApiExtractor::globalEnums() const
     return m_builder->globalEnums();
 }
 
-const AbstractMetaFunctionList &ApiExtractor::globalFunctions() const
+const AbstractMetaFunctionCList &ApiExtractor::globalFunctions() const
 {
     Q_ASSERT(m_builder);
     return m_builder->globalFunctions();
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h
index f9a33ae60..856734593 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.h
+++ b/sources/shiboken6/ApiExtractor/apiextractor.h
@@ -83,7 +83,7 @@ public:
     void setLanguageLevel(LanguageLevel languageLevel);
 
     const AbstractMetaEnumList &globalEnums() const;
-    const AbstractMetaFunctionList &globalFunctions() const;
+    const AbstractMetaFunctionCList &globalFunctions() const;
     const AbstractMetaClassList &classes() const;
     const AbstractMetaClassList &smartPointers() const;
     AbstractMetaClassList classesTopologicalSorted(const Dependencies &additionalDependencies = Dependencies()) const;
diff --git a/sources/shiboken6/ApiExtractor/docparser.cpp b/sources/shiboken6/ApiExtractor/docparser.cpp
index 52afbfb84..d2f8a5234 100644
--- a/sources/shiboken6/ApiExtractor/docparser.cpp
+++ b/sources/shiboken6/ApiExtractor/docparser.cpp
@@ -73,7 +73,7 @@ QString DocParser::execXQuery(const XQueryPtr &xquery, const QString& query) con
     return result;
 }
 
-bool DocParser::skipForQuery(const AbstractMetaFunction *func)
+bool DocParser::skipForQuery(const AbstractMetaFunctionCPtr &func)
 {
     // Skip private functions and copies created by AbstractMetaClass::fixFunctions()
     if (!func || func->isPrivate()
@@ -94,9 +94,9 @@ bool DocParser::skipForQuery(const AbstractMetaFunction *func)
     return false;
 }
 
-AbstractMetaFunctionList DocParser::documentableFunctions(const AbstractMetaClass *metaClass)
+AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaClass *metaClass)
 {
-    AbstractMetaFunctionList result = metaClass->functionsInTargetLang();
+    auto result = metaClass->functionsInTargetLang();
     for (int i = result.size() - 1; i >= 0; --i)  {
         if (DocParser::skipForQuery(result.at(i)) || result.at(i)->isUserAdded())
             result.removeAt(i);
diff --git a/sources/shiboken6/ApiExtractor/docparser.h b/sources/shiboken6/ApiExtractor/docparser.h
index 1dccae4d6..37c914b43 100644
--- a/sources/shiboken6/ApiExtractor/docparser.h
+++ b/sources/shiboken6/ApiExtractor/docparser.h
@@ -112,14 +112,14 @@ public:
     */
     virtual Documentation retrieveModuleDocumentation(const QString& name) = 0;
 
-    static bool skipForQuery(const AbstractMetaFunction *func);
+    static bool skipForQuery(const AbstractMetaFunctionCPtr &func);
 
 protected:
     QString getDocumentation(const XQueryPtr &xquery, const QString& query,
                              const DocModificationList& mods) const;
 
 
-    static AbstractMetaFunctionList documentableFunctions(const AbstractMetaClass *metaClass);
+    static AbstractMetaFunctionCList documentableFunctions(const AbstractMetaClass *metaClass);
 
 private:
     QString m_packageName;
diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
index 90afc245c..a731479c3 100644
--- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp
+++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp
@@ -42,7 +42,7 @@
 #include <QtCore/QFile>
 #include <QtCore/QDir>
 
-static QString getSectionKindAttr(const AbstractMetaFunction *func)
+static QString getSectionKindAttr(const AbstractMetaFunctionCPtr &func)
 {
     if (func->isSignal())
         return QLatin1String("signal");
@@ -121,8 +121,8 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     metaClass->setDocumentation(classDoc);
 
     //Functions Documentation
-    const AbstractMetaFunctionList &funcs = DocParser::documentableFunctions(metaClass);
-    for (AbstractMetaFunction *func : funcs) {
+    const auto &funcs = DocParser::documentableFunctions(metaClass);
+    for (const auto &func : funcs) {
         QString query = QLatin1String("/doxygen/compounddef/sectiondef");
         // properties
         if (func->isPropertyReader() || func->isPropertyWriter()
@@ -172,13 +172,13 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
             QString doc = getDocumentation(xquery, funcQuery, DocModificationList());
             if (doc.isEmpty()) {
                 qCWarning(lcShibokenDoc, "%s",
-                          qPrintable(msgCannotFindDocumentation(doxyFilePath, metaClass, func,
+                          qPrintable(msgCannotFindDocumentation(doxyFilePath, metaClass, func.data(),
                                                                 funcQuery)));
             } else {
                 funcDoc.setValue(doc, tag.first);
             }
         }
-        func->setDocumentation(funcDoc);
+        qSharedPointerConstCast<AbstractMetaFunction>(func)->setDocumentation(funcDoc);
         isProperty = false;
     }
 
diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp
index e3ea87f76..5bdd58ae2 100644
--- a/sources/shiboken6/ApiExtractor/messages.cpp
+++ b/sources/shiboken6/ApiExtractor/messages.cpp
@@ -52,7 +52,7 @@ QString msgNoFunctionForModification(const AbstractMetaClass *klass,
                                      const QString &signature,
                                      const QString &originalSignature,
                                      const QStringList &possibleSignatures,
-                                     const AbstractMetaFunctionList &allFunctions)
+                                     const AbstractMetaFunctionCList &allFunctions)
 {
     QString result;
     QTextStream str(&result);
diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h
index d26200abf..21b16a264 100644
--- a/sources/shiboken6/ApiExtractor/messages.h
+++ b/sources/shiboken6/ApiExtractor/messages.h
@@ -64,7 +64,7 @@ QString msgNoFunctionForModification(const AbstractMetaClass *klass,
                                      const QString &signature,
                                      const QString &originalSignature,
                                      const QStringList &possibleSignatures,
-                                     const AbstractMetaFunctionList &allFunctions);
+                                     const AbstractMetaFunctionCList &allFunctions);
 
 QString msgClassOfEnumNotFound(const EnumTypeEntry *entry);
 
diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.cpp b/sources/shiboken6/ApiExtractor/qtdocparser.cpp
index 815532a38..3b5837c95 100644
--- a/sources/shiboken6/ApiExtractor/qtdocparser.cpp
+++ b/sources/shiboken6/ApiExtractor/qtdocparser.cpp
@@ -106,7 +106,7 @@ enum FunctionMatchFlags
 };
 
 static QString functionXQuery(const QString &classQuery,
-                              const AbstractMetaFunction *func,
+                              const AbstractMetaFunctionCPtr &func,
                               unsigned matchFlags = MatchArgumentCount | MatchArgumentType
                                                     | DescriptionOnly)
 {
@@ -165,7 +165,7 @@ static QString msgArgumentCountMatch(const AbstractMetaFunction *func,
 QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
                                                 const AbstractMetaClass* metaClass,
                                                 const QString &classQuery,
-                                                const  AbstractMetaFunction *func,
+                                                const AbstractMetaFunctionCPtr &func,
                                                 const DocModificationList &signedModifs,
                                                 const XQueryPtr &xquery,
                                                 QString *errorMessage)
@@ -182,8 +182,11 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
         const QString propertyQuery = classQuery + QLatin1String("/property[@name=\"")
             + prop.name() + QLatin1String("\"]/description");
         const QString properyDocumentation = getDocumentation(xquery, propertyQuery, funcModifs);
-        if (properyDocumentation.isEmpty())
-            *errorMessage = msgCannotFindDocumentation(sourceFileName, metaClass, func, propertyQuery);
+        if (properyDocumentation.isEmpty()) {
+            *errorMessage =
+                msgCannotFindDocumentation(sourceFileName, metaClass, func.data(),
+                                           propertyQuery);
+        }
         return properyDocumentation;
     }
 
@@ -192,7 +195,7 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
     const QString result = getDocumentation(xquery, fullQuery, funcModifs);
     if (!result.isEmpty())
         return result;
-    *errorMessage = msgCannotFindDocumentation(sourceFileName, metaClass, func, fullQuery);
+    *errorMessage = msgCannotFindDocumentation(sourceFileName, metaClass, func.data(), fullQuery);
     if (func->arguments().isEmpty()) // No arguments, can't be helped
         return result;
     // Test whether some mismatch in argument types occurred by checking for
@@ -208,7 +211,7 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName,
                              + QLatin1String("\" obtained by matching the argument count only."));
         return getDocumentation(xquery, countOnlyQuery, funcModifs);
     }
-    *errorMessage += msgArgumentCountMatch(func, signatures);
+    *errorMessage += msgArgumentCountMatch(func.data(), signatures);
     return result;
 }
 
@@ -269,14 +272,14 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
     metaClass->setDocumentation(doc);
 
     //Functions Documentation
-    const AbstractMetaFunctionList &funcs = DocParser::documentableFunctions(metaClass);
-    for (AbstractMetaFunction *func : funcs) {
+    const auto &funcs = DocParser::documentableFunctions(metaClass);
+    for (const auto &func : funcs) {
         const QString documentation =
             queryFunctionDocumentation(sourceFileName, metaClass, classQuery,
                                        func, signedModifs, xquery, &errorMessage);
         if (!errorMessage.isEmpty())
             qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage));
-        func->setDocumentation(Documentation(documentation));
+        qSharedPointerConstCast<AbstractMetaFunction>(func)->setDocumentation(Documentation(documentation));
     }
 #if 0
     // Fields
diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.h b/sources/shiboken6/ApiExtractor/qtdocparser.h
index b01139de6..ee6542ca3 100644
--- a/sources/shiboken6/ApiExtractor/qtdocparser.h
+++ b/sources/shiboken6/ApiExtractor/qtdocparser.h
@@ -43,7 +43,7 @@ private:
     QString queryFunctionDocumentation(const QString &sourceFileName,
                                        const AbstractMetaClass* metaClass,
                                        const QString &classQuery,
-                                       const  AbstractMetaFunction *func,
+                                       const AbstractMetaFunctionCPtr &func,
                                        const DocModificationList &signedModifs,
                                        const XQueryPtr &xquery,
                                        QString *errorMessage);
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
index 8e715866e..1fd77a01c 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -70,7 +70,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     QVERIFY(classes[0]->hasConstructors());
     QCOMPARE(classes[0]->functions().size(), 2); // default ctor + copy ctor
 
-    AbstractMetaFunctionList ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors);
+    auto ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.constFirst()->minimalSignature() != QLatin1String("ClassName()"))
         qSwap(ctors[0], ctors[1]);
@@ -88,11 +88,11 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     // QVERIFY(classes[0]->hasNonPrivateConstructor());
 }
 
-static AbstractMetaFunctionList virtualFunctions(const AbstractMetaClass *c)
+static AbstractMetaFunctionCList virtualFunctions(const AbstractMetaClass *c)
 {
-    AbstractMetaFunctionList result;
-    const AbstractMetaFunctionList &functions = c->functions();
-    for (AbstractMetaFunction *f : functions) {
+    AbstractMetaFunctionCList result;
+    const auto &functions = c->functions();
+    for (const auto &f : functions) {
         if (f->isVirtual())
             result.append(f);
     }
@@ -150,9 +150,9 @@ public:
     QVERIFY(f->attributes() & AbstractMetaAttributes::FinalCppClass);
 
     // implementing class, ownclass, declaringclass
-    AbstractMetaFunction *ctorA = a->queryFunctions(AbstractMetaClass::Constructors).constFirst();
-    AbstractMetaFunction *ctorB = b->queryFunctions(AbstractMetaClass::Constructors).constFirst();
-    AbstractMetaFunction *ctorC = c->queryFunctions(AbstractMetaClass::Constructors).constFirst();
+    const auto ctorA = a->queryFunctions(AbstractMetaClass::Constructors).constFirst();
+    const auto ctorB = b->queryFunctions(AbstractMetaClass::Constructors).constFirst();
+    const auto ctorC = c->queryFunctions(AbstractMetaClass::Constructors).constFirst();
     QVERIFY(ctorA->isConstructor());
     QVERIFY(!ctorA->isVirtual());
     QVERIFY(ctorB->isConstructor());
@@ -163,19 +163,19 @@ public:
     QCOMPARE(ctorA->ownerClass(), a);
     QCOMPARE(ctorA->declaringClass(), a);
 
-    const AbstractMetaFunctionList virtualFunctionsA = virtualFunctions(a);
-    const AbstractMetaFunctionList virtualFunctionsB = virtualFunctions(b);
-    const AbstractMetaFunctionList virtualFunctionsC = virtualFunctions(c);
-    const AbstractMetaFunctionList virtualFunctionsF = virtualFunctions(f);
+    const auto virtualFunctionsA = virtualFunctions(a);
+    const auto virtualFunctionsB = virtualFunctions(b);
+    const auto virtualFunctionsC = virtualFunctions(c);
+    const auto virtualFunctionsF = virtualFunctions(f);
     QCOMPARE(virtualFunctionsA.size(), 1); // Add a pureVirtualMethods method !?
     QCOMPARE(virtualFunctionsB.size(), 1);
     QCOMPARE(virtualFunctionsC.size(), 1);
     QCOMPARE(virtualFunctionsF.size(), 1);
 
-    const AbstractMetaFunction* funcA = virtualFunctionsA.constFirst();
-    const AbstractMetaFunction* funcB = virtualFunctionsB.constFirst();
-    const AbstractMetaFunction* funcC = virtualFunctionsC.constFirst();
-    const AbstractMetaFunction* funcF = virtualFunctionsF.constFirst();
+    const auto funcA = virtualFunctionsA.constFirst();
+    const auto funcB = virtualFunctionsB.constFirst();
+    const auto funcC = virtualFunctionsC.constFirst();
+    const auto funcF = virtualFunctionsF.constFirst();
 
     QCOMPARE(funcA->ownerClass(), a);
     QVERIFY(funcC->attributes() & AbstractMetaAttributes::VirtualCppMethod);
@@ -242,7 +242,7 @@ void TestAbstractMetaClass::testDefaultValues()
     QCOMPARE(classes.count(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1);
-    AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).constFirst();
+    const auto method = classA->queryFunctionsByName(QLatin1String("method")).constFirst();
     const AbstractMetaArgument &arg = method->arguments().constFirst();
     QCOMPARE(arg.defaultValueExpression(), arg.originalDefaultValueExpression());
 }
@@ -270,8 +270,9 @@ void TestAbstractMetaClass::testModifiedDefaultValues()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1);
-    AbstractMetaFunction *method = classA->queryFunctionsByName(QLatin1String("method")).constFirst();
+    const auto methodMatches = classA->queryFunctionsByName(QLatin1String("method"));
+    QCOMPARE(methodMatches.count(), 1);
+    const auto method = methodMatches.constFirst();
     const AbstractMetaArgument &arg = method->arguments().constFirst();
     QCOMPARE(arg.defaultValueExpression(), QLatin1String("Hello"));
     QCOMPARE(arg.originalDefaultValueExpression(), QLatin1String("A::B()"));
@@ -326,8 +327,8 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass()
     QVERIFY(classA);
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("A::B"));
     QVERIFY(classB);
-    const AbstractMetaFunction *fooF = classB->findFunction(QLatin1String("foo"));
-    QVERIFY(fooF);
+    const auto fooF = classB->findFunction(QLatin1String("foo"));
+    QVERIFY(!fooF.isNull());
 }
 
 void TestAbstractMetaClass::testSpecialFunctions()
@@ -356,11 +357,11 @@ void TestAbstractMetaClass::testSpecialFunctions()
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction);
     QCOMPARE(ctors.at(1)->functionType(), AbstractMetaFunction::CopyConstructorFunction);
-    AbstractMetaFunctionList assigmentOps = classA->queryFunctionsByName(QLatin1String("operator="));
+    auto assigmentOps = classA->queryFunctionsByName(QLatin1String("operator="));
     QCOMPARE(assigmentOps.size(), 1);
     QCOMPARE(assigmentOps.constFirst()->functionType(),
              AbstractMetaFunction::AssignmentOperatorFunction);
@@ -424,7 +425,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 2);
 
-    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.constFirst()->minimalSignature() != QLatin1String("A()"))
         qSwap(ctors[0], ctors[1]);
@@ -491,7 +492,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
-    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.constFirst()->minimalSignature() != QLatin1String("A()"))
         qSwap(ctors[0], ctors[1]);
@@ -529,7 +530,7 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
-    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    const auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 1);
     QCOMPARE(ctors.constFirst()->arguments().size(), 0);
     QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("A()"));
@@ -550,7 +551,7 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
-    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    const auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 1);
     QCOMPARE(ctors.constFirst()->arguments().size(), 0);
     QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("A()"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
index e65b0f214..897940cd5 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
@@ -74,7 +74,7 @@ void TestAbstractMetaType::testConstCharPtrType()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     QCOMPARE(builder->globalFunctions().size(), 1);
-    AbstractMetaFunction *func = builder->globalFunctions().constFirst();
+    const auto func = builder->globalFunctions().constFirst();
     AbstractMetaType rtype = func->type();
     // Test properties of const char*
     QVERIFY(!rtype.isVoid());
@@ -111,8 +111,7 @@ void TestAbstractMetaType::testApiVersionSupported()
     QCOMPARE(classes.size(), 2);
 
 
-    AbstractMetaFunctionList functions = builder->globalFunctions();
-    QCOMPARE(functions.size(), 2);
+    QCOMPARE(builder->globalFunctions().size(), 2);
 }
 
 
@@ -145,9 +144,9 @@ void TestAbstractMetaType::testCharType()
     QCOMPARE(classes.size(), 1);
     QCOMPARE(classes.constFirst()->package(), QLatin1String("Foo"));
 
-    AbstractMetaFunctionList functions = builder->globalFunctions();
+    const auto functions = builder->globalFunctions();
     QCOMPARE(functions.size(), 1);
-    AbstractMetaFunction *func = functions.constFirst();
+    const auto func = functions.constFirst();
     AbstractMetaType rtype = func->type();
     // Test properties of const char*
     QVERIFY(!rtype.isVoid());
@@ -205,9 +204,9 @@ void TestAbstractMetaType::testTypedefWithTemplates()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    AbstractMetaFunctionList functions = builder->globalFunctions();
+    const auto functions = builder->globalFunctions();
     QCOMPARE(functions.count(), 1);
-    AbstractMetaFunction *function = functions.constFirst();
+    const auto function = functions.constFirst();
     AbstractMetaArgumentList args = function->arguments();
     QCOMPARE(args.count(), 1);
     const AbstractMetaArgument &arg = args.constFirst();
@@ -232,9 +231,9 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue()
     QCOMPARE(classes.size(), 1);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    AbstractMetaFunctionList overloads = classA->queryFunctionsByName(QLatin1String("method"));
+    const auto overloads = classA->queryFunctionsByName(QLatin1String("method"));
     QCOMPARE(overloads.count(), 1);
-    AbstractMetaFunction* method = overloads.constFirst();
+    const auto method = overloads.constFirst();
     QVERIFY(method);
     AbstractMetaArgumentList args = method->arguments();
     QCOMPARE(args.count(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
index 83720b8cb..7a52b9b33 100644
--- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
@@ -166,7 +166,7 @@ void TestAddFunction::testAddFunctionConstructor()
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 3); // default and added ctors
-    AbstractMetaFunction *addedFunc = classA->functions().constLast();
+    const auto addedFunc = classA->functions().constLast();
     QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction);
     QCOMPARE(addedFunc->arguments().size(), 1);
@@ -189,7 +189,7 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function
-    AbstractMetaFunction *addedFunc = classA->functions().constLast();
+    const auto addedFunc = classA->functions().constLast();
     QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
     QVERIFY(addedFunc->isUserAdded());
@@ -213,7 +213,7 @@ void TestAddFunction::testAddFunctionCodeSnippets()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    AbstractMetaFunction *addedFunc = classA->functions().constLast();
+    const auto addedFunc = classA->functions().constLast();
     QVERIFY(addedFunc->hasInjectedCode());
 }
 
@@ -243,8 +243,8 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
-    QVERIFY(addedFunc);
+    const auto addedFunc = classA->findFunction(QLatin1String("func"));
+    QVERIFY(!addedFunc.isNull());
     QVERIFY(addedFunc->hasInjectedCode());
     QCOMPARE(addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode).count(), 1);
 }
@@ -278,8 +278,8 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
-    QVERIFY(addedFunc);
+    const auto addedFunc = classA->findFunction(QLatin1String("func"));
+    QVERIFY(!addedFunc.isNull());
     const AbstractMetaArgument &arg = addedFunc->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), QLatin1String("2"));
 }
@@ -342,8 +342,8 @@ void TestAddFunction::testAddFunctionWithVarargs()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
-    QVERIFY(addedFunc);
+    const auto addedFunc = classA->findFunction(QLatin1String("func"));
+    QVERIFY(!addedFunc.isNull());
     const AbstractMetaArgument &arg = addedFunc->arguments().constLast();
     QVERIFY(arg.type().isVarargs());
     QVERIFY(arg.type().typeEntry()->isVarargs());
@@ -366,8 +366,8 @@ void TestAddFunction::testAddStaticFunction()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
-    QVERIFY(addedFunc);
+    const auto addedFunc = classA->findFunction(QLatin1String("func"));
+    QVERIFY(!addedFunc.isNull());
     QVERIFY(addedFunc->isStatic());
 }
 
@@ -388,7 +388,7 @@ void TestAddFunction::testAddGlobalFunction()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
-    AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
+    const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 2);
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(builder->classes(), QLatin1String("B"));
     QVERIFY(classB);
@@ -414,7 +414,7 @@ void TestAddFunction::testAddFunctionWithApiVersion()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, QLatin1String("0.1")));
     QVERIFY(!builder.isNull());
-    AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
+    const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 }
 
@@ -439,7 +439,8 @@ void TestAddFunction::testModifyAddedFunction()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("Foo"));
-    const AbstractMetaFunction* method = foo->findFunction(QLatin1String("method"));
+    const auto method = foo->findFunction(QLatin1String("method"));
+    QVERIFY(!method.isNull());
     QCOMPARE(method->arguments().size(), 2);
     const AbstractMetaArgument &arg = method->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), QLatin1String("0"));
@@ -469,12 +470,12 @@ void TestAddFunction::testAddFunctionOnTypedef()
     AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("FooInt"));
     QVERIFY(foo);
     QVERIFY(foo->hasNonPrivateConstructor());
-    const AbstractMetaFunctionList &lst = foo->queryFunctions(AbstractMetaClass::Constructors);
-    for (const AbstractMetaFunction *f : lst)
+    const auto &lst = foo->queryFunctions(AbstractMetaClass::Constructors);
+    for (const auto &f : lst)
         QVERIFY(f->signature().startsWith(f->name()));
     QCOMPARE(lst.size(), 2);
-    const AbstractMetaFunction* method = foo->findFunction(QLatin1String("method"));
-    QVERIFY(method);
+    const auto method = foo->findFunction(QLatin1String("method"));
+    QVERIFY(!method.isNull());
 }
 
 void TestAddFunction::testAddFunctionWithTemplateArg()
@@ -490,7 +491,7 @@ void TestAddFunction::testAddFunctionWithTemplateArg()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     QCOMPARE(builder->globalFunctions().size(), 1);
-    AbstractMetaFunction *func = builder->globalFunctions().constFirst();
+    const auto func = builder->globalFunctions().constFirst();
     const AbstractMetaArgument &arg = func->arguments().constFirst();
     QCOMPARE(arg.type().instantiations().count(), 1);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
index df6280725..22cf7ab40 100644
--- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
@@ -63,8 +63,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
 
 static QString functionMinimalSignature(const AbstractMetaClass *c, const QString &name)
 {
-    const AbstractMetaFunction *f = c->findFunction(name);
-    return f ? f->minimalSignature() : QString();
+    const auto f = c->findFunction(name);
+    return f.isNull() ? QString() : f->minimalSignature();
 }
 
 void TestArrayArgument::testArraySignature()
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
index b9345ddbc..32071f533 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
@@ -65,14 +65,14 @@ void TestConversionOperator::testConversionOperator()
     QCOMPARE(classC->functions().count(), 3);
     QCOMPARE(classA->externalConversionOperators().count(), 2);
 
-    AbstractMetaFunction *convOp = nullptr;
-    for (AbstractMetaFunction *func : classB->functions()) {
+    AbstractMetaFunctionCPtr convOp;
+    for (const auto &func : classB->functions()) {
         if (func->isConversionOperator()) {
             convOp = func;
             break;
         }
     }
-    QVERIFY(convOp);
+    QVERIFY(!convOp.isNull());
     QVERIFY(classA->externalConversionOperators().contains(convOp));
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
index 710361b47..df744e994 100644
--- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
@@ -64,7 +64,7 @@ void TestEnum::testEnumCppSignature()
     QCOMPARE(globalEnums.constFirst().name(), QLatin1String("GlobalEnum"));
 
     // enum as parameter of a function
-    AbstractMetaFunctionList functions = builder->globalFunctions();
+    const auto functions = builder->globalFunctions();
     QCOMPARE(functions.count(), 1);
     QCOMPARE(functions.constFirst()->arguments().count(), 1);
     QCOMPARE(functions.constFirst()->arguments().constFirst().type().cppSignature(),
@@ -73,10 +73,9 @@ void TestEnum::testEnumCppSignature()
     // enum as parameter of a method
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->enums().count(), 1);
-    AbstractMetaFunctionList funcs = classA->queryFunctionsByName(QLatin1String("method"));
+    const auto funcs = classA->queryFunctionsByName(QLatin1String("method"));
     QVERIFY(!funcs.isEmpty());
-    AbstractMetaFunction *method = funcs.constFirst();
-    QVERIFY(method);
+    const auto method = funcs.constFirst();
     AbstractMetaArgument arg = method->arguments().constFirst();
     QCOMPARE(arg.type().name(), QLatin1String("ClassEnum"));
     QCOMPARE(arg.type().cppSignature(), QLatin1String("A::ClassEnum"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
index ba8f22706..f58ea6f64 100644
--- a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
@@ -82,7 +82,7 @@ void TestFunctionTag::testRenameGlobalFunction()
     QVERIFY(func);
 
     QCOMPARE(builder->globalFunctions().size(), 1);
-    const AbstractMetaFunction *metaFunc = builder->globalFunctions().constFirst();
+    const auto metaFunc = builder->globalFunctions().constFirst();
 
     QVERIFY(metaFunc);
     QCOMPARE(metaFunc->modifications().size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
index ef9699cad..928122967 100644
--- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
@@ -58,7 +58,7 @@ void TestImplicitConversions::testWithPrivateCtors()
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
-    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
              classC->typeEntry());
@@ -88,7 +88,7 @@ void TestImplicitConversions::testWithModifiedVisibility()
     QCOMPARE(classes.count(), 2);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
              classB->typeEntry());
@@ -122,7 +122,7 @@ void TestImplicitConversions::testWithAddedCtor()
     QCOMPARE(classes.count(), 3);
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 2);
 
     // Added constructors with custom types should never result in implicit converters.
@@ -149,17 +149,17 @@ void TestImplicitConversions::testWithExternalConversionOperator()
     QCOMPARE(classes.count(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 1);
-    AbstractMetaFunctionList externalConvOps = classA->externalConversionOperators();
+    const auto &externalConvOps = classA->externalConversionOperators();
     QCOMPARE(externalConvOps.count(), 1);
 
-    const AbstractMetaFunction *convOp = nullptr;
-    for (const AbstractMetaFunction *func : classB->functions()) {
+    AbstractMetaFunctionCPtr convOp;
+    for (const auto &func : classB->functions()) {
         if (func->isConversionOperator())
             convOp = func;
     }
-    QVERIFY(convOp);
+    QVERIFY(!convOp.isNull());
     QCOMPARE(implicitConvs.constFirst(), convOp);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
index 6928448b7..0fa07b75c 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
@@ -67,8 +67,8 @@ void TestModifyFunction::testRenameArgument()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    const AbstractMetaFunction* func = classA->findFunction(QLatin1String("method"));
-    Q_ASSERT(func);
+    const auto func = classA->findFunction(QLatin1String("method"));
+    QVERIFY(!func.isNull());
 
     QCOMPARE(func->argumentName(1), QLatin1String("otherArg"));
 }
@@ -95,7 +95,8 @@ void TestModifyFunction::testOwnershipTransfer()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("method"));
+    const auto func = classB->findFunction(QLatin1String("method"));
+    QVERIFY(!func.isNull());
 
     QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership);
 }
@@ -143,7 +144,7 @@ void TestModifyFunction::invalidateAfterUse()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("call"));
+    auto func = classB->findFunction(QLatin1String("call"));
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse);
@@ -216,7 +217,7 @@ void TestModifyFunction::testWithApiVersion()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("method"));
+    auto func = classB->findFunction(QLatin1String("method"));
 
     QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership);
 
@@ -256,28 +257,28 @@ struct A {
     QVERIFY(classA);
 
     // Nothing specified, true
-    const AbstractMetaFunction *f1 = classA->findFunction(QLatin1String("f1"));
-    QVERIFY(f1);
+    const auto f1 = classA->findFunction(QLatin1String("f1"));
+    QVERIFY(!f1.isNull());
     QVERIFY(!f1->allowThread());
 
     // 'auto' specified, should be false for nontrivial function
-    const AbstractMetaFunction *f2 = classA->findFunction(QLatin1String("f2"));
-    QVERIFY(f2);
+    const auto f2 = classA->findFunction(QLatin1String("f2"));
+    QVERIFY(!f2.isNull());
     QVERIFY(f2->allowThread());
 
     // 'no' specified, should be false
-    const AbstractMetaFunction *f3 = classA->findFunction(QLatin1String("f3"));
-    QVERIFY(f3);
+    const auto f3 = classA->findFunction(QLatin1String("f3"));
+    QVERIFY(!f3.isNull());
     QVERIFY(!f3->allowThread());
 
     // Nothing specified, should be false for simple getter
-    const AbstractMetaFunction *getter1 = classA->findFunction(QLatin1String("getter1"));
-    QVERIFY(getter1);
+    const auto getter1 = classA->findFunction(QLatin1String("getter1"));
+    QVERIFY(!getter1.isNull());
     QVERIFY(!getter1->allowThread());
 
     // Forced to true simple getter
-    const AbstractMetaFunction *getter2 = classA->findFunction(QLatin1String("getter2"));
-    QVERIFY(getter2);
+    const auto getter2 = classA->findFunction(QLatin1String("getter2"));
+    QVERIFY(!getter2.isNull());
     QVERIFY(getter2->allowThread()); // Forced to true simple getter
 }
 
@@ -310,8 +311,8 @@ void TestModifyFunction::testGlobalFunctionModification()
     ArgumentModification argMod = argMods.constFirst();
     QCOMPARE(argMod.replacedDefaultExpression, QLatin1String("A()"));
 
-    const AbstractMetaFunction *func = builder->globalFunctions().constFirst();
-    QVERIFY(func);
+    QVERIFY(!builder->globalFunctions().isEmpty());
+    const auto func = builder->globalFunctions().constFirst();
     QCOMPARE(func->arguments().count(), 1);
     const AbstractMetaArgument &arg = func->arguments().constFirst();
     QCOMPARE(arg.type().cppSignature(), QLatin1String("A *"));
@@ -452,19 +453,19 @@ void TestModifyFunction::testScopedModifications()
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
-    const AbstractMetaFunction *f = classA->findFunction(QStringLiteral("unspecified"));
-    QVERIFY(f);
+    auto f = classA->findFunction(QStringLiteral("unspecified"));
+    QVERIFY(!f.isNull());
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Unknown);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateUnspecified);
     QCOMPARE(f->allowThread(), expectedAllowThread);
 
     f = classA->findFunction(QStringLiteral("nonThrowing"));
-    QVERIFY(f);
+    QVERIFY(!f.isNull());
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::NoExcept);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateNonThrowing);
 
     f = classA->findFunction(QStringLiteral("throwing"));
-    QVERIFY(f);
+    QVERIFY(!f.isNull());
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Throws);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateThrowing);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
index 7702d37d9..748adfc39 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -62,8 +62,7 @@ void TestMultipleInheritance::testVirtualClass()
 
     const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("D"));
     bool functionFound = false;
-    const AbstractMetaFunctionList &functions = classD->functions();
-    for (AbstractMetaFunction *f : functions) {
+    for (const auto &f : classD->functions()) {
         if (f->name() == QLatin1String("theBug")) {
             functionFound = true;
             break;
diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
index 7f0addd6b..99aabe780 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
@@ -57,8 +57,8 @@ void NamespaceTest::testNamespaceMembers()
     QVERIFY(ns);
     auto metaEnum = ns->findEnum(QLatin1String("Option"));
     QVERIFY(metaEnum.has_value());
-    const AbstractMetaFunction* func = ns->findFunction(QLatin1String("foo"));
-    QVERIFY(func);
+    const auto func = ns->findFunction(QLatin1String("foo"));
+    QVERIFY(!func.isNull());
 }
 
 void NamespaceTest::testNamespaceInnerClassMembers()
@@ -89,8 +89,8 @@ void NamespaceTest::testNamespaceInnerClassMembers()
     QVERIFY(ins);
     const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
     QVERIFY(sc);
-    const AbstractMetaFunction* meth = sc->findFunction(QLatin1String("method"));
-    QVERIFY(meth);
+    const auto meth = sc->findFunction(QLatin1String("method"));
+    QVERIFY(!meth.isNull());
 }
 
 QTEST_APPLESS_MAIN(NamespaceTest)
diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
index 4613eeaa5..71daef051 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
@@ -73,7 +73,7 @@ void TestNestedTypes::testNestedTypesModifications()
     CodeSnip snip = ins->typeEntry()->codeSnips().constFirst();
     QCOMPARE(snip.code().trimmed(), QLatin1String("custom_code1();"));
 
-    AbstractMetaFunction *addedFunc = ins->functions().constFirst();
+    const auto addedFunc = ins->functions().constFirst();
     QVERIFY(addedFunc->isUserAdded());
     QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
@@ -88,7 +88,7 @@ void TestNestedTypes::testNestedTypesModifications()
     const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
     QVERIFY(ins);
     QCOMPARE(sc->functions().count(), 2); // default constructor and removed method
-    AbstractMetaFunction *removedFunc = sc->functions().constLast();
+    const auto removedFunc = sc->functions().constLast();
     QVERIFY(removedFunc->isModifiedRemoved());
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
index d613074fe..de2f30135 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
@@ -50,9 +50,8 @@ void TestNumericalTypedef::testNumericalTypedef()
     QVERIFY(!builder.isNull());
 
     QCOMPARE(builder->globalFunctions().size(), 2);
-    const AbstractMetaFunction *funcDouble = builder->globalFunctions().constFirst();
-    QVERIFY(funcDouble);
-    const AbstractMetaFunction *funcReal = builder->globalFunctions().constLast();
+    auto funcDouble = builder->globalFunctions().constFirst();
+    auto funcReal = builder->globalFunctions().constLast();
     QVERIFY(funcReal);
 
     if (funcDouble->name() == QLatin1String("funcReal"))
@@ -90,10 +89,8 @@ void TestNumericalTypedef::testUnsignedNumericalTypedef()
     QVERIFY(!builder.isNull());
 
     QCOMPARE(builder->globalFunctions().size(), 2);
-    const AbstractMetaFunction *funcUnsignedShort = builder->globalFunctions().constFirst();
-    QVERIFY(funcUnsignedShort);
-    const AbstractMetaFunction *funcUShort = builder->globalFunctions().constLast();
-    QVERIFY(funcUShort);
+    auto funcUnsignedShort = builder->globalFunctions().constFirst();
+    auto funcUShort = builder->globalFunctions().constLast();
 
     if (funcUnsignedShort->name() == QLatin1String("funcUShort"))
         std::swap(funcUnsignedShort, funcUShort);
diff --git a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
index 9f1e32e05..a589827e4 100644
--- a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
@@ -55,8 +55,8 @@ void TestRefCountTag::testReferenceCountTag()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject"));
-    QVERIFY(func);
+    const auto func = classB->findFunction(QLatin1String("keepObject"));
+    QVERIFY(!func.isNull());
     ReferenceCount refCount = func->modifications().constFirst().argument_mods().constFirst().referenceCounts.constFirst();
     QCOMPARE(refCount.action, ReferenceCount::Add);
 }
@@ -88,8 +88,8 @@ void TestRefCountTag::testWithApiVersion()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject"));
-    QVERIFY(func);
+    const auto func = classB->findFunction(QLatin1String("keepObject"));
+    QVERIFY(!func.isNull());
     ReferenceCount refCount = func->modifications().constFirst().argument_mods().constFirst().referenceCounts.constFirst();
     QCOMPARE(refCount.action, ReferenceCount::Add);
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
index 6cd719743..b929ebd66 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
@@ -50,8 +50,8 @@ void TestReferenceToPointer::testReferenceToPointerArgument()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("dummy"));
-    QVERIFY(func);
+    const auto func = classB->findFunction(QLatin1String("dummy"));
+    QVERIFY(!func.isNull());
     QCOMPARE(func->arguments().constFirst().type().minimalSignature(), QLatin1String("A*&"));
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
index bd78ad80d..41103c24e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
@@ -62,7 +62,7 @@ void TestRemoveImplConv::testRemoveImplConv()
     QVERIFY(classB);
     const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(classC);
-    AbstractMetaFunctionList implConv = classC->implicitConversions();
+    const auto implConv = classC->implicitConversions();
     QCOMPARE(implConv.count(), 1);
     QCOMPARE(implConv.constFirst()->arguments().constFirst().type().typeEntry(),
              classB->typeEntry());
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
index 3b9936571..9824d1bf0 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -106,8 +106,7 @@ void TestRemoveOperatorMethod::testRemoveOperatorMethod()
     removedSignatures.append(QLatin1String("operator>>(Char&)"));
     removedSignatures.append(QLatin1String("operator>>(String&)"));
     int notRemoved = classA->functions().size();
-    const AbstractMetaFunctionList &functions = classA->functions();
-    for (const AbstractMetaFunction *f : functions) {
+    for (const auto &f : classA->functions()) {
         QCOMPARE(f->isModifiedRemoved(), bool(removedSignatures.contains(f->minimalSignature())));
         notRemoved -= int(f->isModifiedRemoved());
     }
diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
index 2203f3648..4c2930234 100644
--- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
@@ -58,7 +58,8 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("A::D"));
     QVERIFY(classD);
-    const AbstractMetaFunction* meth = classD->findFunction(QLatin1String("method"));
+    const auto meth = classD->findFunction(QLatin1String("method"));
+    QVERIFY(!meth.isNull());
     QVERIFY(meth);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
index 66dd6edbf..3ad77c86f 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
@@ -52,9 +52,9 @@ void TestReverseOperators::testReverseSum()
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 4);
 
-    const AbstractMetaFunction* reverseOp = nullptr;
-    const AbstractMetaFunction* normalOp = 0;
-    for (const AbstractMetaFunction *func : classA->functions()) {
+    AbstractMetaFunctionCPtr reverseOp;
+    AbstractMetaFunctionCPtr normalOp;
+    for (const auto &func : classA->functions()) {
         if (func->name() == QLatin1String("operator+")) {
             if (func->isReverseOperator())
                 reverseOp = func;
@@ -63,10 +63,10 @@ void TestReverseOperators::testReverseSum()
         }
     }
 
-    QVERIFY(normalOp);
+    QVERIFY(!normalOp.isNull());
     QVERIFY(!normalOp->isReverseOperator());
     QCOMPARE(normalOp->arguments().count(), 1);
-    QVERIFY(reverseOp);
+    QVERIFY(!reverseOp.isNull());
     QVERIFY(reverseOp->isReverseOperator());
     QCOMPARE(reverseOp->arguments().count(), 1);
 }
@@ -98,9 +98,9 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     QVERIFY(classB);
     QCOMPARE(classB->functions().count(), 4);
 
-    const AbstractMetaFunction *reverseOp = nullptr;
-    const AbstractMetaFunction *normalOp = nullptr;
-    for (const AbstractMetaFunction *func : classB->functions()) {
+    AbstractMetaFunctionCPtr reverseOp;
+    AbstractMetaFunctionCPtr normalOp;
+    for (const auto &func : classB->functions()) {
         if (func->name() == QLatin1String("operator+")) {
             if (func->isReverseOperator())
                 reverseOp = func;
@@ -108,11 +108,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
                 normalOp = func;
         }
     }
-    QVERIFY(normalOp);
+    QVERIFY(!normalOp.isNull());
     QVERIFY(!normalOp->isReverseOperator());
     QCOMPARE(normalOp->arguments().count(), 1);
     QCOMPARE(normalOp->minimalSignature(), QLatin1String("operator+(B,A)"));
-    QVERIFY(reverseOp);
+    QVERIFY(!reverseOp.isNull());
     QVERIFY(reverseOp->isReverseOperator());
     QCOMPARE(reverseOp->arguments().count(), 1);
     QCOMPARE(reverseOp->minimalSignature(), QLatin1String("operator+(A,B)"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
index 2ddccc900..2a5bd750d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
@@ -77,7 +77,8 @@ namespace Internet {
 
     AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("Bookmarks"));
     QVERIFY(classB);
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("list"));
+    const auto func = classB->findFunction(QLatin1String("list"));
+    QVERIFY(!func.isNull());
     AbstractMetaType funcType = func->type();
     QVERIFY(!funcType.isVoid());
     QCOMPARE(funcType.cppSignature(), QLatin1String("QList<Internet::Url >"));
@@ -116,7 +117,8 @@ namespace Namespace {
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
-    const AbstractMetaFunction* func = classB->findFunction(QLatin1String("foo"));
+    const auto func = classB->findFunction(QLatin1String("foo"));
+    QVERIFY(!func.isNull());
     AbstractMetaType argType = func->arguments().constFirst().type();
     QCOMPARE(argType.instantiations().count(), 1);
     QCOMPARE(argType.typeEntry()->qualifiedCppName(), QLatin1String("QList"));
@@ -146,10 +148,10 @@ void func(List<int> arg) {}
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
+    const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 
-    AbstractMetaFunction *func = globalFuncs.constFirst();
+    const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>)"));
     QCOMPARE(func->arguments().constFirst().type().cppSignature(),
              QLatin1String("List<int >"));
@@ -171,10 +173,10 @@ void func(List<int>* arg) {}
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
+    AbstractMetaFunctionCList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 
-    AbstractMetaFunction* func = globalFuncs.constFirst();
+    const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>*)"));
     QCOMPARE(func->arguments().constFirst().type().cppSignature(),
              QLatin1String("List<int > *"));
@@ -196,10 +198,10 @@ void func(List<int>& arg) {}
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
+    const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 
-    AbstractMetaFunction* func = globalFuncs.constFirst();
+    const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>&)"));
     QCOMPARE(func->arguments().constFirst().type().cppSignature(),
              QLatin1String("List<int > &"));
@@ -230,13 +232,13 @@ struct List {
     QCOMPARE(templates.count(), 1);
     const AbstractMetaClass *list = templates.constFirst();
     // Verify that the parameter of "void append(List l)" gets fixed to "List<T >"
-    const AbstractMetaFunction *append = list->findFunction(QStringLiteral("append"));
-    QVERIFY(append);
+    const auto append = list->findFunction(QStringLiteral("append"));
+    QVERIFY(!append.isNull());
     QCOMPARE(append->arguments().size(), 1);
     QCOMPARE(append->arguments().at(0).type().cppSignature(), QLatin1String("List<T >"));
     // Verify that the parameter of "void erase(Iterator)" is not modified
-    const AbstractMetaFunction *erase = list->findFunction(QStringLiteral("erase"));
-    QVERIFY(erase);
+    const auto erase = list->findFunction(QStringLiteral("erase"));
+    QVERIFY(!erase.isNull());
     QCOMPARE(erase->arguments().size(), 1);
     QEXPECT_FAIL("", "Clang: Some other code changes the parameter type", Abort);
     QCOMPARE(erase->arguments().at(0).type().cppSignature(), QLatin1String("List::Iterator"));
@@ -438,12 +440,12 @@ typedef Vector<int> IntVector;
              ContainerTypeEntry::VectorContainer);
     QCOMPARE(vector->functions().count(), 4);
 
-    const AbstractMetaFunction* method = vector->findFunction(QLatin1String("method"));
-    QVERIFY(method);
+    const auto method = vector->findFunction(QLatin1String("method"));
+    QVERIFY(!method.isNull());
     QCOMPARE(method->signature(), QLatin1String("method(const Vector<int > & vector)"));
 
-    const AbstractMetaFunction* otherMethod = vector->findFunction(QLatin1String("otherMethod"));
-    QVERIFY(otherMethod);
+    const auto otherMethod = vector->findFunction(QLatin1String("otherMethod"));
+    QVERIFY(!otherMethod.isNull());
     QCOMPARE(otherMethod->signature(), QLatin1String("otherMethod()"));
     QVERIFY(!otherMethod->type().isVoid());
     QCOMPARE(otherMethod->type().cppSignature(), QLatin1String("Vector<int >"));
@@ -572,15 +574,13 @@ void TestTemplates::testTemplateTypeDefs()
     QCOMPARE(xmlOptionalInt->templateBaseClass(), optional);
 
     // Check whether the value() method now has an 'int' return
-    const AbstractMetaFunction *valueMethod =
-        optionalInt->findFunction(QLatin1String("value"));
-    QVERIFY(valueMethod);
+    const auto valueMethod = optionalInt->findFunction(QLatin1String("value"));
+    QVERIFY(!valueMethod.isNull());
     QCOMPARE(valueMethod->type().cppSignature(), QLatin1String("int"));
 
     // ditto for typesystem XML
-    const AbstractMetaFunction *xmlValueMethod =
-        xmlOptionalInt->findFunction(QLatin1String("value"));
-    QVERIFY(xmlValueMethod);
+    const auto xmlValueMethod = xmlOptionalInt->findFunction(QLatin1String("value"));
+    QVERIFY(!xmlValueMethod.isNull());
     QCOMPARE(xmlValueMethod->type().cppSignature(), QLatin1String("int"));
 
     // Check whether the m_value field is of type 'int'
diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
index d39819d0f..6d155dacc 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
@@ -45,7 +45,8 @@ void TestVoidArg::testVoidParsedFunction()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a"));
+    const auto addedFunc = classA->findFunction(QLatin1String("a"));
+    QVERIFY(!addedFunc.isNull());
     QCOMPARE(addedFunc->arguments().count(), 0);
 }
 
@@ -63,7 +64,8 @@ void TestVoidArg::testVoidAddedFunction()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a"));
+    const auto addedFunc = classA->findFunction(QLatin1String("a"));
+    QVERIFY(!addedFunc.isNull());
     QCOMPARE(addedFunc->arguments().count(), 0);
 
 }
@@ -80,7 +82,8 @@ void TestVoidArg::testVoidPointerParsedFunction()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a"));
+    const auto addedFunc = classA->findFunction(QLatin1String("a"));
+    QVERIFY(!addedFunc.isNull());
     QCOMPARE(addedFunc->arguments().count(), 1);
 
 }
diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp
index 0c986661b..2bc489897 100644
--- a/sources/shiboken6/generator/generator.cpp
+++ b/sources/shiboken6/generator/generator.cpp
@@ -302,7 +302,7 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType
 
 }
 
-void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction *func)
+void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunctionCPtr &func)
 {
     addInstantiatedContainersAndSmartPointers(func->type(), func->signature());
     const AbstractMetaArgumentList &arguments = func->arguments();
@@ -314,8 +314,7 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
 {
     if (!metaClass->typeEntry()->generateCode())
         return;
-    const AbstractMetaFunctionList &funcs = metaClass->functions();
-    for (const AbstractMetaFunction *func : funcs)
+    for (const auto &func : metaClass->functions())
         collectInstantiatedContainersAndSmartPointers(func);
     for (const AbstractMetaField &field : metaClass->fields())
         addInstantiatedContainersAndSmartPointers(field.type(), field.name());
@@ -326,7 +325,7 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
 
 void Generator::collectInstantiatedContainersAndSmartPointers()
 {
-    for (const AbstractMetaFunction *func : globalFunctions())
+    for (const auto &func : globalFunctions())
         collectInstantiatedContainersAndSmartPointers(func);
     for (const AbstractMetaClass *metaClass : classes())
         collectInstantiatedContainersAndSmartPointers(metaClass);
@@ -367,7 +366,7 @@ AbstractMetaClassList Generator::classesTopologicalSorted(const Dependencies &ad
     return m_d->apiextractor->classesTopologicalSorted(additionalDependencies);
 }
 
-const AbstractMetaFunctionList &Generator::globalFunctions() const
+const AbstractMetaFunctionCList &Generator::globalFunctions() const
 {
     return m_d->apiextractor->globalFunctions();
 }
@@ -527,16 +526,16 @@ void verifyDirectoryFor(const QString &file)
     }
 }
 
-AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry *type) const
+AbstractMetaFunctionCList Generator::implicitConversions(const TypeEntry *type) const
 {
     if (type->isValue()) {
         if (const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), type))
             return metaClass->implicitConversions();
     }
-    return AbstractMetaFunctionList();
+    return {};
 }
 
-AbstractMetaFunctionList Generator::implicitConversions(const AbstractMetaType &metaType) const
+AbstractMetaFunctionCList Generator::implicitConversions(const AbstractMetaType &metaType) const
 {
     return implicitConversions(metaType.typeEntry());
 }
@@ -729,9 +728,9 @@ std::optional<DefaultValue>
 
     const QString qualifiedCppName = cType->qualifiedCppName();
     // Obtain a list of constructors sorted by complexity and number of arguments
-    QMultiMap<int, const AbstractMetaFunction *> candidates;
-    const AbstractMetaFunctionList &constructors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
-    for (const AbstractMetaFunction *ctor : constructors) {
+    QMultiMap<int, const AbstractMetaFunctionCPtr> candidates;
+    const auto &constructors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
+    for (const auto &ctor : constructors) {
         if (!ctor->isUserAdded() && !ctor->isPrivate()
             && ctor->functionType() == AbstractMetaFunction::ConstructorFunction) {
             // No arguments: Default constructible
diff --git a/sources/shiboken6/generator/generator.h b/sources/shiboken6/generator/generator.h
index 28120b5b4..79e2f19b1 100644
--- a/sources/shiboken6/generator/generator.h
+++ b/sources/shiboken6/generator/generator.h
@@ -264,10 +264,10 @@ public:
      *   \param type a TypeEntry that is expected to be a value-type
      *   \return a list of constructors that could be used as implicit converters
      */
-    AbstractMetaFunctionList implicitConversions(const TypeEntry *type) const;
+    AbstractMetaFunctionCList implicitConversions(const TypeEntry *type) const;
 
     /// Convenience function for implicitConversions(const TypeEntry *type).
-    AbstractMetaFunctionList implicitConversions(const AbstractMetaType &metaType) const;
+    AbstractMetaFunctionCList implicitConversions(const AbstractMetaType &metaType) const;
 
 protected:
     /// Returns the classes, topologically ordered, used to generate the binding code.
@@ -277,7 +277,7 @@ protected:
     AbstractMetaClassList classesTopologicalSorted(const Dependencies &additionalDependencies = Dependencies()) const;
 
     /// Returns all global functions found by APIExtractor
-    const AbstractMetaFunctionList &globalFunctions() const;
+    const AbstractMetaFunctionCList &globalFunctions() const;
 
     /// Returns all global enums found by APIExtractor
     const AbstractMetaEnumList &globalEnums() const;
@@ -398,7 +398,7 @@ private:
 
     struct GeneratorPrivate;
     GeneratorPrivate *m_d;
-    void collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction *func);
+    void collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunctionCPtr &func);
     void collectInstantiatedContainersAndSmartPointers(const AbstractMetaClass *metaClass);
     void collectInstantiatedContainersAndSmartPointers();
 };
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index 9a53bd97a..3e61b3e99 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -58,7 +58,7 @@ static inline QString briefEndElement() { return QStringLiteral("</brief>"); }
 
 static inline QString none() { return QStringLiteral("None"); }
 
-static bool shouldSkip(const AbstractMetaFunction* func)
+static bool shouldSkip(const AbstractMetaFunctionCPtr &func)
 {
     // Constructors go to separate section
     if (DocParser::skipForQuery(func) || func->isConstructor())
@@ -69,8 +69,8 @@ static bool shouldSkip(const AbstractMetaFunction* func)
         return false;
 
     const AbstractMetaArgumentList funcArgs = func->arguments();
-    const AbstractMetaFunctionList &ownerFunctions = func->ownerClass()->functions();
-    for (AbstractMetaFunction *f : ownerFunctions) {
+    const auto &ownerFunctions = func->ownerClass()->functions();
+    for (const auto &f : ownerFunctions) {
         if (f != func
             && f->isConstant()
             && f->name() == func->name()
@@ -92,7 +92,7 @@ static bool shouldSkip(const AbstractMetaFunction* func)
     return false;
 }
 
-static bool functionSort(const AbstractMetaFunction* func1, const AbstractMetaFunction* func2)
+static bool functionSort(const AbstractMetaFunctionCPtr &func1, const AbstractMetaFunctionCPtr &func2)
 {
     return func1->name() < func2->name();
 }
@@ -107,7 +107,7 @@ static inline QVersionNumber versionOf(const TypeEntry *te)
     return QVersionNumber();
 }
 
-static QString getFuncName(const AbstractMetaFunction* cppFunc) {
+static QString getFuncName(const AbstractMetaFunctionCPtr& cppFunc) {
     static bool hashInitialized = false;
     static QHash<QString, QString> operatorsHash;
     if (!hashInitialized) {
@@ -292,7 +292,7 @@ void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classC
     writeFunctionList(s, metaClass);
 
     //Function list
-    AbstractMetaFunctionList functionList = metaClass->functions();
+    auto functionList = metaClass->functions();
     std::sort(functionList.begin(), functionList.end(), functionSort);
 
     s << "\nDetailed Description\n"
@@ -311,7 +311,7 @@ void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classC
 
 
     QStringList uniqueFunctions;
-    for (AbstractMetaFunction *func : qAsConst(functionList)) {
+    for (const auto &func : qAsConst(functionList)) {
         if (shouldSkip(func))
             continue;
 
@@ -335,8 +335,8 @@ void QtDocGenerator::writeFunctionList(TextStream& s, const AbstractMetaClass* c
     QStringList slotList;
     QStringList staticFunctionList;
 
-    const AbstractMetaFunctionList &classFunctions = cppClass->functions();
-    for (AbstractMetaFunction *func : classFunctions) {
+    const auto &classFunctions = cppClass->functions();
+    for (const auto &func : classFunctions) {
         if (shouldSkip(func))
             continue;
 
@@ -427,7 +427,7 @@ void QtDocGenerator::writeConstructors(TextStream& s, const AbstractMetaClass* c
 {
     static const QString sectionTitle = QLatin1String(".. class:: ");
 
-    AbstractMetaFunctionList lst = cppClass->queryFunctions(AbstractMetaClass::Constructors | AbstractMetaClass::Visible);
+    auto lst = cppClass->queryFunctions(AbstractMetaClass::Constructors | AbstractMetaClass::Visible);
     for (int i = lst.size() - 1; i >= 0; --i) {
         if (lst.at(i)->isModifiedRemoved() || lst.at(i)->functionType() == AbstractMetaFunction::MoveConstructorFunction)
             lst.removeAt(i);
@@ -440,7 +440,7 @@ void QtDocGenerator::writeConstructors(TextStream& s, const AbstractMetaClass* c
         s << sectionTitle << cppClass->fullName();
     } else {
         QByteArray pad;
-        for (AbstractMetaFunction *func : qAsConst(lst)) {
+        for (const auto &func : qAsConst(lst)) {
             s << pad;
             if (first) {
                 first = false;
@@ -474,12 +474,12 @@ void QtDocGenerator::writeConstructors(TextStream& s, const AbstractMetaClass* c
 
     s << '\n';
 
-    for (AbstractMetaFunction *func : qAsConst(lst))
+    for (const auto &func : qAsConst(lst))
         writeFormattedText(s, func->documentation().value(), cppClass);
 }
 
 QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* /* cppClass */,
-                                         const AbstractMetaFunction* func)
+                                         const AbstractMetaFunctionCPtr &func)
 {
     QString ret;
     int optArgs = 0;
@@ -589,7 +589,7 @@ void QtDocGenerator::writeDocSnips(TextStream &s,
 bool QtDocGenerator::writeInjectDocumentation(TextStream& s,
                                             TypeSystem::DocModificationMode mode,
                                             const AbstractMetaClass* cppClass,
-                                            const AbstractMetaFunction* func)
+                                            const AbstractMetaFunctionCPtr &func)
 {
     Indentation indentation(s);
     bool didSomething = false;
@@ -630,7 +630,8 @@ bool QtDocGenerator::writeInjectDocumentation(TextStream& s,
     return didSomething;
 }
 
-QString QtDocGenerator::functionSignature(const AbstractMetaClass* cppClass, const AbstractMetaFunction* func)
+QString QtDocGenerator::functionSignature(const AbstractMetaClass* cppClass,
+                                          const AbstractMetaFunctionCPtr &func)
 {
     QString funcName;
 
@@ -710,7 +711,7 @@ void QtDocGenerator::writeParameterType(TextStream& s, const AbstractMetaClass*
 }
 
 void QtDocGenerator::writeFunctionParametersType(TextStream &s, const AbstractMetaClass *cppClass,
-                                                 const AbstractMetaFunction *func) const
+                                                 const AbstractMetaFunctionCPtr &func) const
 {
     s << '\n';
     const AbstractMetaArgumentList &funcArgs = func->arguments();
@@ -743,7 +744,7 @@ void QtDocGenerator::writeFunctionParametersType(TextStream &s, const AbstractMe
 }
 
 void QtDocGenerator::writeFunction(TextStream& s, const AbstractMetaClass* cppClass,
-                                   const AbstractMetaFunction* func, bool indexed)
+                                   const AbstractMetaFunctionCPtr &func, bool indexed)
 {
     s << functionSignature(cppClass, func);
 
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
index 356a0e210..e68a5f451 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
@@ -81,11 +81,11 @@ private:
 
     void writeFields(TextStream &s, const AbstractMetaClass *cppClass) const;
     static QString functionSignature(const AbstractMetaClass* cppClass,
-                                     const AbstractMetaFunction* func);
+                                     const AbstractMetaFunctionCPtr &func);
     void writeFunction(TextStream& s, const AbstractMetaClass* cppClass,
-                       const AbstractMetaFunction* func, bool indexed = true);
+                       const AbstractMetaFunctionCPtr &func, bool indexed = true);
     void writeFunctionParametersType(TextStream &s, const AbstractMetaClass *cppClass,
-                                     const AbstractMetaFunction* func) const;
+                                     const AbstractMetaFunctionCPtr &func) const;
     void writeFunctionList(TextStream& s, const AbstractMetaClass* cppClass);
     void writeFunctionBlock(TextStream& s, const QString& title, QStringList& functions);
     void writeParameterType(TextStream &s, const AbstractMetaClass *cppClass,
@@ -95,13 +95,16 @@ private:
     void writeFormattedText(TextStream &s, const Documentation &doc,
                             const AbstractMetaClass *metaclass = nullptr,
                             Documentation::Type docType = Documentation::Detailed) const;
-    bool writeInjectDocumentation(TextStream& s, TypeSystem::DocModificationMode mode, const AbstractMetaClass* cppClass, const AbstractMetaFunction* func);
+    bool writeInjectDocumentation(TextStream& s, TypeSystem::DocModificationMode mode,
+                                  const AbstractMetaClass* cppClass,
+                                  const AbstractMetaFunctionCPtr &func);
     void writeDocSnips(TextStream &s, const CodeSnipList &codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language);
 
     void writeModuleDocumentation();
     void writeAdditionalDocumentation() const;
 
-    static QString parseArgDocStyle(const AbstractMetaClass *cppClass, const AbstractMetaFunction *func);
+    static QString parseArgDocStyle(const AbstractMetaClass *cppClass,
+                                    const AbstractMetaFunctionCPtr &func);
     QString translateToPythonType(const AbstractMetaType &type, const AbstractMetaClass *cppClass) const;
 
     QString m_docDataDir;
diff --git a/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp b/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp
index 45dd1557e..ba4e74cb2 100644
--- a/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtxmltosphinx.cpp
@@ -413,15 +413,15 @@ QString QtXmlToSphinx::resolveContextForMethod(const QString& methodName) const
     }
 
     if (metaClass) {
-        AbstractMetaFunctionList funcList;
-        const AbstractMetaFunctionList &methods = metaClass->queryFunctionsByName(methodName);
-        for (AbstractMetaFunction *func : methods) {
+        AbstractMetaFunctionCList funcList;
+        const auto &methods = metaClass->queryFunctionsByName(methodName);
+        for (const auto &func : methods) {
             if (methodName == func->name())
                 funcList.append(func);
         }
 
         const AbstractMetaClass *implementingClass = nullptr;
-        for (AbstractMetaFunction *func : qAsConst(funcList)) {
+        for (const auto &func : qAsConst(funcList)) {
             implementingClass = func->implementingClass();
             if (implementingClass->name() == currentClass)
                 break;
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 10c49d807..8d46d44cd 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -207,15 +207,15 @@ QString CppGenerator::fileNameForContext(const GeneratorContext &context) const
     return fileNameBase + fileNameSuffix();
 }
 
-QList<AbstractMetaFunctionList>
+QList<AbstractMetaFunctionCList>
     CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass,
                                                  uint queryIn)
 {
     // ( func_name, num_args ) => func_list
-    QMap<QPair<QString, int>, AbstractMetaFunctionList> results;
+    QMap<QPair<QString, int>, AbstractMetaFunctionCList> results;
     const AbstractMetaClass::OperatorQueryOptions query(queryIn);
-    const AbstractMetaFunctionList &funcs = metaClass->operatorOverloads(query);
-    for (AbstractMetaFunction *func : funcs) {
+    const auto &funcs = metaClass->operatorOverloads(query);
+    for (const auto &func : funcs) {
         if (func->isModifiedRemoved()
             || func->usesRValueReferences()
             || func->name() == QLatin1String("operator[]")
@@ -232,26 +232,28 @@ QList<AbstractMetaFunctionList>
         QPair<QString, int > op(func->name(), args);
         results[op].append(func);
     }
-    QList<AbstractMetaFunctionList> result;
+    QList<AbstractMetaFunctionCList> result;
     result.reserve(results.size());
     for (auto it = results.cbegin(), end = results.cend(); it != end; ++it)
         result.append(it.value());
     return result;
 }
 
-const AbstractMetaFunction *CppGenerator::boolCast(const AbstractMetaClass *metaClass) const
+AbstractMetaFunctionCPtr CppGenerator::boolCast(const AbstractMetaClass *metaClass) const
 {
     if (!useIsNullAsNbNonZero())
-        return nullptr;
+        return {};
     // TODO: This could be configurable someday
-    const AbstractMetaFunction *func = metaClass->findFunction(QLatin1String("isNull"));
-    if (!func || func->isVoid() || !func->type().typeEntry()->isPrimitive() || !func->isPublic())
-        return nullptr;
+    const auto func = metaClass->findFunction(QLatin1String("isNull"));
+    if (func.isNull() || func->isVoid() || !func->type().typeEntry()->isPrimitive()
+        || !func->isPublic()) {
+        return {};
+    }
     auto pte = static_cast<const PrimitiveTypeEntry *>(func->type().typeEntry());
     while (pte->referencedTypeEntry())
         pte = pte->referencedTypeEntry();
-    return func && func->isConstant() && pte->name() == QLatin1String("bool")
-        && func->arguments().isEmpty() ? func : nullptr;
+    return func->isConstant() && pte->name() == QLatin1String("bool")
+            && func->arguments().isEmpty() ? func : AbstractMetaFunctionCPtr{};
 }
 
 std::optional<AbstractMetaType>
@@ -273,8 +275,6 @@ void CppGenerator::clearTpFuncs()
     };
 }
 
-using FunctionGroupMap = QMap<QString, AbstractMetaFunctionList>;
-
 // Prevent ELF symbol qt_version_tag from being generated into the source
 static const char includeQDebug[] =
 "#ifndef QT_NO_VERSION_TAGGING\n"
@@ -477,10 +477,10 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
             s << "}\n\n";
         }
 
-        const AbstractMetaFunctionList &funcs = filterFunctions(metaClass);
+        const auto &funcs = filterFunctions(metaClass);
         int maxOverrides = 0;
         writeCacheResetNative(s, classContext);
-        for (const AbstractMetaFunction *func : funcs) {
+        for (const auto &func : funcs) {
             const bool notAbstract = !func->isAbstract();
             if ((func->isPrivate() && notAbstract && !func->isVisibilityModifiedToPrivate())
                 || (func->isModifiedRemoved() && notAbstract))
@@ -506,10 +506,10 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
         << "extern \"C\" {\n";
     const auto &functionGroups = getFunctionGroups(metaClass);
     for (auto it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
-        AbstractMetaFunctionList overloads;
+        AbstractMetaFunctionCList overloads;
         QSet<QString> seenSignatures;
         bool staticEncountered = false;
-        for (AbstractMetaFunction *func : it.value()) {
+        for (const auto &func : it.value()) {
             if (!func->isAssignmentOperator()
                 && !func->usesRValueReferences()
                 && !func->isCastOperator()
@@ -533,14 +533,14 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
         if (!staticEncountered) {
             for (int i = overloads.size() - 1; i >= 0; --i) {
                 if (overloads.at(i)->isStatic())
-                    delete overloads.takeAt(i);
+                    overloads.removeAt(i);
             }
         }
 
         if (overloads.isEmpty())
             continue;
 
-        const AbstractMetaFunction *rfunc = overloads.constFirst();
+        const auto rfunc = overloads.constFirst();
         if (contains(sequenceProtocols(), rfunc->name())
             || contains(mappingProtocols(), rfunc->name())) {
             continue;
@@ -578,8 +578,8 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
                     auto pointerToInnerType =
                             buildAbstractMetaTypeFromString(pointerToInnerTypeName);
                     Q_ASSERT(pointerToInnerType.has_value());
-                    AbstractMetaFunction *mutableRfunc = overloads.constFirst();
-                    mutableRfunc->setType(pointerToInnerType.value());
+                    auto mutableRfunc = overloads.constFirst();
+                    qSharedPointerConstCast<AbstractMetaFunction>(mutableRfunc)->setType(pointerToInnerType.value());
                 } else if (smartPointerTypeEntry->refCountMethodName().isEmpty()
                            || smartPointerTypeEntry->refCountMethodName() != rfunc->name()) {
                     // Skip all public methods of the smart pointer except for the raw getter and
@@ -652,7 +652,8 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
             writeSetattroFunction(s, attroCheck, classContext);
     }
 
-    if (const AbstractMetaFunction *f = boolCast(metaClass)) {
+    const auto f = boolCast(metaClass);
+    if (!f.isNull()) {
         ErrorCode errorCode(-1);
         s << "static int " << cpythonBaseName(metaClass) << "___nb_bool(PyObject *self)\n"
             << "{\n" << indent;
@@ -670,15 +671,15 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
     }
 
     if (supportsNumberProtocol(metaClass) && !metaClass->typeEntry()->isSmartPointer()) {
-        const QList<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
+        const QList<AbstractMetaFunctionCList> opOverloads = filterGroupedOperatorFunctions(
                 metaClass,
                 AbstractMetaClass::ArithmeticOp
                 | AbstractMetaClass::LogicalOp
                 | AbstractMetaClass::BitwiseOp);
 
-        for (const AbstractMetaFunctionList &allOverloads : opOverloads) {
-            AbstractMetaFunctionList overloads;
-            for (AbstractMetaFunction *func : allOverloads) {
+        for (const AbstractMetaFunctionCList &allOverloads : opOverloads) {
+            AbstractMetaFunctionCList overloads;
+            for (const auto &func : allOverloads) {
                 if (!func->isModifiedRemoved()
                     && !func->isPrivate()
                     && (func->ownerClass() == func->implementingClass() || func->isAbstract()))
@@ -790,7 +791,7 @@ void CppGenerator::writeCacheResetNative(TextStream &s, const GeneratorContext &
 }
 
 void CppGenerator::writeConstructorNative(TextStream &s, const GeneratorContext &classContext,
-                                          const AbstractMetaFunction *func) const
+                                          const AbstractMetaFunctionCPtr &func) const
 {
     const QString qualifiedName = classContext.wrapperName() + QLatin1String("::");
     s << functionSignature(func, qualifiedName, QString(),
@@ -821,7 +822,7 @@ Shiboken::Object::destroy(wrapper, this);
 )" << outdent << "}\n";
 }
 
-static bool allArgumentsRemoved(const AbstractMetaFunction *func)
+static bool allArgumentsRemoved(const AbstractMetaFunctionCPtr& func)
 {
     if (func->arguments().isEmpty())
         return false;
@@ -833,7 +834,7 @@ static bool allArgumentsRemoved(const AbstractMetaFunction *func)
     return true;
 }
 
-QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunction *func) const
+QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctionCPtr &func) const
 {
     if (func->type().isVoid())
         return QLatin1String("\"\"");
@@ -869,7 +870,7 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
 // When writing an overridden method of a wrapper class, write the part
 // calling the C++ function in case no overload in Python exists.
 void CppGenerator::writeVirtualMethodCppCall(TextStream &s,
-                                             const AbstractMetaFunction *func,
+                                             const AbstractMetaFunctionCPtr &func,
                                              const QString &funcName,
                                              const CodeSnipList &snips,
                                              const AbstractMetaArgument *lastArg,
@@ -905,7 +906,7 @@ void CppGenerator::writeVirtualMethodCppCall(TextStream &s,
 
 // Determine the return statement (void or a result value).
 QString CppGenerator::virtualMethodReturn(TextStream &s,
-                                          const AbstractMetaFunction *func,
+                                          const AbstractMetaFunctionCPtr &func,
                                           const FunctionModificationList &functionModifications) const
 {
     if (func->isVoid())
@@ -958,7 +959,7 @@ QString CppGenerator::virtualMethodReturn(TextStream &s,
 }
 
 void CppGenerator::writeVirtualMethodNative(TextStream &s,
-                                            const AbstractMetaFunction *func,
+                                            const AbstractMetaFunctionCPtr &func,
                                             int cacheIndex) const
 {
     //skip metaObject function, this will be written manually ahead
@@ -978,7 +979,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
     const QString returnStatement = virtualMethodReturn(s, func, functionModifications);
 
     if (func->isAbstract() && func->isModifiedRemoved()) {
-        qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func)));
+        qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func.data())));
         s << returnStatement << '\n' << outdent << "}\n\n";
         return;
     }
@@ -1255,14 +1256,11 @@ void CppGenerator::writeMetaObjectMethod(TextStream &s,
     s << "int " << wrapperClassName << "::qt_metacall(QMetaObject::Call call, int id, void **args)\n";
     s << "{\n" << indent;
 
-    AbstractMetaFunction *func = nullptr;
-    AbstractMetaFunctionList list =
-        classContext.metaClass()->queryFunctionsByName(QLatin1String("qt_metacall"));
-    if (list.size() == 1)
-        func = list[0];
+    const auto list = classContext.metaClass()->queryFunctionsByName(QLatin1String("qt_metacall"));
 
     CodeSnipList snips;
-    if (func) {
+    if (list.size() == 1) {
+        const auto func = list.constFirst();
         snips = func->injectedCodeSnips();
         if (func->isUserAdded()) {
             CodeSnipList snips = func->injectedCodeSnips();
@@ -1506,10 +1504,10 @@ return result;)";
     CustomConversion *customConversion = metaClass->typeEntry()->customConversion();
 
     // Implicit conversions.
-    AbstractMetaFunctionList implicitConvs;
+    AbstractMetaFunctionCList implicitConvs;
     if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
-        const AbstractMetaFunctionList &allImplicitConvs = implicitConversions(metaClass->typeEntry());
-        for (AbstractMetaFunction *func : allImplicitConvs) {
+        const auto &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+        for (const auto &func : allImplicitConvs) {
             if (!func->isUserAdded())
                 implicitConvs << func;
         }
@@ -1519,7 +1517,7 @@ return result;)";
         s << "// Implicit conversions.\n";
 
     AbstractMetaType targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
-    for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) {
+    for (const auto &conv : qAsConst(implicitConvs)) {
         if (conv->isModifiedRemoved())
             continue;
 
@@ -1693,10 +1691,10 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
     CustomConversion *customConversion = metaClass->typeEntry()->customConversion();
 
     // Add implicit conversions.
-    AbstractMetaFunctionList implicitConvs;
+    AbstractMetaFunctionCList implicitConvs;
     if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
-        const AbstractMetaFunctionList &allImplicitConvs = implicitConversions(metaClass->typeEntry());
-        for (AbstractMetaFunction *func : allImplicitConvs) {
+        const auto &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+        for (const auto &func : allImplicitConvs) {
             if (!func->isUserAdded())
                 implicitConvs << func;
         }
@@ -1706,7 +1704,7 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
         s << "// Add implicit conversions to type converter.\n";
 
     AbstractMetaType targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
-    for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) {
+    for (const auto &conv : qAsConst(implicitConvs)) {
         if (conv->isModifiedRemoved())
             continue;
         AbstractMetaType sourceType;
@@ -1778,7 +1776,7 @@ void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s,
 void CppGenerator::writeMethodWrapperPreamble(TextStream &s, OverloadData &overloadData,
                                               const GeneratorContext &context) const
 {
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
     const AbstractMetaClass *ownerClass = rfunc->targetLangOwner();
     Q_ASSERT(ownerClass == context.metaClass());
     int minArgs = overloadData.minArgs();
@@ -1852,13 +1850,13 @@ static const char *fullName = ")" << fullPythonFunctionName(rfunc, true)
     }
 }
 
-void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunctionList &overloads,
+void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunctionCList &overloads,
                                            const GeneratorContext &classContext) const
 {
     ErrorCode errorCode(-1);
     OverloadData overloadData(overloads, this);
 
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
     const AbstractMetaClass *metaClass = rfunc->ownerClass();
 
     s << "static int\n";
@@ -1949,7 +1947,7 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunc
 
     // Constructor code injections, position=end
     bool hasCodeInjectionsAtEnd = false;
-    for (AbstractMetaFunction *func : overloads) {
+    for (const auto &func : overloads) {
         const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips();
         for (const CodeSnip &cs : injectedCodeSnips) {
             if (cs.position == TypeSystem::CodeSnipPositionEnd) {
@@ -1961,7 +1959,7 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunc
     if (hasCodeInjectionsAtEnd) {
         // FIXME: C++ arguments are not available in code injection on constructor when position = end.
         s <<"switch (overloadId) {\n";
-        for (AbstractMetaFunction *func : overloads) {
+        for (const auto &func : overloads) {
             Indentation indent(s);
             const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips();
             for (const CodeSnip &cs : injectedCodeSnips) {
@@ -1986,11 +1984,11 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunc
     s<< outdent << "}\n\n";
 }
 
-void CppGenerator::writeMethodWrapper(TextStream &s, const AbstractMetaFunctionList &overloads,
+void CppGenerator::writeMethodWrapper(TextStream &s, const AbstractMetaFunctionCList &overloads,
                                       const GeneratorContext &classContext) const
 {
     OverloadData overloadData(overloads, this);
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
 
     int maxArgs = overloadData.maxArgs();
 
@@ -2098,7 +2096,7 @@ void CppGenerator::writeMethodWrapper(TextStream &s, const AbstractMetaFunctionL
 
 void CppGenerator::writeArgumentsInitializer(TextStream &s, OverloadData &overloadData) const
 {
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
     s << "PyTuple_GET_SIZE(args);\n";
     writeUnusedVariableCast(s, QLatin1String("numArgs"));
 
@@ -2258,7 +2256,7 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s,
 }
 
 void CppGenerator::writeCppSelfDefinition(TextStream &s,
-                                          const AbstractMetaFunction *func,
+                                          const AbstractMetaFunctionCPtr &func,
                                           const GeneratorContext &context,
                                           bool hasStaticOverload) const
 {
@@ -2282,7 +2280,7 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s,
 
 void CppGenerator::writeErrorSection(TextStream &s, OverloadData &overloadData) const
 {
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
     s  << '\n' << cpythonFunctionName(rfunc) << "_TypeError:\n";
     Indentation indentation(s);
     QString funcName = fullPythonFunctionName(rfunc, true);
@@ -2366,7 +2364,8 @@ void CppGenerator::writeTypeCheck(TextStream &s, AbstractMetaType argType,
     s << typeCheck;
 }
 
-static void checkTypeViability(const AbstractMetaFunction *func, const AbstractMetaType &type, int argIdx)
+static void checkTypeViability(const AbstractMetaFunctionCPtr &func,
+                               const AbstractMetaType &type, int argIdx)
 {
     if (type.isVoid()
         || !type.typeEntry()->isPrimitive()
@@ -2394,7 +2393,7 @@ static void checkTypeViability(const AbstractMetaFunction *func, const AbstractM
     qCWarning(lcShiboken).noquote().nospace() << message;
 }
 
-static void checkTypeViability(const AbstractMetaFunction *func)
+static void checkTypeViability(const AbstractMetaFunctionCPtr &func)
 {
     if (func->isUserAdded())
         return;
@@ -2409,8 +2408,7 @@ void CppGenerator::writeTypeCheck(TextStream &s, const OverloadData *overloadDat
     QSet<const TypeEntry *> numericTypes;
     const OverloadDataList &overloads = overloadData->previousOverloadData()->nextOverloadData();
     for (OverloadData *od : overloads) {
-        const AbstractMetaFunctionCList &odOverloads = od->overloads();
-        for (const AbstractMetaFunction *func : odOverloads) {
+        for (const auto &func : od->overloads()) {
             checkTypeViability(func);
             const AbstractMetaType &argType = od->argument(func)->type();
             if (!argType.isPrimitive())
@@ -2460,7 +2458,7 @@ static const QStringList &knownPythonTypes()
 }
 
 std::optional<AbstractMetaType>
-    CppGenerator::getArgumentType(const AbstractMetaFunction *func, int argPos) const
+    CppGenerator::getArgumentType(const AbstractMetaFunctionCPtr &func, int argPos) const
 {
     if (argPos < 0 || argPos > func->arguments().size()) {
         qCWarning(lcShiboken).noquote().nospace()
@@ -2479,7 +2477,7 @@ std::optional<AbstractMetaType>
     auto argType = buildAbstractMetaTypeFromString(typeReplaced);
     if (!argType.has_value() && !knownPythonTypes().contains(typeReplaced)) {
         qCWarning(lcShiboken, "%s",
-                  qPrintable(msgUnknownTypeInArgumentTypeReplacement(typeReplaced, func)));
+                  qPrintable(msgUnknownTypeInArgumentTypeReplacement(typeReplaced, func.data())));
     }
     return argType;
 }
@@ -2630,7 +2628,7 @@ static void addConversionRuleCodeSnippet(CodeSnipList &snippetList, QString &rul
     snippetList << snip;
 }
 
-void CppGenerator::writeConversionRule(TextStream &s, const AbstractMetaFunction *func,
+void CppGenerator::writeConversionRule(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                        TypeSystem::Language language) const
 {
 
@@ -2644,7 +2642,7 @@ void CppGenerator::writeConversionRule(TextStream &s, const AbstractMetaFunction
     writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, func);
 }
 
-void CppGenerator::writeConversionRule(TextStream &s, const AbstractMetaFunction *func,
+void CppGenerator::writeConversionRule(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                        TypeSystem::Language language, const QString &outputVar) const
 {
     CodeSnipList snippets;
@@ -2653,7 +2651,7 @@ void CppGenerator::writeConversionRule(TextStream &s, const AbstractMetaFunction
     writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionAny, language, func);
 }
 
-void CppGenerator::writeNoneReturn(TextStream &s, const AbstractMetaFunction *func,
+void CppGenerator::writeNoneReturn(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                    bool thereIsReturnValue)
 {
     if (thereIsReturnValue && (func->isVoid() || func->argumentRemoved(0))
@@ -2666,7 +2664,7 @@ void CppGenerator::writeNoneReturn(TextStream &s, const AbstractMetaFunction *fu
 void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s, const OverloadData &overloadData) const
 {
     s << "// Overloaded function decisor\n";
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
     const AbstractMetaFunctionCList &functionOverloads = overloadData.overloadsWithoutRepetition();
     for (int i = 0; i < functionOverloads.count(); i++) {
         const auto func = functionOverloads.at(i);
@@ -2701,7 +2699,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
                                                         const OverloadData *parentOverloadData) const
 {
     bool hasDefaultCall = parentOverloadData->nextArgumentHasDefaultValue();
-    const AbstractMetaFunction *referenceFunction = parentOverloadData->referenceFunction();
+    auto referenceFunction = parentOverloadData->referenceFunction();
 
     // If the next argument has not an argument with a default value, it is still possible
     // that one of the overloads for the current overload data has its final occurrence here.
@@ -2709,8 +2707,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
     // variable to be used further on this method on the conditional that identifies default
     // method calls.
     if (!hasDefaultCall) {
-        const AbstractMetaFunctionCList &overloads = parentOverloadData->overloads();
-        for (const AbstractMetaFunction *func : overloads) {
+        for (const auto &func : parentOverloadData->overloads()) {
             if (parentOverloadData->isFinalOccurrence(func)) {
                 referenceFunction = func;
                 hasDefaultCall = true;
@@ -2740,7 +2737,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
         // The current overload data describes the last argument of a signature,
         // so the method can be identified right now.
         if (isLastArgument || (signatureFound && !hasDefaultCall)) {
-            const AbstractMetaFunction *func = parentOverloadData->referenceFunction();
+            const auto func = parentOverloadData->referenceFunction();
             s << "overloadId = " << parentOverloadData->headOverloadData()->overloads().indexOf(func)
                 << "; // " << func->minimalSignature() << '\n';
             return;
@@ -2759,10 +2756,10 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
         s << "if (numArgs == " << numArgs << ") {\n";
         {
             Indentation indent(s);
-            const AbstractMetaFunction *func = referenceFunction;
+            auto func = referenceFunction;
             for (OverloadData *overloadData : overloads) {
-                const AbstractMetaFunction *defValFunc = overloadData->getFunctionWithDefaultValue();
-                if (defValFunc) {
+                const auto defValFunc = overloadData->getFunctionWithDefaultValue();
+                if (!defValFunc.isNull()) {
                     func = defValFunc;
                     break;
                 }
@@ -2778,7 +2775,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
                                 && !overloadData->getFunctionWithDefaultValue()
                                 && !overloadData->findNextArgWithDefault();
 
-        const AbstractMetaFunction *refFunc = overloadData->referenceFunction();
+        const auto refFunc = overloadData->referenceFunction();
 
         QStringList typeChecks;
 
@@ -2794,7 +2791,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
                 if (usePyArgs)
                     pyArgName = pythonArgsAt(od->argPos());
                 StringStream tck(TextStream::Language::Cpp);
-                const AbstractMetaFunction *func = od->referenceFunction();
+                auto func = od->referenceFunction();
 
                 if (func->isConstructor() && func->arguments().count() == 1) {
                     const AbstractMetaClass *ownerClass = func->ownerClass();
@@ -2874,7 +2871,7 @@ void CppGenerator::writeFunctionCalls(TextStream &s, const OverloadData &overloa
             writeSingleFunctionCall(s, overloadData, overloads.constFirst(), context);
         } else {
             for (int i = 0; i < overloads.count(); i++) {
-                const AbstractMetaFunction *func = overloads.at(i);
+                const auto func = overloads.at(i);
                 s << "case " << i << ": // " << func->signature() << "\n{\n";
                 {
                     Indentation indent(s);
@@ -2896,7 +2893,7 @@ void CppGenerator::writeFunctionCalls(TextStream &s, const OverloadData &overloa
 
 void CppGenerator::writeSingleFunctionCall(TextStream &s,
                                            const OverloadData &overloadData,
-                                           const AbstractMetaFunction *func,
+                                           const AbstractMetaFunctionCPtr &func,
                                            const GeneratorContext &context) const
 {
     if (func->isDeprecated()) {
@@ -3240,7 +3237,7 @@ void CppGenerator::writeAddPythonToCppConversion(TextStream &s, const QString &c
     s << ");\n";
 }
 
-void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMetaFunction *func,
+void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                                 bool usePyArgs, const OverloadData &overloadData) const
 {
     const AbstractMetaArgumentList &args = OverloadData::getArgumentsWithDefaultValues(func);
@@ -3320,7 +3317,7 @@ void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMet
     s << "}\n";
 }
 
-QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction *func, int argIndex,
+QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunctionCPtr &func, int argIndex,
                                             const AbstractMetaClass **wrappedClass,
                                             QString *errorMessage) const
 {
@@ -3372,7 +3369,7 @@ const char defaultExceptionHandling[] = R"(} catch (const std::exception &e) {
 }
 )";
 
-void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunction *func,
+void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                    const GeneratorContext &context, int maxArgs) const
 {
     s << "// " << func->minimalSignature() << (func->isReverseOperator() ? " [reverse operator]": "") << '\n';
@@ -3382,7 +3379,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunction *fu
             if (cs.position == TypeSystem::CodeSnipPositionEnd) {
                 auto klass = func->ownerClass();
                 s << "overloadId = "
-                  << klass->functions().indexOf(const_cast<AbstractMetaFunction *>(func))
+                  << klass->functions().indexOf(func)
                   << ";\n";
                 break;
             }
@@ -4168,9 +4165,9 @@ void CppGenerator::writeClassDefinition(TextStream &s,
     QString cppClassName = metaClass->qualifiedCppName();
     const QString className = chopType(cpythonTypeName(metaClass));
     QString baseClassName;
-    AbstractMetaFunctionList ctors;
-    const AbstractMetaFunctionList &allCtors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
-    for (AbstractMetaFunction *f : allCtors) {
+    AbstractMetaFunctionCList ctors;
+    const auto &allCtors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
+    for (const auto &f : allCtors) {
         if (!f->isPrivate() && !f->isModifiedRemoved() && !classContext.forSmartPointer())
             ctors.append(f);
     }
@@ -4242,8 +4239,7 @@ void CppGenerator::writeClassDefinition(TextStream &s,
 
     // search for special functions
     clearTpFuncs();
-    const AbstractMetaFunctionList &funcs = metaClass->functions();
-    for (AbstractMetaFunction *func : funcs) {
+    for (const auto &func : metaClass->functions()) {
         if (m_tpFuncs.contains(func->name()))
             m_tpFuncs[func->name()] = cpythonFunctionName(func);
     }
@@ -4269,8 +4265,8 @@ void CppGenerator::writeClassDefinition(TextStream &s,
     if (!metaClass->typeEntry()->hashFunction().isEmpty())
         tp_hash = QLatin1Char('&') + cpythonBaseName(metaClass) + QLatin1String("_HashFunc");
 
-    const AbstractMetaFunction *callOp = metaClass->findFunction(QLatin1String("operator()"));
-    if (callOp && !callOp->isModifiedRemoved())
+    const auto callOp = metaClass->findFunction(QLatin1String("operator()"));
+    if (!callOp.isNull() && !callOp->isModifiedRemoved())
         tp_call = QLatin1Char('&') + cpythonFunctionName(callOp);
 
     QString computedClassTargetFullName;
@@ -4330,8 +4326,8 @@ void CppGenerator::writeMappingMethods(TextStream &s,
                                        const GeneratorContext &context) const
 {
     for (const auto & m : mappingProtocols()) {
-        const AbstractMetaFunction *func = metaClass->findFunction(m.name);
-        if (!func)
+        const auto func = metaClass->findFunction(m.name);
+        if (func.isNull())
             continue;
         QString funcName = cpythonFunctionName(func);
         CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
@@ -4354,8 +4350,8 @@ void CppGenerator::writeSequenceMethods(TextStream &s,
     bool injectedCode = false;
 
     for (const auto &seq : sequenceProtocols()) {
-        const AbstractMetaFunction *func = metaClass->findFunction(seq.name);
-        if (!func)
+        const auto func = metaClass->findFunction(seq.name);
+        if (func.isNull())
             continue;
         injectedCode = true;
         QString funcName = cpythonFunctionName(func);
@@ -4395,7 +4391,8 @@ void CppGenerator::writeTypeAsSequenceDefinition(TextStream &s, const AbstractMe
     bool hasFunctions = false;
     QMap<QString, QString> funcs;
     for (const auto &seq : sequenceProtocols()) {
-        if (const AbstractMetaFunction *func = metaClass->findFunction(seq.name)) {
+        const auto func = metaClass->findFunction(seq.name);
+        if (!func.isNull()) {
             funcs.insert(seq.name, QLatin1Char('&') + cpythonFunctionName(func));
             hasFunctions = true;
         }
@@ -4430,7 +4427,8 @@ void CppGenerator::writeTypeAsMappingDefinition(TextStream &s, const AbstractMet
     };
     QMap<QString, QString> funcs;
     for (const auto &m : mappingProtocols()) {
-        if (const AbstractMetaFunction *func = metaClass->findFunction(m.name)) {
+        const auto func = metaClass->findFunction(m.name);
+        if (!func.isNull()) {
             const QString entry = QLatin1String("reinterpret_cast<void *>(&")
                                   + cpythonFunctionName(func) + QLatin1Char(')');
             funcs.insert(m.name, entry);
@@ -4482,14 +4480,14 @@ void CppGenerator::writeTypeAsNumberDefinition(TextStream &s, const AbstractMeta
 {
     QMap<QString, QString> nb;
 
-    const QList<AbstractMetaFunctionList> opOverloads =
+    const QList<AbstractMetaFunctionCList> opOverloads =
             filterGroupedOperatorFunctions(metaClass,
                                            AbstractMetaClass::ArithmeticOp
                                            | AbstractMetaClass::LogicalOp
                                            | AbstractMetaClass::BitwiseOp);
 
-    for (const AbstractMetaFunctionList &opOverload : opOverloads) {
-        const AbstractMetaFunction *rfunc = opOverload.at(0);
+    for (const AbstractMetaFunctionCList &opOverload : opOverloads) {
+        const auto rfunc = opOverload.at(0);
         QString opName = ShibokenGenerator::pythonOperatorFunctionName(rfunc);
         nb[opName] = cpythonFunctionName(rfunc);
     }
@@ -4781,9 +4779,10 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
     s << "switch (op) {\n";
     {
         Indentation indent(s);
-        const QList<AbstractMetaFunctionList> &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
-        for (const AbstractMetaFunctionList &overloads : groupedFuncs) {
-            const AbstractMetaFunction *rfunc = overloads[0];
+        const QList<AbstractMetaFunctionCList> &groupedFuncs =
+            filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
+        for (const AbstractMetaFunctionCList &overloads : groupedFuncs) {
+            const auto rfunc = overloads[0];
 
             QString operatorId = ShibokenGenerator::pythonRichCompareOperatorId(rfunc);
             s << "case " << operatorId << ':' << '\n';
@@ -4794,7 +4793,7 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
             op = op.right(op.size() - QLatin1String("operator").size());
 
             int alternativeNumericTypes = 0;
-            for (const AbstractMetaFunction *func : overloads) {
+            for (const auto &func : overloads) {
                 if (!func->isStatic() &&
                     ShibokenGenerator::isNumber(func->arguments().at(0).type().typeEntry()))
                     alternativeNumericTypes++;
@@ -4804,7 +4803,7 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
             OverloadData overloadData(overloads, this);
             const OverloadDataList &nextOverloads = overloadData.nextOverloadData();
             for (OverloadData *od : nextOverloads) {
-                const AbstractMetaFunction *func = od->referenceFunction();
+                const auto func = od->referenceFunction();
                 if (func->isStatic())
                     continue;
                 auto argTypeO = getArgumentType(func, 1);
@@ -4893,12 +4892,12 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
         << outdent << "}\n\n";
 }
 
-void CppGenerator::writeMethodDefinitionEntry(TextStream &s, const AbstractMetaFunctionList &overloads) const
+void CppGenerator::writeMethodDefinitionEntry(TextStream &s, const AbstractMetaFunctionCList &overloads) const
 {
     Q_ASSERT(!overloads.isEmpty());
     OverloadData overloadData(overloads, this);
     bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(overloadData);
-    const AbstractMetaFunction *func = overloadData.referenceFunction();
+    const auto func = overloadData.referenceFunction();
     int min = overloadData.minArgs();
     int max = overloadData.maxArgs();
 
@@ -4924,10 +4923,10 @@ void CppGenerator::writeMethodDefinitionEntry(TextStream &s, const AbstractMetaF
     }
 }
 
-void CppGenerator::writeMethodDefinition(TextStream &s, const AbstractMetaFunctionList &overloads) const
+void CppGenerator::writeMethodDefinition(TextStream &s, const AbstractMetaFunctionCList &overloads) const
 {
     Q_ASSERT(!overloads.isEmpty());
-    const AbstractMetaFunction *func = overloads.constFirst();
+    const auto func = overloads.constFirst();
     if (m_tpFuncs.contains(func->name()))
         return;
 
@@ -4941,16 +4940,16 @@ void CppGenerator::writeMethodDefinition(TextStream &s, const AbstractMetaFuncti
     s << ',' << '\n';
 }
 
-void CppGenerator::writeSignatureInfo(TextStream &s, const AbstractMetaFunctionList &overloads) const
+void CppGenerator::writeSignatureInfo(TextStream &s, const AbstractMetaFunctionCList &overloads) const
 {
     OverloadData overloadData(overloads, this);
-    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const auto rfunc = overloadData.referenceFunction();
     QString funcName = fullPythonFunctionName(rfunc, false);
 
     int idx = overloads.length() - 1;
     bool multiple = idx > 0;
 
-    for (const AbstractMetaFunction *f : overloads) {
+    for (const auto &f : overloads) {
         QStringList args;
         // PYSIDE-1328: `self`-ness cannot be computed in Python because there are mixed cases.
         // Toplevel functions like `PySide6.QtCore.QEnum` are always self-less.
@@ -5130,8 +5129,8 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum
 void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaClass *metaClass)
 {
     // Try to check something and print some warnings
-    const AbstractMetaFunctionList &signalFuncs = metaClass->cppSignalFunctions();
-    for (const AbstractMetaFunction *cppSignal : signalFuncs) {
+    const auto &signalFuncs = metaClass->cppSignalFunctions();
+    for (const auto &cppSignal : signalFuncs) {
         if (cppSignal->declaringClass() != metaClass)
             continue;
         const AbstractMetaArgumentList &arguments = cppSignal->arguments();
@@ -5548,8 +5547,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const Generato
         bool canBeValue = false;
         if (!metaClass->isObjectType()) {
             // check if there's a empty ctor
-            const AbstractMetaFunctionList &funcs = metaClass->functions();
-            for (AbstractMetaFunction *func : funcs) {
+            for (const auto &func : metaClass->functions()) {
                 if (func->isConstructor() && !func->arguments().count()) {
                     canBeValue = true;
                     break;
@@ -5777,8 +5775,8 @@ void CppGenerator::writeGetattroFunction(TextStream &s, AttroCheck attroCheck,
         }
         s << "}\n";
 
-        const AbstractMetaFunctionList &funcs = getMethodsWithBothStaticAndNonStaticMethods(metaClass);
-        for (const AbstractMetaFunction *func : funcs) {
+        const auto &funcs = getMethodsWithBothStaticAndNonStaticMethods(metaClass);
+        for (const auto &func : funcs) {
             QString defName = cpythonMethodDefinitionName(func);
             s << "static PyMethodDef non_static_" << defName << " = {\n";
             {
@@ -5892,8 +5890,8 @@ bool CppGenerator::finishGeneration()
 
     const auto functionGroups = getGlobalFunctionGroups();
     for (auto it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
-        AbstractMetaFunctionList overloads;
-        for (AbstractMetaFunction *func : it.value()) {
+        AbstractMetaFunctionCList overloads;
+        for (const auto &func : it.value()) {
             if (!func->isModifiedRemoved()) {
                 overloads.append(func);
                 if (func->typeEntry())
@@ -6248,7 +6246,7 @@ bool CppGenerator::finishGeneration()
     return file.done() != FileOut::Failure;
 }
 
-static ArgumentOwner getArgumentOwner(const AbstractMetaFunction *func, int argIndex)
+static ArgumentOwner getArgumentOwner(const AbstractMetaFunctionCPtr &func, int argIndex)
 {
     ArgumentOwner argOwner = func->argumentOwner(func->ownerClass(), argIndex);
     if (argOwner.index == ArgumentOwner::InvalidIndex)
@@ -6256,8 +6254,8 @@ static ArgumentOwner getArgumentOwner(const AbstractMetaFunction *func, int argI
     return argOwner;
 }
 
-bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunction *func, int argIndex,
-                                              bool useHeuristicPolicy) const
+bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                              int argIndex, bool useHeuristicPolicy) const
 {
     const int numArgs = func->arguments().count();
     bool ctorHeuristicEnabled = func->isConstructor() && useCtorHeuristic() && useHeuristicPolicy;
@@ -6316,7 +6314,7 @@ bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaF
     return false;
 }
 
-void CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunction *func,
+void CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                               bool useHeuristicForReturn) const
 {
     const int numArgs = func->arguments().count();
@@ -6331,7 +6329,7 @@ void CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaF
         writeReturnValueHeuristics(s, func);
 }
 
-void CppGenerator::writeReturnValueHeuristics(TextStream &s, const AbstractMetaFunction *func) const
+void CppGenerator::writeReturnValueHeuristics(TextStream &s, const AbstractMetaFunctionCPtr &func) const
 {
     const  AbstractMetaType &type = func->type();
     if (!useReturnValueHeuristic()
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h
index 0c5be6ebc..0539a19ec 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.h
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.h
@@ -44,7 +44,7 @@ public:
 protected:
     QString fileNameSuffix() const override;
     QString fileNameForContext(const GeneratorContext &context) const override;
-    static QList<AbstractMetaFunctionList>
+    static QList<AbstractMetaFunctionCList>
         filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass, uint query);
     void generateClass(TextStream &s, const GeneratorContext &classContext) override;
     bool finishGeneration() override;
@@ -55,18 +55,18 @@ private:
                        const TypeEntry *enclosingEntry = nullptr) const;
     void writeCacheResetNative(TextStream &s, const GeneratorContext &classContext) const;
     void writeConstructorNative(TextStream &s, const GeneratorContext &classContext,
-                                const AbstractMetaFunction *func) const;
+                                const AbstractMetaFunctionCPtr &func) const;
     void writeDestructorNative(TextStream &s, const GeneratorContext &classContext) const;
 
-    QString getVirtualFunctionReturnTypeName(const AbstractMetaFunction *func) const;
-    void writeVirtualMethodNative(TextStream &s, const AbstractMetaFunction *func,
+    QString getVirtualFunctionReturnTypeName(const AbstractMetaFunctionCPtr &func) const;
+    void writeVirtualMethodNative(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                   int cacheIndex) const;
-    void writeVirtualMethodCppCall(TextStream &s, const AbstractMetaFunction *func,
+    void writeVirtualMethodCppCall(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                    const QString &funcName, const CodeSnipList &snips,
                                    const AbstractMetaArgument *lastArg, const TypeEntry *retType,
                                    const QString &returnStatement) const;
     QString virtualMethodReturn(TextStream &s,
-                                const AbstractMetaFunction *func,
+                                const AbstractMetaFunctionCPtr &func,
                                 const FunctionModificationList &functionModifications) const;
     void writeMetaObjectMethod(TextStream &s, const GeneratorContext &classContext) const;
     void writeMetaCast(TextStream &s, const GeneratorContext &classContext) const;
@@ -90,15 +90,15 @@ private:
 
     void writeMethodWrapperPreamble(TextStream &s, OverloadData &overloadData,
                                     const GeneratorContext &context) const;
-    void writeConstructorWrapper(TextStream &s, const AbstractMetaFunctionList &overloads,
+    void writeConstructorWrapper(TextStream &s, const AbstractMetaFunctionCList &overloads,
                                  const GeneratorContext &classContext) const;
-    void writeMethodWrapper(TextStream &s, const AbstractMetaFunctionList &overloads,
+    void writeMethodWrapper(TextStream &s, const AbstractMetaFunctionCList &overloads,
                             const GeneratorContext &classContext) const;
     void writeArgumentsInitializer(TextStream &s, OverloadData &overloadData) const;
     void writeCppSelfConversion(TextStream &s, const GeneratorContext &context,
                                 const QString &className, bool useWrapperClass) const;
     void writeCppSelfDefinition(TextStream &s,
-                                const AbstractMetaFunction *func,
+                                const AbstractMetaFunctionCPtr &func,
                                 const GeneratorContext &context,
                                 bool hasStaticOverload = false) const;
     void writeCppSelfDefinition(TextStream &s,
@@ -162,7 +162,7 @@ private:
      *  \return The type of the argument indicated by \p argPos.
      */
     std::optional<AbstractMetaType>
-        getArgumentType(const AbstractMetaFunction *func, int argPos) const;
+        getArgumentType(const AbstractMetaFunctionCPtr &func, int argPos) const;
 
     void writePythonToCppTypeConversion(TextStream &s,
                                         const AbstractMetaType &type,
@@ -172,10 +172,11 @@ private:
                                         const QString &defaultValue = QString()) const;
 
     /// Writes the conversion rule for arguments of regular and virtual methods.
-    void writeConversionRule(TextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language) const;
+    void writeConversionRule(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                             TypeSystem::Language language) const;
     /// Writes the conversion rule for the return value of a method.
-    void writeConversionRule(TextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language,
-                             const QString &outputVar) const;
+    void writeConversionRule(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                             TypeSystem::Language language, const QString &outputVar) const;
 
     /**
      *   Set the Python method wrapper return value variable to Py_None if
@@ -186,7 +187,8 @@ private:
      *   \param thereIsReturnValue indicates if the return type of any of the other overloads
      *                             for this function is different from 'void'
      */
-    static void writeNoneReturn(TextStream &s, const AbstractMetaFunction *func, bool thereIsReturnValue);
+    static void writeNoneReturn(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                bool thereIsReturnValue);
 
     /**
      *   Writes the Python function wrapper overload decisor that selects which C++
@@ -207,7 +209,7 @@ private:
     /// Writes the call to a single function usually from a collection of overloads.
     void writeSingleFunctionCall(TextStream &s,
                                  const OverloadData &overloadData,
-                                 const AbstractMetaFunction *func,
+                                 const AbstractMetaFunctionCPtr &func,
                                  const GeneratorContext &context) const;
 
     /// Returns the name of a C++ to Python conversion function.
@@ -261,14 +263,14 @@ private:
                                        const QString &pythonToCppFunc,
                                        const QString &isConvertibleFunc) const;
 
-    void writeNamedArgumentResolution(TextStream &s, const AbstractMetaFunction *func,
+    void writeNamedArgumentResolution(TextStream &s, const AbstractMetaFunctionCPtr &func,
                                       bool usePyArgs, const OverloadData &overloadData) const;
 
     /// Returns a string containing the name of an argument for the given function and argument index.
-    QString argumentNameFromIndex(const AbstractMetaFunction *func, int argIndex,
+    QString argumentNameFromIndex(const AbstractMetaFunctionCPtr &func, int argIndex,
                                   const AbstractMetaClass **wrappedClass,
                                   QString *errorMessage = nullptr) const;
-    void writeMethodCall(TextStream &s, const AbstractMetaFunction *func,
+    void writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr &func,
                          const GeneratorContext &context, int maxArgs = 0) const;
 
     QString getInitFunctionName(const GeneratorContext &context) const;
@@ -284,9 +286,9 @@ private:
     void writeClassDefinition(TextStream &s,
                               const AbstractMetaClass *metaClass,
                               const GeneratorContext &classContext);
-    void writeMethodDefinitionEntry(TextStream &s, const AbstractMetaFunctionList &overloads) const;
-    void writeMethodDefinition(TextStream &s, const AbstractMetaFunctionList &overloads) const;
-    void writeSignatureInfo(TextStream &s, const AbstractMetaFunctionList &overloads) const;
+    void writeMethodDefinitionEntry(TextStream &s, const AbstractMetaFunctionCList &overloads) const;
+    void writeMethodDefinition(TextStream &s, const AbstractMetaFunctionCList &overloads) const;
+    void writeSignatureInfo(TextStream &s, const AbstractMetaFunctionCList &overloads) const;
     /// Writes the implementation of all methods part of python sequence protocol
     void writeSequenceMethods(TextStream &s,
                               const AbstractMetaClass *metaClass,
@@ -356,9 +358,11 @@ private:
     void writeExtendedConverterInitialization(TextStream &s, const TypeEntry *externalType,
                                               const AbstractMetaClassCList &conversions) const;
 
-    void writeParentChildManagement(TextStream &s, const AbstractMetaFunction *func, bool userHeuristicForReturn) const;
-    bool writeParentChildManagement(TextStream &s, const AbstractMetaFunction *func, int argIndex, bool userHeuristicPolicy) const;
-    void writeReturnValueHeuristics(TextStream &s, const AbstractMetaFunction *func) const;
+    void writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                    bool userHeuristicForReturn) const;
+    bool writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func,
+                                    int argIndex, bool userHeuristicPolicy) const;
+    void writeReturnValueHeuristics(TextStream &s, const AbstractMetaFunctionCPtr &func) const;
     void writeInitQtMetaTypeFunctionBody(TextStream &s, const GeneratorContext &context) const;
 
     /**
@@ -394,9 +398,9 @@ private:
     QString writeReprFunction(TextStream &s, const GeneratorContext &context,
                               uint indirections) const;
 
-    const AbstractMetaFunction *boolCast(const AbstractMetaClass *metaClass) const;
+    AbstractMetaFunctionCPtr boolCast(const AbstractMetaClass *metaClass) const;
     bool hasBoolCast(const AbstractMetaClass *metaClass) const
-    { return boolCast(metaClass) != nullptr; }
+    { return !boolCast(metaClass).isNull(); }
 
     std::optional<AbstractMetaType>
         findSmartPointerInstantiation(const TypeEntry *entry) const;
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp
index 05c76b4d8..bb968a0ee 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp
@@ -143,9 +143,9 @@ void HeaderGenerator::generateClass(TextStream &s, const GeneratorContext &class
            << " : public " << metaClass->qualifiedCppName()
            << "\n{\npublic:\n" << indent;
 
-        const AbstractMetaFunctionList &funcs = filterFunctions(metaClass);
+        const auto &funcs = filterFunctions(metaClass);
         int maxOverrides = 0;
-        for (AbstractMetaFunction *func : funcs) {
+        for (const auto &func : funcs) {
             if ((func->attributes() & AbstractMetaAttributes::FinalCppMethod) == 0) {
                 writeFunction(s, func);
                 // PYSIDE-803: Build a boolean cache for unused overrides.
@@ -222,7 +222,7 @@ void *qt_metacast(const char *_clname) override;
     s << "#endif // SBK_" << outerHeaderGuard << "_H\n\n";
 }
 
-void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunction *func)
+void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func)
 {
 
     // do not write copy ctors here.
@@ -282,8 +282,7 @@ void HeaderGenerator::writeFunction(TextStream &s, const AbstractMetaFunction *f
             s << " override";
         s << ";\n";
         // Check if this method hide other methods in base classes
-        const AbstractMetaFunctionList &ownerFuncs = func->ownerClass()->functions();
-        for (const AbstractMetaFunction *f : ownerFuncs) {
+        for (const auto &f : func->ownerClass()->functions()) {
             if (f != func
                 && !f->isConstructor()
                 && !f->isPrivate()
@@ -618,7 +617,7 @@ void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaType
 
 void HeaderGenerator::writeInheritedOverloads(TextStream &s) const
 {
-    for (const AbstractMetaFunction *func : qAsConst(m_inheritedOverloads)) {
+    for (const auto &func : qAsConst(m_inheritedOverloads)) {
         s << "inline ";
         s << functionSignature(func, QString(), QString(), Generator::EnumAsInts|Generator::OriginalTypeDescription)
             << " { ";
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h
index 12087519d..a5cf2f272 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.h
+++ b/sources/shiboken6/generator/shiboken/headergenerator.h
@@ -54,7 +54,7 @@ protected:
 private:
     void writeCopyCtor(TextStream &s, const AbstractMetaClass *metaClass) const;
     void writeProtectedFieldAccessors(TextStream &s, const AbstractMetaField &field) const;
-    void writeFunction(TextStream &s, const AbstractMetaFunction *func);
+    void writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func);
     void writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum) const;
     void writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass) const;
     void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType) const;
@@ -63,7 +63,7 @@ private:
     void writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum) const;
     void writeInheritedOverloads(TextStream &s) const;
 
-    QSet<const AbstractMetaFunction *> m_inheritedOverloads;
+    QSet<AbstractMetaFunctionCPtr> m_inheritedOverloads;
 };
 
 #endif // HEADERGENERATOR_H
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp
index 6113cdda1..1ff9a74a8 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.cpp
+++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp
@@ -135,7 +135,7 @@ struct OverloadSortData
  */
 static QString getImplicitConversionTypeName(const AbstractMetaType &containerType,
                                              const AbstractMetaType &instantiation,
-                                             const AbstractMetaFunction *function,
+                                             const AbstractMetaFunctionCPtr &function,
                                              const QString &implicitConvTypeName = QString())
 {
     QString impConv;
@@ -274,8 +274,8 @@ void OverloadData::sortNextOverloads()
                 for (const QString &primitive : qAsConst(nonIntegerPrimitives))
                     sortData.mapType(getImplicitConversionTypeName(ov->argType(), instantiation, nullptr, primitive));
             } else {
-                const AbstractMetaFunctionList &funcs = m_generator->implicitConversions(instantiation);
-                for (const AbstractMetaFunction *function : funcs)
+                const auto &funcs = m_generator->implicitConversions(instantiation);
+                for (const auto &function : funcs)
                     sortData.mapType(getImplicitConversionTypeName(ov->argType(), instantiation, function));
             }
         }
@@ -309,8 +309,8 @@ void OverloadData::sortNextOverloads()
         int targetTypeId = sortData.map[targetTypeEntryName];
 
         // Process implicit conversions
-        const AbstractMetaFunctionList &functions = m_generator->implicitConversions(targetType);
-        for (AbstractMetaFunction *function : functions) {
+        const auto &functions = m_generator->implicitConversions(targetType);
+        for (const auto &function : functions) {
             QString convertibleType;
             if (function->isConversionOperator())
                 convertibleType = function->ownerClass()->typeEntry()->name();
@@ -362,8 +362,8 @@ void OverloadData::sortNextOverloads()
                     }
 
                 } else {
-                    const AbstractMetaFunctionList &funcs = m_generator->implicitConversions(instantiation);
-                    for (const AbstractMetaFunction *function : funcs) {
+                    const auto &funcs = m_generator->implicitConversions(instantiation);
+                    for (const auto &function : funcs) {
                         QString convertibleTypeName = getImplicitConversionTypeName(ov->argType(), instantiation, function);
                         if (!graph.containsEdge(targetTypeId, sortData.map[convertibleTypeName])) { // Avoid cyclic dependency.
                             graph.addEdge(sortData.map[convertibleTypeName], targetTypeId);
@@ -477,11 +477,11 @@ void OverloadData::sortNextOverloads()
  *                    \- int
  *
  */
-OverloadData::OverloadData(const AbstractMetaFunctionList &overloads, const ShibokenGenerator *generator)
+OverloadData::OverloadData(const AbstractMetaFunctionCList &overloads, const ShibokenGenerator *generator)
     : m_minArgs(256), m_maxArgs(0), m_argPos(-1), m_argType(nullptr),
     m_headOverloadData(this), m_previousOverloadData(nullptr), m_generator(generator)
 {
-    for (const AbstractMetaFunction *func : overloads) {
+    for (const auto &func : overloads) {
         m_overloads.append(func);
         int argSize = func->arguments().size() - numberOfRemovedArguments(func);
         if (m_minArgs > argSize)
@@ -506,7 +506,7 @@ OverloadData::OverloadData(const AbstractMetaFunctionList &overloads, const Shib
         m_headOverloadData->m_minArgs = maxArgs();
 }
 
-OverloadData::OverloadData(OverloadData *headOverloadData, const AbstractMetaFunction *func,
+OverloadData::OverloadData(OverloadData *headOverloadData, const AbstractMetaFunctionCPtr &func,
                                  const AbstractMetaType &argType, int argPos)
     : m_minArgs(256), m_maxArgs(0), m_argPos(argPos), m_argType(argType),
       m_headOverloadData(headOverloadData), m_previousOverloadData(nullptr),
@@ -516,7 +516,7 @@ OverloadData::OverloadData(OverloadData *headOverloadData, const AbstractMetaFun
         this->addOverload(func);
 }
 
-void OverloadData::addOverload(const AbstractMetaFunction *func)
+void OverloadData::addOverload(const AbstractMetaFunctionCPtr &func)
 {
     int origNumArgs = func->arguments().size();
     int removed = numberOfRemovedArguments(func);
@@ -541,7 +541,7 @@ void OverloadData::addOverload(const AbstractMetaFunction *func)
     m_overloads.append(func);
 }
 
-OverloadData *OverloadData::addOverloadData(const AbstractMetaFunction *func,
+OverloadData *OverloadData::addOverloadData(const AbstractMetaFunctionCPtr &func,
                                             const AbstractMetaArgument &arg)
 {
     const AbstractMetaType &argType = arg.type();
@@ -579,7 +579,7 @@ OverloadData *OverloadData::addOverloadData(const AbstractMetaFunction *func,
 QStringList OverloadData::returnTypes() const
 {
     QSet<QString> retTypes;
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         if (!func->typeReplaced(0).isEmpty())
             retTypes << func->typeReplaced(0);
         else if (!func->argumentRemoved(0))
@@ -596,7 +596,7 @@ bool OverloadData::hasNonVoidReturnType() const
 
 bool OverloadData::hasVarargs() const
 {
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         AbstractMetaArgumentList args = func->arguments();
         if (args.size() > 1 && args.constLast().type().isVarargs())
             return true;
@@ -606,16 +606,16 @@ bool OverloadData::hasVarargs() const
 
 bool OverloadData::hasAllowThread() const
 {
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         if (func->allowThread())
             return true;
     }
     return false;
 }
 
-bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList &overloads)
+bool OverloadData::hasStaticFunction(const AbstractMetaFunctionCList &overloads)
 {
-    for (const AbstractMetaFunction *func : qAsConst(overloads)) {
+    for (const auto &func : overloads) {
         if (func->isStatic())
             return true;
     }
@@ -624,16 +624,16 @@ bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList &overloads)
 
 bool OverloadData::hasStaticFunction() const
 {
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         if (func->isStatic())
             return true;
     }
     return false;
 }
 
-bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList &overloads)
+bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionCList &overloads)
 {
-    for (const AbstractMetaFunction *func : qAsConst(overloads)) {
+    for (const auto &func : overloads) {
         if (!func->isStatic())
             return true;
     }
@@ -642,14 +642,14 @@ bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList &overloads
 
 bool OverloadData::hasInstanceFunction() const
 {
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         if (!func->isStatic())
             return true;
     }
     return false;
 }
 
-bool OverloadData::hasStaticAndInstanceFunctions(const AbstractMetaFunctionList &overloads)
+bool OverloadData::hasStaticAndInstanceFunctions(const AbstractMetaFunctionCList &overloads)
 {
     return OverloadData::hasStaticFunction(overloads) && OverloadData::hasInstanceFunction(overloads);
 }
@@ -659,12 +659,12 @@ bool OverloadData::hasStaticAndInstanceFunctions() const
     return OverloadData::hasStaticFunction() && OverloadData::hasInstanceFunction();
 }
 
-const AbstractMetaFunction *OverloadData::referenceFunction() const
+AbstractMetaFunctionCPtr OverloadData::referenceFunction() const
 {
     return m_overloads.constFirst();
 }
 
-const AbstractMetaArgument *OverloadData::argument(const AbstractMetaFunction *func) const
+const AbstractMetaArgument *OverloadData::argument(const AbstractMetaFunctionCPtr &func) const
 {
     if (isHeadOverloadData() || !m_overloads.contains(func))
         return nullptr;
@@ -704,7 +704,7 @@ OverloadDataList OverloadData::overloadDataOnPosition(int argPos) const
 bool OverloadData::nextArgumentHasDefaultValue() const
 {
     for (OverloadData *overloadData : m_nextOverloadData) {
-        if (overloadData->getFunctionWithDefaultValue())
+        if (!overloadData->getFunctionWithDefaultValue().isNull())
             return true;
     }
     return false;
@@ -712,7 +712,7 @@ bool OverloadData::nextArgumentHasDefaultValue() const
 
 static OverloadData *_findNextArgWithDefault(OverloadData *overloadData)
 {
-    if (overloadData->getFunctionWithDefaultValue())
+    if (!overloadData->getFunctionWithDefaultValue().isNull())
         return overloadData;
 
     OverloadData *result = nullptr;
@@ -730,7 +730,7 @@ OverloadData *OverloadData::findNextArgWithDefault()
     return _findNextArgWithDefault(this);
 }
 
-bool OverloadData::isFinalOccurrence(const AbstractMetaFunction *func) const
+bool OverloadData::isFinalOccurrence(const AbstractMetaFunctionCPtr &func) const
 {
     for (const OverloadData *pd : m_nextOverloadData) {
         if (pd->overloads().contains(func))
@@ -742,10 +742,10 @@ bool OverloadData::isFinalOccurrence(const AbstractMetaFunction *func) const
 AbstractMetaFunctionCList OverloadData::overloadsWithoutRepetition() const
 {
     AbstractMetaFunctionCList overloads = m_overloads;
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         if (func->minimalSignature().endsWith(QLatin1String("const")))
             continue;
-        for (const AbstractMetaFunction *f : qAsConst(overloads)) {
+        for (const auto &f : qAsConst(overloads)) {
             if ((func->minimalSignature() + QLatin1String("const")) == f->minimalSignature()) {
                 overloads.removeOne(f);
                 break;
@@ -755,9 +755,9 @@ AbstractMetaFunctionCList OverloadData::overloadsWithoutRepetition() const
     return overloads;
 }
 
-const AbstractMetaFunction *OverloadData::getFunctionWithDefaultValue() const
+AbstractMetaFunctionCPtr OverloadData::getFunctionWithDefaultValue() const
 {
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         int removedArgs = 0;
         for (int i = 0; i <= m_argPos + removedArgs; i++) {
             if (func->argumentRemoved(i + 1))
@@ -766,14 +766,14 @@ const AbstractMetaFunction *OverloadData::getFunctionWithDefaultValue() const
         if (func->arguments().at(m_argPos + removedArgs).hasDefaultValueExpression())
             return func;
     }
-    return nullptr;
+    return {};
 }
 
 QList<int> OverloadData::invalidArgumentLengths() const
 {
     QSet<int> validArgLengths;
 
-    for (const AbstractMetaFunction *func : qAsConst(m_headOverloadData->m_overloads)) {
+    for (const auto &func : qAsConst(m_headOverloadData->m_overloads)) {
         const AbstractMetaArgumentList args = func->arguments();
         int offset = 0;
         for (int i = 0; i < args.size(); ++i) {
@@ -796,7 +796,7 @@ QList<int> OverloadData::invalidArgumentLengths() const
     return invalidArgLengths;
 }
 
-int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction *func, int finalArgPos)
+int OverloadData::numberOfRemovedArguments(const AbstractMetaFunctionCPtr &func, int finalArgPos)
 {
     int removed = 0;
     if (finalArgPos < 0) {
@@ -813,33 +813,10 @@ int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction *func, int
     return removed;
 }
 
-QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList &overloads)
-{
-    int minArgs = 10000;
-    int maxArgs = 0;
-    for (const AbstractMetaFunction *func : overloads) {
-        int origNumArgs = func->arguments().size();
-        int removed = numberOfRemovedArguments(func);
-        int numArgs = origNumArgs - removed;
-        if (maxArgs < numArgs)
-            maxArgs = numArgs;
-        if (minArgs > numArgs)
-            minArgs = numArgs;
-        for (int j = 0; j < origNumArgs; j++) {
-            if (func->argumentRemoved(j + 1))
-                continue;
-            int fixedArgIndex = j - removed;
-            if (fixedArgIndex < minArgs && func->arguments().at(j).hasDefaultValueExpression())
-                minArgs = fixedArgIndex;
-        }
-    }
-    return {minArgs, maxArgs};
-}
-
-bool OverloadData::isSingleArgument(const AbstractMetaFunctionList &overloads)
+bool OverloadData::isSingleArgument(const AbstractMetaFunctionCList &overloads)
 {
     bool singleArgument = true;
-    for (const AbstractMetaFunction *func : overloads) {
+    for (const auto &func : overloads) {
         if (func->arguments().size() - numberOfRemovedArguments(func) != 1) {
             singleArgument = false;
             break;
@@ -870,13 +847,13 @@ QString OverloadData::dumpGraph() const
     QString result;
     QTextStream s(&result);
     if (m_argPos == -1) {
-        const AbstractMetaFunction *rfunc = referenceFunction();
+        const auto rfunc = referenceFunction();
         s << "digraph OverloadedFunction {\n";
         s << "    graph [fontsize=12 fontname=freemono labelloc=t splines=true overlap=false rankdir=LR];\n";
 
         // Shows all function signatures
         s << "legend [fontsize=9 fontname=freemono shape=rect label=\"";
-        for (const AbstractMetaFunction *func : m_overloads) {
+        for (const auto &func : m_overloads) {
             s << "f" << functionNumber(func) << " : "
                 << toHtml(func->type().cppSignature())
                 << ' ' << toHtml(func->minimalSignature()) << "\\l";
@@ -904,7 +881,7 @@ QString OverloadData::dumpGraph() const
             << "</td></tr>";
 
         // Shows type changes for all function signatures
-        for (const AbstractMetaFunction *func : m_overloads) {
+        for (const auto &func : m_overloads) {
             if (func->typeReplaced(0).isEmpty())
                 continue;
             s << "<tr><td bgcolor=\"gray\" align=\"right\">f" << functionNumber(func);
@@ -927,7 +904,7 @@ QString OverloadData::dumpGraph() const
 
         // Overloads for the signature to present point
         s << "<tr><td bgcolor=\"gray\" align=\"right\">overloads</td><td bgcolor=\"gray\" align=\"left\">";
-        for (const AbstractMetaFunction *func : m_overloads)
+        for (const auto &func : m_overloads)
             s << 'f' << functionNumber(func) << ' ';
         s << "</td></tr>";
 
@@ -959,12 +936,12 @@ QString OverloadData::dumpGraph() const
 
         // Overloads for the signature to present point
         s << "<tr><td bgcolor=\"gray\" align=\"right\">overloads</td><td bgcolor=\"gray\" align=\"left\">";
-        for (const AbstractMetaFunction *func : m_overloads)
+        for (const auto &func : m_overloads)
             s << 'f' << functionNumber(func) << ' ';
         s << "</td></tr>";
 
         // Show default values (original and modified) for various functions
-        for (const AbstractMetaFunction *func : m_overloads) {
+        for (const auto &func : m_overloads) {
             const AbstractMetaArgument *arg = argument(func);
             if (!arg)
                 continue;
@@ -990,7 +967,7 @@ QString OverloadData::dumpGraph() const
     return result;
 }
 
-int OverloadData::functionNumber(const AbstractMetaFunction *func) const
+int OverloadData::functionNumber(const AbstractMetaFunctionCPtr &func) const
 {
     return m_headOverloadData->m_overloads.indexOf(func);
 }
@@ -1011,29 +988,18 @@ QString OverloadData::argumentTypeReplaced() const
     return m_argTypeReplaced;
 }
 
-bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList &overloads)
-{
-    if (OverloadData::getMinMaxArguments(overloads).second == 0)
-        return false;
-    for (const AbstractMetaFunction *func : overloads) {
-        if (hasArgumentWithDefaultValue(func))
-            return true;
-    }
-    return false;
-}
-
 bool OverloadData::hasArgumentWithDefaultValue() const
 {
     if (maxArgs() == 0)
         return false;
-    for (const AbstractMetaFunction *func : m_overloads) {
+    for (const auto &func : m_overloads) {
         if (hasArgumentWithDefaultValue(func))
             return true;
     }
     return false;
 }
 
-bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction *func)
+bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionCPtr &func)
 {
     const AbstractMetaArgumentList &arguments = func->arguments();
     for (const AbstractMetaArgument &arg : arguments) {
@@ -1045,7 +1011,7 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction *func)
     return false;
 }
 
-AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction *func)
+AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunctionCPtr &func)
 {
     AbstractMetaArgumentList args;
     const AbstractMetaArgumentList &arguments = func->arguments();
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.h b/sources/shiboken6/generator/shiboken/overloaddata.h
index 86f76843f..317b1d022 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.h
+++ b/sources/shiboken6/generator/shiboken/overloaddata.h
@@ -43,7 +43,7 @@ using OverloadDataList = QList<OverloadData *>;
 class OverloadData
 {
 public:
-    OverloadData(const AbstractMetaFunctionList &overloads, const ShibokenGenerator *generator);
+    OverloadData(const AbstractMetaFunctionCList &overloads, const ShibokenGenerator *generator);
     ~OverloadData();
 
     int minArgs() const { return m_headOverloadData->m_minArgs; }
@@ -68,22 +68,22 @@ public:
     bool hasStaticFunction() const;
 
     /// Returns true if any of the overloads passed as argument is static.
-    static bool hasStaticFunction(const AbstractMetaFunctionList &overloads);
+    static bool hasStaticFunction(const AbstractMetaFunctionCList &overloads);
 
     /// Returns true if any of the overloads for the current OverloadData is not static.
     bool hasInstanceFunction() const;
 
     /// Returns true if any of the overloads passed as argument is not static.
-    static bool hasInstanceFunction(const AbstractMetaFunctionList &overloads);
+    static bool hasInstanceFunction(const AbstractMetaFunctionCList &overloads);
 
     /// Returns true if among the overloads for the current OverloadData there are static and non-static methods altogether.
     bool hasStaticAndInstanceFunctions() const;
 
     /// Returns true if among the overloads passed as argument there are static and non-static methods altogether.
-    static bool hasStaticAndInstanceFunctions(const AbstractMetaFunctionList &overloads);
+    static bool hasStaticAndInstanceFunctions(const AbstractMetaFunctionCList &overloads);
 
-    const AbstractMetaFunction *referenceFunction() const;
-    const AbstractMetaArgument *argument(const AbstractMetaFunction *func) const;
+    AbstractMetaFunctionCPtr referenceFunction() const;
+    const AbstractMetaArgument *argument(const AbstractMetaFunctionCPtr &func) const;
     OverloadDataList overloadDataOnPosition(int argPos) const;
 
     bool isHeadOverloadData() const { return this == m_headOverloadData; }
@@ -92,12 +92,12 @@ public:
     OverloadData *headOverloadData() const { return m_headOverloadData; }
 
     /// Returns the function that has a default value at the current OverloadData argument position, otherwise returns null.
-    const AbstractMetaFunction *getFunctionWithDefaultValue() const;
+    AbstractMetaFunctionCPtr getFunctionWithDefaultValue() const;
 
     bool nextArgumentHasDefaultValue() const;
     /// Returns the nearest occurrence, including this instance, of an argument with a default value.
     OverloadData *findNextArgWithDefault();
-    bool isFinalOccurrence(const AbstractMetaFunction *func) const;
+    bool isFinalOccurrence(const AbstractMetaFunctionCPtr &func) const;
 
     /// Returns the list of overloads removing repeated constant functions (ex.: "foo()" and "foo()const", the second is removed).
     AbstractMetaFunctionCList overloadsWithoutRepetition() const;
@@ -107,10 +107,9 @@ public:
 
     QList<int> invalidArgumentLengths() const;
 
-    static int numberOfRemovedArguments(const AbstractMetaFunction *func, int finalArgPos = -1);
-    static QPair<int, int> getMinMaxArguments(const AbstractMetaFunctionList &overloads);
+    static int numberOfRemovedArguments(const AbstractMetaFunctionCPtr &func, int finalArgPos = -1);
     /// Returns true if all overloads have no more than one argument.
-    static bool isSingleArgument(const AbstractMetaFunctionList &overloads);
+    static bool isSingleArgument(const AbstractMetaFunctionCList &overloads);
 
     void dumpGraph(const QString &filename) const;
     QString dumpGraph() const;
@@ -119,27 +118,26 @@ public:
     QString argumentTypeReplaced() const;
 
     bool hasArgumentWithDefaultValue() const;
-    static bool hasArgumentWithDefaultValue(const AbstractMetaFunctionList &overloads);
-    static bool hasArgumentWithDefaultValue(const AbstractMetaFunction *func);
+    static bool hasArgumentWithDefaultValue(const AbstractMetaFunctionCPtr &func);
 
     /// Returns a list of function arguments which have default values and were not removed.
-    static AbstractMetaArgumentList getArgumentsWithDefaultValues(const AbstractMetaFunction *func);
+    static AbstractMetaArgumentList getArgumentsWithDefaultValues(const AbstractMetaFunctionCPtr &func);
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &) const;
 #endif
 
 private:
-    OverloadData(OverloadData *headOverloadData, const AbstractMetaFunction *func,
+    OverloadData(OverloadData *headOverloadData, const AbstractMetaFunctionCPtr &func,
                  const AbstractMetaType &argType, int argPos);
 
-    void addOverload(const AbstractMetaFunction *func);
-    OverloadData *addOverloadData(const AbstractMetaFunction *func, const AbstractMetaArgument &arg);
+    void addOverload(const AbstractMetaFunctionCPtr &func);
+    OverloadData *addOverloadData(const AbstractMetaFunctionCPtr &func, const AbstractMetaArgument &arg);
 
     void sortNextOverloads();
     bool sortByOverloadNumberModification();
 
-    int functionNumber(const AbstractMetaFunction *func) const;
+    int functionNumber(const AbstractMetaFunctionCPtr &func) const;
     OverloadDataList overloadDataOnPosition(OverloadData *overloadData, int argPos) const;
 
     int m_minArgs;
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 4d3ac58b2..eac7f87f7 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -226,8 +226,7 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaCl
         if (!result && metaClass->hasProtectedFunctions()) {
             int protectedFunctions = 0;
             int protectedOperators = 0;
-            const AbstractMetaFunctionList &funcs = metaClass->functions();
-            for (const AbstractMetaFunction *func : funcs) {
+            for (const auto &func : metaClass->functions()) {
                 if (!func->isProtected() || func->isSignal() || func->isModifiedRemoved())
                     continue;
                 if (func->isOperatorOverload())
@@ -243,7 +242,7 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaCl
     return result;
 }
 
-bool ShibokenGenerator::shouldWriteVirtualMethodNative(const AbstractMetaFunction *func) const
+bool ShibokenGenerator::shouldWriteVirtualMethodNative(const AbstractMetaFunctionCPtr &func) const
 {
     // PYSIDE-803: Extracted this because it is used multiple times.
     const AbstractMetaClass *metaClass = func->ownerClass();
@@ -274,7 +273,7 @@ QString ShibokenGenerator::fullPythonClassName(const AbstractMetaClass *metaClas
     return fullClassName;
 }
 
-QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunction *func, bool forceFunc)
+QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunctionCPtr &func, bool forceFunc)
 {
     QString funcName;
     if (func->isOperatorOverload())
@@ -316,7 +315,7 @@ QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField &fie
     return QLatin1String("protected_") + field.name() + QLatin1String("_setter");
 }
 
-QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction *func) const
+QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunctionCPtr &func) const
 {
     QString result;
 
@@ -340,7 +339,7 @@ QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction *func)
     return result;
 }
 
-QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunction *func)
+QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunctionCPtr &func)
 {
     if (!func->ownerClass())
         return QString();
@@ -424,7 +423,7 @@ static QString searchForEnumScope(const AbstractMetaClass *metaClass, const QStr
 }
 
 // Handle QFlags<> for guessScopeForDefaultValue()
-QString ShibokenGenerator::guessScopeForDefaultFlagsValue(const AbstractMetaFunction *func,
+QString ShibokenGenerator::guessScopeForDefaultFlagsValue(const AbstractMetaFunctionCPtr &func,
                                                           const AbstractMetaArgument &arg,
                                                           const QString &value) const
 {
@@ -489,7 +488,7 @@ QString ShibokenGenerator::guessScopeForDefaultFlagsValue(const AbstractMetaFunc
  * New situations may arise in the future and
  * this method should be updated, do it with care.
  */
-QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction *func,
+QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunctionCPtr &func,
                                                      const AbstractMetaArgument &arg) const
 {
     QString value = arg.defaultValueExpression();
@@ -628,7 +627,7 @@ void ShibokenGenerator::writeToCppConversion(TextStream &s, const AbstractMetaTy
     s << cpythonToCppConversionFunction(type, context) << inArgName << ", &" << outArgName << ')';
 }
 
-bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunction *func, int argIndex) const
+bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func, int argIndex) const
 {
     if (argIndex < 0 || argIndex >= func->arguments().count())
         return false;
@@ -652,7 +651,7 @@ bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFuncti
     return false;
 }
 
-QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction *func, bool incRef)
+QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunctionCPtr &func, bool incRef)
 {
     QString result;
     const char objType = (incRef ? 'O' : 'N');
@@ -943,11 +942,11 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const QString &cppOpFuncNa
     return value;
 }
 
-QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction *func)
+QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunctionCPtr &func)
 {
     QString op = pythonOperatorFunctionName(func->originalName());
     if (op == unknownOperator())
-        qCWarning(lcShiboken).noquote().nospace() << msgUnknownOperator(func);
+        qCWarning(lcShiboken).noquote().nospace() << msgUnknownOperator(func.data());
     if (func->arguments().isEmpty()) {
         if (op == QLatin1String("__sub__"))
             op = QLatin1String("__neg__");
@@ -966,7 +965,7 @@ QString ShibokenGenerator::pythonRichCompareOperatorId(const QString &cppOpFuncN
     return QLatin1String("Py_") + pythonOperators().value(cppOpFuncName).toUpper();
 }
 
-QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunction *func)
+QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunctionCPtr &func)
 {
     return pythonRichCompareOperatorId(func->originalName());
 }
@@ -1260,7 +1259,7 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry *ty
     return QStringLiteral("Shiboken::Conversions::copyToPython(%1, &").arg(converterObject(type));
 }
 
-QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
+QString ShibokenGenerator::argumentString(const AbstractMetaFunctionCPtr &func,
                                           const AbstractMetaArgument &argument,
                                           Options options) const
 {
@@ -1301,7 +1300,7 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
 }
 
 void ShibokenGenerator::writeArgument(TextStream &s,
-                                      const AbstractMetaFunction *func,
+                                      const AbstractMetaFunctionCPtr &func,
                                       const AbstractMetaArgument &argument,
                                       Options options) const
 {
@@ -1309,7 +1308,7 @@ void ShibokenGenerator::writeArgument(TextStream &s,
 }
 
 void ShibokenGenerator::writeFunctionArguments(TextStream &s,
-                                               const AbstractMetaFunction *func,
+                                               const AbstractMetaFunctionCPtr &func,
                                                Options options) const
 {
     AbstractMetaArgumentList arguments = func->arguments();
@@ -1342,7 +1341,7 @@ GeneratorContext ShibokenGenerator::contextForClass(const AbstractMetaClass *c)
     return result;
 }
 
-QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction *func, Options options) const
+QString ShibokenGenerator::functionReturnType(const AbstractMetaFunctionCPtr &func, Options options) const
 {
     QString modifiedReturnType = QString(func->typeReplaced(0));
     if (!modifiedReturnType.isEmpty() && !(options & OriginalTypeDescription))
@@ -1350,7 +1349,7 @@ QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction *func,
     return translateType(func->type(), func->implementingClass(), options);
 }
 
-QString ShibokenGenerator::functionSignature(const AbstractMetaFunction *func,
+QString ShibokenGenerator::functionSignature(const AbstractMetaFunctionCPtr &func,
                                              const QString &prepend,
                                              const QString &append,
                                              Options options,
@@ -1385,7 +1384,7 @@ QString ShibokenGenerator::functionSignature(const AbstractMetaFunction *func,
 }
 
 void ShibokenGenerator::writeArgumentNames(TextStream &s,
-                                           const AbstractMetaFunction *func,
+                                           const AbstractMetaFunctionCPtr &func,
                                            Options options) const
 {
     const AbstractMetaArgumentList arguments = func->arguments();
@@ -1409,7 +1408,7 @@ void ShibokenGenerator::writeArgumentNames(TextStream &s,
 }
 
 void ShibokenGenerator::writeFunctionCall(TextStream &s,
-                                          const AbstractMetaFunction *func,
+                                          const AbstractMetaFunctionCPtr &func,
                                           Options options) const
 {
     if (!(options & Generator::SkipName))
@@ -1424,7 +1423,7 @@ void ShibokenGenerator::writeUnusedVariableCast(TextStream &s, const QString &va
     s << "SBK_UNUSED(" << variableName<< ")\n";
 }
 
-static bool filterFunction(const AbstractMetaFunction *func, bool avoidProtectedHack)
+static bool filterFunction(const AbstractMetaFunctionCPtr &func, bool avoidProtectedHack)
 {
     switch (func->functionType()) {
     case AbstractMetaFunction::DestructorFunction:
@@ -1444,12 +1443,12 @@ static bool filterFunction(const AbstractMetaFunction *func, bool avoidProtected
     return true;
 }
 
-AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass *metaClass) const
+AbstractMetaFunctionCList ShibokenGenerator::filterFunctions(const AbstractMetaClass *metaClass) const
 {
-    AbstractMetaFunctionList result;
-    const AbstractMetaFunctionList &funcs = metaClass->functions();
+    AbstractMetaFunctionCList result;
+    const AbstractMetaFunctionCList &funcs = metaClass->functions();
     result.reserve(funcs.size());
-    for (AbstractMetaFunction *func : funcs) {
+    for (const auto &func : funcs) {
         if (filterFunction(func, avoidProtectedHack()))
             result.append(func);
     }
@@ -1463,8 +1462,8 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter
         // Use only the classes for the current module.
         if (!shouldGenerate(metaClass))
             continue;
-        const AbstractMetaFunctionList &overloads = metaClass->operatorOverloads(AbstractMetaClass::ConversionOp);
-        for (AbstractMetaFunction *convOp : overloads) {
+        const auto &overloads = metaClass->operatorOverloads(AbstractMetaClass::ConversionOp);
+        for (const auto &convOp : overloads) {
             // Get only the conversion operators that return a type from another module,
             // that are value-types and were not removed in the type system.
             const TypeEntry *convType = convOp->type().typeEntry();
@@ -1562,7 +1561,7 @@ void ShibokenGenerator::processCodeSnip(QString &code) const
 }
 
 ShibokenGenerator::ArgumentVarReplacementList
-    ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunction *func,
+    ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunctionCPtr &func,
                                               bool usePyArgs, TypeSystem::Language language,
                                               const AbstractMetaArgument *lastArg) const
 {
@@ -1643,7 +1642,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
                                        const CodeSnipList &codeSnips,
                                        TypeSystem::CodeSnipPosition position,
                                        TypeSystem::Language language,
-                                       const AbstractMetaFunction *func,
+                                       const AbstractMetaFunctionCPtr &func,
                                        const AbstractMetaArgument *lastArg) const
 {
     QString code = getCodeSnippets(codeSnips, position, language);
@@ -1677,7 +1676,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
             const QRegularExpressionMatch match = pyArgsRegexCheck.match(code);
             if (match.hasMatch()) {
                 qCWarning(lcShiboken).noquote().nospace()
-                    << msgWrongIndex("%PYARG", match.captured(1), func);
+                    << msgWrongIndex("%PYARG", match.captured(1), func.data());
                 return;
             }
             code.replace(QLatin1String("%PYARG_1"), QLatin1String(PYTHON_ARG));
@@ -1707,7 +1706,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
     while (rit.hasNext()) {
         QRegularExpressionMatch match = rit.next();
         qCWarning(lcShiboken).noquote().nospace()
-            << msgWrongIndex("%ARG#_TYPE", match.captured(1), func);
+            << msgWrongIndex("%ARG#_TYPE", match.captured(1), func.data());
     }
 
     // Replace template variable for return variable name.
@@ -1838,8 +1837,8 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
         // dispatcher.
         bool hasProtectedOverload = false;
         if (func->isUserAdded()) {
-            const AbstractMetaFunctionList &funcs = getFunctionOverloads(func->ownerClass(), func->name());
-            for (const AbstractMetaFunction *f : funcs)
+            const auto &funcs = getFunctionOverloads(func->ownerClass(), func->name());
+            for (const auto &f : funcs)
                 hasProtectedOverload |= f->isProtected();
         }
 
@@ -2024,7 +2023,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
 }
 
 bool ShibokenGenerator::injectedCodeCallsCppFunction(const GeneratorContext &context,
-                                                     const AbstractMetaFunction *func)
+                                                     const AbstractMetaFunctionCPtr &func)
 {
     if (func->injectedCodeContains(u"%FUNCTION_NAME("))
         return true;
@@ -2090,8 +2089,8 @@ bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *
         return true;
     const auto &functionGroup = getFunctionGroups(metaClass);
     for (auto it = functionGroup.cbegin(), end = functionGroup.cend(); it != end; ++it) {
-        AbstractMetaFunctionList overloads;
-        for (AbstractMetaFunction *func : qAsConst(it.value())) {
+        AbstractMetaFunctionCList overloads;
+        for (const auto &func : qAsConst(it.value())) {
             if (func->isAssignmentOperator() || func->isCastOperator() || func->isModifiedRemoved()
                 || func->isPrivate() || func->ownerClass() != func->implementingClass()
                 || func->isConstructor() || func->isOperatorOverload())
@@ -2106,15 +2105,14 @@ bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *
     return false;
 }
 
-AbstractMetaFunctionList
-    ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass) const
+AbstractMetaFunctionCList ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass) const
 {
-    AbstractMetaFunctionList methods;
+    AbstractMetaFunctionCList methods;
     if (metaClass) {
         const auto &functionGroups = getFunctionGroups(metaClass);
         for (auto it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
-            AbstractMetaFunctionList overloads;
-            for (AbstractMetaFunction *func : qAsConst(it.value())) {
+            AbstractMetaFunctionCList overloads;
+            for (const auto &func : qAsConst(it.value())) {
                 if (func->isAssignmentOperator() || func->isCastOperator() || func->isModifiedRemoved()
                     || func->isPrivate() || func->ownerClass() != func->implementingClass()
                     || func->isConstructor() || func->isOperatorOverload())
@@ -2205,7 +2203,7 @@ static void dumpFunction(AbstractMetaFunctionList lst)
 }
 */
 
-static bool isGroupable(const AbstractMetaFunction *func)
+static bool isGroupable(const AbstractMetaFunctionCPtr &func)
 {
     switch (func->functionType()) {
     case AbstractMetaFunction::DestructorFunction:
@@ -2224,10 +2222,10 @@ static bool isGroupable(const AbstractMetaFunction *func)
     return true;
 }
 
-static void insertIntoFunctionGroups(const AbstractMetaFunctionList &lst,
+static void insertIntoFunctionGroups(const AbstractMetaFunctionCList &lst,
                                      ShibokenGenerator::FunctionGroups *results)
 {
-    for (AbstractMetaFunction *func : lst) {
+    for (const auto &func : lst) {
         if (isGroupable(func))
             (*results)[func->name()].append(func);
     }
@@ -2262,15 +2260,15 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroups(const Abs
 
 ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const AbstractMetaClass *scope)
 {
-    AbstractMetaFunctionList lst = scope->functions();
+    AbstractMetaFunctionCList lst = scope->functions();
     scope->getFunctionsFromInvisibleNamespacesToBeGenerated(&lst);
 
     FunctionGroups results;
-    for (AbstractMetaFunction *func : lst) {
+    for (const auto &func : lst) {
         if (isGroupable(func)) {
             auto it = results.find(func->name());
             if (it == results.end()) {
-                results.insert(func->name(), AbstractMetaFunctionList(1, func));
+                results.insert(func->name(), AbstractMetaFunctionCList(1, func));
             } else {
                 // If there are virtuals methods in the mix (PYSIDE-570,
                 // QFileSystemModel::index(QString,int) and
@@ -2287,40 +2285,43 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const
     return results;
 }
 
-AbstractMetaFunctionList ShibokenGenerator::getInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen)
+AbstractMetaFunctionCList
+    ShibokenGenerator::getInheritedOverloads(const AbstractMetaFunctionCPtr &func, QSet<QString> *seen)
 {
-    AbstractMetaFunctionList results;
+    AbstractMetaFunctionCList results;
     AbstractMetaClass *basis;
     if (func->ownerClass() && (basis = func->ownerClass()->baseClass())) {
         for (; basis; basis = basis->baseClass()) {
-            const AbstractMetaFunction *inFunc = basis->findFunction(func->name());
-            if (inFunc && !seen->contains(inFunc->minimalSignature())) {
+            const auto inFunc = basis->findFunction(func->name());
+            if (!inFunc.isNull() && !seen->contains(inFunc->minimalSignature())) {
                 seen->insert(inFunc->minimalSignature());
                 AbstractMetaFunction *newFunc = inFunc->copy();
                 newFunc->setImplementingClass(func->implementingClass());
-                results << newFunc;
+                results << AbstractMetaFunctionCPtr(newFunc);
             }
         }
     }
     return results;
 }
 
-AbstractMetaFunctionList ShibokenGenerator::getFunctionAndInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen)
+AbstractMetaFunctionCList
+    ShibokenGenerator::getFunctionAndInheritedOverloads(const AbstractMetaFunctionCPtr &func,
+                                                        QSet<QString> *seen)
 {
-    AbstractMetaFunctionList results;
+    AbstractMetaFunctionCList results;
     seen->insert(func->minimalSignature());
-    results << const_cast<AbstractMetaFunction *>(func) << getInheritedOverloads(func, seen);
+    results << func << getInheritedOverloads(func, seen);
     return results;
 }
 
-AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass *scope,
+AbstractMetaFunctionCList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass *scope,
                                                                  const QString &functionName) const
 {
-    AbstractMetaFunctionList lst = scope ? scope->functions() : globalFunctions();
+    const auto &lst = scope ? scope->functions() : globalFunctions();
 
-    AbstractMetaFunctionList results;
+    AbstractMetaFunctionCList results;
     QSet<QString> seenSignatures;
-    for (AbstractMetaFunction *func : qAsConst(lst)) {
+    for (const auto &func : qAsConst(lst)) {
         if (func->name() != functionName)
             continue;
         if (isGroupable(func)) {
@@ -2416,7 +2417,7 @@ bool ShibokenGenerator::doSetup()
 
     const auto &functionGroups = getGlobalFunctionGroups();
     for (auto it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
-        for (AbstractMetaFunction *func : it.value())
+        for (const auto &func : it.value())
             getCode(snips, func->injectedCodeSnips());
     }
 
@@ -2633,7 +2634,7 @@ QString ShibokenGenerator::pythonArgsAt(int i)
 }
 
 void ShibokenGenerator::replaceTemplateVariables(QString &code,
-                                                 const AbstractMetaFunction *func) const
+                                                 const AbstractMetaFunctionCPtr &func) const
 {
     const AbstractMetaClass *cpp_class = func->ownerClass();
     if (cpp_class)
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h
index 9bca5f85e..b20a64515 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.h
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h
@@ -81,7 +81,7 @@ public:
     };
     Q_DECLARE_FLAGS(AttroCheck, AttroCheckFlag);
 
-    using FunctionGroups = QMap<QString, AbstractMetaFunctionList>; // Sorted
+    using FunctionGroups = QMap<QString, AbstractMetaFunctionCList>; // Sorted
 
     ShibokenGenerator();
     ~ShibokenGenerator() override;
@@ -110,8 +110,8 @@ protected:
      *   \param func the metafunction to be searched in subclasses.
      *   \param seen the function's minimal signatures already seen.
      */
-    static AbstractMetaFunctionList getFunctionAndInheritedOverloads(const AbstractMetaFunction *func,
-                                                                     QSet<QString> *seen);
+    static AbstractMetaFunctionCList getFunctionAndInheritedOverloads(const AbstractMetaFunctionCPtr &func,
+                                                                      QSet<QString> *seen);
 
     /// Write user's custom code snippets at class or module level.
     void writeClassCodeSnips(TextStream &s,
@@ -128,7 +128,7 @@ protected:
                         const CodeSnipList &codeSnips,
                         TypeSystem::CodeSnipPosition position,
                         TypeSystem::Language language,
-                        const AbstractMetaFunction *func,
+                        const AbstractMetaFunctionCPtr &func,
                         const AbstractMetaArgument *lastArg = nullptr) const;
 
     /// Replaces variables for the user's custom code at global or class level.
@@ -143,7 +143,7 @@ protected:
      *   \return true if the function's code snippets call the wrapped C++ function
      */
     static bool injectedCodeCallsCppFunction(const GeneratorContext &context,
-                                             const AbstractMetaFunction *func);
+                                             const AbstractMetaFunctionCPtr &func);
 
     /**
      *   Function which parse the metafunction information
@@ -151,7 +151,7 @@ protected:
      *   \param option some extra options
      *   \param arg_count the number of function arguments
      */
-    QString functionSignature(const AbstractMetaFunction *func,
+    QString functionSignature(const AbstractMetaFunctionCPtr &func,
                               const QString &prepend = QString(),
                               const QString &append = QString(),
                               Options options = NoOption,
@@ -164,7 +164,7 @@ protected:
     AttroCheck checkAttroFunctionNeeds(const AbstractMetaClass *metaClass) const;
 
     /// Returns a list of methods of the given class where each one is part of a different overload with both static and non-static method.
-    AbstractMetaFunctionList getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass) const;
+    AbstractMetaFunctionCList getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass) const;
 
     void writeToPythonConversion(TextStream &s, const AbstractMetaType &type,
                                  const AbstractMetaClass *context, const QString &argumentName) const;
@@ -174,18 +174,18 @@ protected:
                               const QString &outArgName) const;
 
     /// Returns true if the argument is a pointer that rejects nullptr values.
-    bool shouldRejectNullPointerArgument(const AbstractMetaFunction *func, int argIndex) const;
+    bool shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func, int argIndex) const;
 
     /// Verifies if the class should have a C++ wrapper generated for it, instead of only a Python wrapper.
     bool shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const;
 
     /// Condition to call WriteVirtualMethodNative. Was extracted because also used to count these calls.
-    bool shouldWriteVirtualMethodNative(const AbstractMetaFunction *func) const;
+    bool shouldWriteVirtualMethodNative(const AbstractMetaFunctionCPtr &func) const;
 
     QString wrapperName(const AbstractMetaClass *metaClass) const;
 
     static QString fullPythonClassName(const AbstractMetaClass *metaClass);
-    static QString fullPythonFunctionName(const AbstractMetaFunction *func, bool forceFunc);
+    static QString fullPythonFunctionName(const AbstractMetaFunctionCPtr &func, bool forceFunc);
 
     bool wrapperDiagnostics() const { return m_wrapperDiagnostics; }
 
@@ -197,9 +197,9 @@ protected:
     static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry *type);
 
     static QString pythonOperatorFunctionName(const QString &cppOpFuncName);
-    static QString pythonOperatorFunctionName(const AbstractMetaFunction *func);
+    static QString pythonOperatorFunctionName(const AbstractMetaFunctionCPtr &func);
     static QString pythonRichCompareOperatorId(const QString &cppOpFuncName);
-    static QString pythonRichCompareOperatorId(const AbstractMetaFunction *func);
+    static QString pythonRichCompareOperatorId(const AbstractMetaFunctionCPtr &func);
 
     static QString fixedCppTypeName(const CustomConversion::TargetToNativeConversion *toNative);
     static QString fixedCppTypeName(const AbstractMetaType &type);
@@ -259,8 +259,8 @@ protected:
     QString cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass) const;
     QString cpythonToPythonConversionFunction(const TypeEntry *type) const;
 
-    QString cpythonFunctionName(const AbstractMetaFunction *func) const;
-    static QString cpythonMethodDefinitionName(const AbstractMetaFunction *func);
+    QString cpythonFunctionName(const AbstractMetaFunctionCPtr &func) const;
+    static QString cpythonMethodDefinitionName(const AbstractMetaFunctionCPtr &func);
     static QString cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass);
     static QString cpythonGetattroFunctionName(const AbstractMetaClass *metaClass);
     static QString cpythonSetattroFunctionName(const AbstractMetaClass *metaClass);
@@ -276,9 +276,9 @@ protected:
     static QString cpythonWrapperCPtr(const TypeEntry *type, const QString &argName);
 
     /// Guesses the scope to where belongs an argument's default value.
-    QString guessScopeForDefaultValue(const AbstractMetaFunction *func,
+    QString guessScopeForDefaultValue(const AbstractMetaFunctionCPtr &func,
                                       const AbstractMetaArgument &arg) const;
-    QString guessScopeForDefaultFlagsValue(const AbstractMetaFunction *func,
+    QString guessScopeForDefaultFlagsValue(const AbstractMetaFunctionCPtr &func,
                                            const AbstractMetaArgument &arg,
                                            const QString &value) const;
 
@@ -290,7 +290,7 @@ protected:
     /// Returns the special cast function name, the function used to proper cast class with multiple inheritance.
     static QString cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass);
 
-    static QString getFormatUnitString(const AbstractMetaFunction *func, bool incRef = false);
+    static QString getFormatUnitString(const AbstractMetaFunctionCPtr &func, bool incRef = false);
 
     /// Returns the file name for the module global header. If no module name is provided the current will be used.
     QString getModuleHeaderFileName(const QString &moduleName = QString()) const;
@@ -347,12 +347,12 @@ protected:
     void collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro);
 
     void writeFunctionCall(TextStream &s,
-                           const AbstractMetaFunction *metaFunc,
+                           const AbstractMetaFunctionCPtr &metaFunc,
                            Options options = NoOption) const;
 
     void writeUnusedVariableCast(TextStream &s, const QString &variableName) const;
 
-    AbstractMetaFunctionList filterFunctions(const AbstractMetaClass *metaClass) const;
+    AbstractMetaFunctionCList filterFunctions(const AbstractMetaClass *metaClass) const;
 
     // All data about extended converters: the type entries of the target type, and a
     // list of AbstractMetaClasses accepted as argument for the conversion.
@@ -393,7 +393,7 @@ private:
      *   \param func the metafunction to be searched in subclasses.
      *   \param seen the function's minimal signatures already seen.
      */
-    static AbstractMetaFunctionList getInheritedOverloads(const AbstractMetaFunction *func,
+    static AbstractMetaFunctionCList getInheritedOverloads(const AbstractMetaFunctionCPtr & func,
                                                           QSet<QString> *seen);
 
     /**
@@ -401,8 +401,8 @@ private:
      *   \param scope scope used to search for overloads.
      *   \param functionName the function name.
      */
-    AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass *scope,
-                                                  const QString &functionName) const;
+    AbstractMetaFunctionCList getFunctionOverloads(const AbstractMetaClass *scope,
+                                                   const QString &functionName) const;
     /**
      *   Write a function argument in the C++ in the text stream \p s.
      *   This function just call \code s << argumentString(); \endcode
@@ -412,7 +412,7 @@ private:
      *   \param options some extra options.
      */
     void writeArgument(TextStream &s,
-                       const AbstractMetaFunction *func,
+                       const AbstractMetaFunctionCPtr &func,
                        const AbstractMetaArgument &argument,
                        Options options = NoOption) const;
     /**
@@ -421,16 +421,16 @@ private:
      *   \param argument metaargument information to be parsed.
      *   \param options some extra options.
      */
-    QString argumentString(const AbstractMetaFunction *func,
+    QString argumentString(const AbstractMetaFunctionCPtr &func,
                            const AbstractMetaArgument &argument,
                            Options options = NoOption) const;
 
-    QString functionReturnType(const AbstractMetaFunction *func, Options options = NoOption) const;
+    QString functionReturnType(const AbstractMetaFunctionCPtr &func, Options options = NoOption) const;
 
     /// Utility function for writeCodeSnips.
     using ArgumentVarReplacementPair = QPair<AbstractMetaArgument, QString>;
     using ArgumentVarReplacementList = QList<ArgumentVarReplacementPair>;
-    ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
+    ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunctionCPtr &func,
                                                       bool usePyArgs, TypeSystem::Language language,
                                                       const AbstractMetaArgument *lastArg) const;
 
@@ -479,15 +479,15 @@ private:
     /// \param count the number of function arguments
     /// \param options some extra options used during the parser
     void writeArgumentNames(TextStream &s,
-                            const AbstractMetaFunction *func,
+                            const AbstractMetaFunctionCPtr &func,
                             Options options = NoOption) const;
 
     void writeFunctionArguments(TextStream &s,
-                                const AbstractMetaFunction *func,
+                                const AbstractMetaFunctionCPtr &func,
                                 Options options = NoOption) const;
 
     void replaceTemplateVariables(QString &code,
-                                  const AbstractMetaFunction *func) const;
+                                  const AbstractMetaFunctionCPtr &func) const;
 
     bool m_useCtorHeuristic = false;
     bool m_userReturnValueHeuristic = false;