shiboken2: AbstractMetaArgument: use QSharedData[Pointer]

Similar to AbstractMetaType, AbstractMetaArgument was previously
kept as a raw pointer. The data were copied numerous times by
AbstractMetaArgument::copy() when adding the inherited functions to a
AbstractMetaClass.

Similar to what was done for AbstractMetaType in
6cad0686101b252cfdbd1a6768a2b02c39aa1d8a, change the type to be based
on QSharedData[Pointer]. It can then be passed around and treated like
a C++ value type, with Qt sharing the data when possible behind the
scenes.

* Remove inheritance from  AbstractMetaVariable by moving
  the fields over.
* Remove the unused field m_originalName.

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

9 files changed, 212 insertions, 201 deletions

diff --git a/sources/shiboken2/generator/generator.cpp b/sources/shiboken2/generator/generator.cpp
index 94b0f93b2..72a5b9a2e 100644
--- a/sources/shiboken2/generator/generator.cpp
+++ b/sources/shiboken2/generator/generator.cpp
@@ -298,8 +298,8 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
 {
     addInstantiatedContainersAndSmartPointers(func->type(), func->signature());
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (const AbstractMetaArgument *arg : arguments)
-        addInstantiatedContainersAndSmartPointers(arg->type(), func->signature());
+    for (const AbstractMetaArgument &arg : arguments)
+        addInstantiatedContainersAndSmartPointers(arg.type(), func->signature());
 }
 
 void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMetaClass *metaClass)
@@ -525,8 +525,8 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
         code.replace(QLatin1String("%TYPE"), cpp_class->name());
 
     const AbstractMetaArgumentList &argument = func->arguments();
-    for (AbstractMetaArgument *arg : argument)
-        code.replace(QLatin1Char('%') + QString::number(arg->argumentIndex() + 1), arg->name());
+    for (const AbstractMetaArgument &arg : argument)
+        code.replace(QLatin1Char('%') + QString::number(arg.argumentIndex() + 1), arg.name());
 
     //template values
     code.replace(QLatin1String("%RETURN_TYPE"), translateType(func->type(), cpp_class));
@@ -790,7 +790,7 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaClass *metaClass) c
                                     QLatin1String("::") + qualifiedCppName);
             }
             // First argument has unmodified default: Default constructible with values
-            if (arguments.constFirst()->hasUnmodifiedDefaultValueExpression()) {
+            if (arguments.constFirst().hasUnmodifiedDefaultValueExpression()) {
                 return DefaultValue(DefaultValue::DefaultConstructorWithDefaultValues,
                                     QLatin1String("::") + qualifiedCppName);
             }
@@ -798,11 +798,11 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaClass *metaClass) c
             bool simple = true;
             bool suitable = true;
             for (int i = 0, size = arguments.size();
-                 suitable && i < size && !arguments.at(i)->hasOriginalDefaultValueExpression(); ++i) {
-                const AbstractMetaArgument *arg = arguments.at(i);
-                const TypeEntry *aType = arg->type().typeEntry();
+                 suitable && i < size && !arguments.at(i).hasOriginalDefaultValueExpression(); ++i) {
+                const AbstractMetaArgument &arg = arguments.at(i);
+                const TypeEntry *aType = arg.type().typeEntry();
                 suitable &= aType != cType;
-                simple &= aType->isCppPrimitive() || aType->isEnum() || isPointer(arg->type());
+                simple &= aType->isCppPrimitive() || aType->isEnum() || isPointer(arg.type());
             }
             if (suitable)
                 candidates.insert(arguments.size() + (simple ? 0 : 100), ctor);
@@ -814,14 +814,14 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaClass *metaClass) c
         QStringList args;
         bool ok = true;
         for (int i =0, size = arguments.size(); ok && i < size; ++i) {
-            const AbstractMetaArgument *arg = arguments.at(i);
-            if (arg->hasModifiedDefaultValueExpression()) {
-                args << arg->defaultValueExpression(); // Spell out modified values
+            const AbstractMetaArgument &arg = arguments.at(i);
+            if (arg.hasModifiedDefaultValueExpression()) {
+                args << arg.defaultValueExpression(); // Spell out modified values
                 break;
             }
-            if (arg->hasOriginalDefaultValueExpression())
+            if (arg.hasOriginalDefaultValueExpression())
                 break;
-            auto argValue = minimalConstructor(arg->type());
+            auto argValue = minimalConstructor(arg.type());
             ok &= argValue.isValid();
             args << argValue.constructorParameter();
         }
diff --git a/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
index f091860ca..53b403022 100644
--- a/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
@@ -88,7 +88,7 @@ static bool shouldSkip(const AbstractMetaFunction* func)
 
             const AbstractMetaArgumentList fargs = f->arguments();
             for (int i = 0, max = funcArgs.count(); i < max; ++i) {
-                if (funcArgs.at(i)->type().typeEntry() != fargs.at(i)->type().typeEntry()) {
+                if (funcArgs.at(i).type().typeEntry() != fargs.at(i).type().typeEntry()) {
                     cloneFound = false;
                     break;
                 }
@@ -1795,7 +1795,7 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
     }
 
     bool first = true;
-    QHash<QString, AbstractMetaArgument*> arg_map;
+    QHash<QString, AbstractMetaArgument> arg_map;
 
     IndentorBase<1> indent1;
     indent1.indent = INDENT.total();
@@ -1818,9 +1818,9 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
                 s << indent1 << rstDeprecationNote("constructor");
 
             const AbstractMetaArgumentList &arguments = func->arguments();
-            for (AbstractMetaArgument *arg : arguments) {
-                if (!arg_map.contains(arg->name())) {
-                    arg_map.insert(arg->name(), arg);
+            for (const AbstractMetaArgument &arg : arguments) {
+                if (!arg_map.contains(arg.name())) {
+                    arg_map.insert(arg.name(), arg);
                 }
             }
         }
@@ -1828,7 +1828,7 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
 
     s << Qt::endl;
 
-    for (QHash<QString, AbstractMetaArgument*>::const_iterator it = arg_map.cbegin(), end = arg_map.cend(); it != end; ++it) {
+    for (auto it = arg_map.cbegin(), end = arg_map.cend(); it != end; ++it) {
         Indentation indentation(INDENT, 2);
         writeParameterType(s, cppClass, it.value());
     }
@@ -1846,24 +1846,24 @@ QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* /* cppClass */
     int optArgs = 0;
 
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (AbstractMetaArgument *arg : arguments) {
+    for (const AbstractMetaArgument &arg : arguments) {
 
-        if (func->argumentRemoved(arg->argumentIndex() + 1))
+        if (func->argumentRemoved(arg.argumentIndex() + 1))
             continue;
 
-        bool thisIsoptional = !arg->defaultValueExpression().isEmpty();
+        bool thisIsoptional = !arg.defaultValueExpression().isEmpty();
         if (optArgs || thisIsoptional) {
             ret += QLatin1Char('[');
             optArgs++;
         }
 
-        if (arg->argumentIndex() > 0)
+        if (arg.argumentIndex() > 0)
             ret += QLatin1String(", ");
 
-        ret += arg->name();
+        ret += arg.name();
 
         if (thisIsoptional) {
-            QString defValue = arg->defaultValueExpression();
+            QString defValue = arg.defaultValueExpression();
             if (defValue == QLatin1String("QString()")) {
                 defValue = QLatin1String("\"\"");
             } else if (defValue == QLatin1String("QStringList()")
@@ -1876,7 +1876,7 @@ QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* /* cppClass */
                 defValue.replace(QLatin1String("::"), QLatin1String("."));
                 if (defValue == QLatin1String("nullptr"))
                     defValue = none();
-                else if (defValue == QLatin1String("0") && arg->type().isObject())
+                else if (defValue == QLatin1String("0") && arg.type().isObject())
                     defValue = none();
             }
             ret += QLatin1Char('=') + defValue;
@@ -2063,10 +2063,11 @@ QString QtDocGenerator::translateToPythonType(const AbstractMetaType &type,
     return strType;
 }
 
-void QtDocGenerator::writeParameterType(QTextStream& s, const AbstractMetaClass* cppClass, const AbstractMetaArgument* arg)
+void QtDocGenerator::writeParameterType(QTextStream& s, const AbstractMetaClass* cppClass,
+                                        const AbstractMetaArgument &arg)
 {
-    s << INDENT << ":param " << arg->name() << ": "
-      << translateToPythonType(arg->type(), cppClass) << Qt::endl;
+    s << INDENT << ":param " << arg.name() << ": "
+      << translateToPythonType(arg.type(), cppClass) << Qt::endl;
 }
 
 void QtDocGenerator::writeFunctionParametersType(QTextStream &s, const AbstractMetaClass *cppClass,
@@ -2074,9 +2075,9 @@ void QtDocGenerator::writeFunctionParametersType(QTextStream &s, const AbstractM
 {
     s << Qt::endl;
     const AbstractMetaArgumentList &funcArgs = func->arguments();
-    for (AbstractMetaArgument *arg : funcArgs) {
+    for (const AbstractMetaArgument &arg : funcArgs) {
 
-        if (func->argumentRemoved(arg->argumentIndex() + 1))
+        if (func->argumentRemoved(arg.argumentIndex() + 1))
             continue;
 
         writeParameterType(s, cppClass, arg);
diff --git a/sources/shiboken2/generator/qtdoc/qtdocgenerator.h b/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
index a562fe6be..70f6c7c26 100644
--- a/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
+++ b/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
@@ -258,7 +258,8 @@ private:
                                      const AbstractMetaFunction* func);
     void writeFunctionList(QTextStream& s, const AbstractMetaClass* cppClass);
     void writeFunctionBlock(QTextStream& s, const QString& title, QStringList& functions);
-    void writeParameterType(QTextStream &s, const AbstractMetaClass *cppClass, const AbstractMetaArgument *arg);
+    void writeParameterType(QTextStream &s, const AbstractMetaClass *cppClass,
+                            const AbstractMetaArgument &arg);
 
     void writeConstructors(QTextStream &s, const AbstractMetaClass *cppClass);
     void writeFormattedText(QTextStream &s, const Documentation &doc,
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index 5d1924818..4409e0fa0 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -793,7 +793,7 @@ void CppGenerator::writeConstructorNative(QTextStream &s, const GeneratorContext
     s << "\n{\n";
     if (wrapperDiagnostics())
         s << INDENT << R"(std::cerr << __FUNCTION__ << ' ' << this << '\n';)" << '\n';
-    const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
+    const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : &func->arguments().constLast();
     s << INDENT << "resetPyMethodCache();\n";
     writeCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg);
     s << INDENT << "// ... middle\n";
@@ -819,8 +819,8 @@ static bool allArgumentsRemoved(const AbstractMetaFunction *func)
     if (func->arguments().isEmpty())
         return false;
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (const AbstractMetaArgument *arg : arguments) {
-        if (!func->argumentRemoved(arg->argumentIndex() + 1))
+    for (const AbstractMetaArgument &arg : arguments) {
+        if (!func->argumentRemoved(arg.argumentIndex() + 1))
             return false;
     }
     return true;
@@ -918,7 +918,7 @@ QString CppGenerator::virtualMethodReturn(QTextStream &s,
                         qCWarning(lcShiboken, "The expression used in return value contains an invalid index.");
                         break;
                     }
-                    expr.replace(match.captured(0), func->arguments().at(argId)->name());
+                    expr.replace(match.captured(0), func->arguments().at(argId).name());
                     offset = match.capturedStart(1);
                 }
                 DefaultValue defaultReturnExpr(DefaultValue::Custom, expr);
@@ -980,7 +980,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream &s,
     const CodeSnipList snips = func->hasInjectedCode()
         ? func->injectedCodeSnips() : CodeSnipList();
     const AbstractMetaArgument *lastArg = func->arguments().isEmpty()
-        ?  nullptr : func->arguments().constLast();
+        ?  nullptr : &func->arguments().constLast();
 
     //Write declaration/native injected code
     if (!snips.isEmpty()) {
@@ -1049,13 +1049,13 @@ void CppGenerator::writeVirtualMethodNative(QTextStream &s,
     } else {
         QStringList argConversions;
         const AbstractMetaArgumentList &arguments = func->arguments();
-        for (const AbstractMetaArgument *arg : arguments) {
-            if (func->argumentRemoved(arg->argumentIndex() + 1))
+        for (const AbstractMetaArgument &arg : arguments) {
+            if (func->argumentRemoved(arg.argumentIndex() + 1))
                 continue;
 
             QString argConv;
             QTextStream ac(&argConv);
-            const auto &argType = arg->type();
+            const auto &argType = arg.type();
             auto argTypeEntry = static_cast<const PrimitiveTypeEntry *>(argType.typeEntry());
             bool convert = argTypeEntry->isObject()
                             || argTypeEntry->isValue()
@@ -1075,13 +1075,13 @@ void CppGenerator::writeVirtualMethodNative(QTextStream &s,
             Indentor nested;
             Indentation indentation(nested);
             ac << nested;
-            if (!func->conversionRule(TypeSystem::TargetLangCode, arg->argumentIndex() + 1).isEmpty()) {
+            if (!func->conversionRule(TypeSystem::TargetLangCode, arg.argumentIndex() + 1).isEmpty()) {
                 // Has conversion rule.
-                ac << arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
+                ac << arg.name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
             } else {
-                QString argName = arg->name();
+                QString argName = arg.name();
                 if (convert)
-                    writeToPythonConversion(ac, arg->type(), func->ownerClass(), argName);
+                    writeToPythonConversion(ac, arg.type(), func->ownerClass(), argName);
                 else
                     ac << argName;
             }
@@ -1113,7 +1113,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream &s,
         if (injectedCodeUsesPySelf(func))
             s << INDENT << "PyObject *pySelf = BindingManager::instance().retrieveWrapper(this);\n";
 
-        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : &func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg);
     }
 
@@ -1212,7 +1212,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream &s,
 
     if (func->hasInjectedCode()) {
         s << Qt::endl;
-        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : &func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, func, lastArg);
     }
 
@@ -1542,7 +1542,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
             // Constructor that does implicit conversion.
             if (!conv->typeReplaced(1).isEmpty() || conv->isModifiedToArray(1))
                 continue;
-            const AbstractMetaType sourceType = conv->arguments().constFirst()->type();
+            const AbstractMetaType sourceType = conv->arguments().constFirst().type();
             typeCheck = cpythonCheckFunction(sourceType);
             bool isUserPrimitiveWithoutTargetLangName = isUserPrimitive(sourceType)
                                                         && sourceType.typeEntry()->targetLangApiName() == sourceType.typeEntry()->name();
@@ -1586,7 +1586,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
         }
         const AbstractMetaType sourceType = conv->isConversionOperator()
                                             ? buildAbstractMetaTypeFromAbstractMetaClass(conv->ownerClass())
-                                            : conv->arguments().constFirst()->type();
+                                            : conv->arguments().constFirst().type();
         writePythonToCppConversionFunctions(s, sourceType, targetType, typeCheck, toCppConv, toCppPreConv);
     }
 
@@ -1722,7 +1722,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
             // Constructor that does implicit conversion.
             if (!conv->typeReplaced(1).isEmpty() || conv->isModifiedToArray(1))
                 continue;
-            sourceType = conv->arguments().constFirst()->type();
+            sourceType = conv->arguments().constFirst().type();
         }
         QString toCpp = pythonToCppFunctionName(sourceType, targetType);
         QString isConv = convertibleToCppFunctionName(sourceType, targetType);
@@ -1872,10 +1872,10 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
         const OverloadData::MetaFunctionList &overloads = overloadData.overloads();
         for (const AbstractMetaFunction *func : overloads) {
             const AbstractMetaArgumentList &arguments = func->arguments();
-            for (const AbstractMetaArgument *arg : arguments) {
-                if (arg->defaultValueExpression().isEmpty() || func->argumentRemoved(arg->argumentIndex() + 1))
+            for (const AbstractMetaArgument &arg : arguments) {
+                if (arg.defaultValueExpression().isEmpty() || func->argumentRemoved(arg.argumentIndex() + 1))
                     continue;
-                argNamesSet << arg->name();
+                argNamesSet << arg.name();
             }
         }
         QStringList argNamesList = argNamesSet.values();
@@ -2410,7 +2410,7 @@ static void checkTypeViability(const AbstractMetaFunction *func)
         return;
     checkTypeViability(func, func->type(), 0);
     for (int i = 0; i < func->arguments().count(); ++i)
-        checkTypeViability(func, func->arguments().at(i)->type(), i + 1);
+        checkTypeViability(func, func->arguments().at(i).type(), i + 1);
 }
 
 void CppGenerator::writeTypeCheck(QTextStream &s, const OverloadData *overloadData, QString argumentName)
@@ -2468,7 +2468,7 @@ const AbstractMetaType CppGenerator::getArgumentType(const AbstractMetaFunction
     if (typeReplaced.isEmpty()) {
         if (argPos == 0)
             return func->type();
-        auto argType = func->arguments().at(argPos - 1)->type();
+        auto argType = func->arguments().at(argPos - 1).type();
         return argType.viewOn() ? *argType.viewOn() : argType;
     }
 
@@ -2632,10 +2632,10 @@ void CppGenerator::writeConversionRule(QTextStream &s, const AbstractMetaFunctio
 {
     CodeSnipList snippets;
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (AbstractMetaArgument *arg : arguments) {
-        QString rule = func->conversionRule(language, arg->argumentIndex() + 1);
+    for (const AbstractMetaArgument &arg : arguments) {
+        QString rule = func->conversionRule(language, arg.argumentIndex() + 1);
         addConversionRuleCodeSnippet(snippets, rule, language, TypeSystem::TargetLangCode,
-                                     arg->name(), arg->name());
+                                     arg.name(), arg.name());
     }
     writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, func);
 }
@@ -2792,7 +2792,8 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream &s, const Ov
                 if (func->isConstructor() && func->arguments().count() == 1) {
                     const AbstractMetaClass *ownerClass = func->ownerClass();
                     const ComplexTypeEntry *baseContainerType = ownerClass->typeEntry()->baseContainerType();
-                    if (baseContainerType && baseContainerType == func->arguments().constFirst()->type().typeEntry() && isCopyable(ownerClass)) {
+                    if (baseContainerType && baseContainerType == func->arguments().constFirst().type().typeEntry()
+                        && isCopyable(ownerClass)) {
                         tck << '!' << cpythonCheckFunction(ownerClass->typeEntry()) << pyArgName << ")\n";
                         Indentation indent(INDENT);
                         tck << INDENT << "&& ";
@@ -2817,7 +2818,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream &s, const Ov
 
         if (usePyArgs && signatureFound) {
             AbstractMetaArgumentList args = refFunc->arguments();
-            const bool isVarargs = args.size() > 1 && args.constLast()->type().isVarargs();
+            const bool isVarargs = args.size() > 1 && args.constLast().type().isVarargs();
             int numArgs = args.size() - OverloadData::numberOfRemovedArguments(refFunc);
             if (isVarargs)
                 --numArgs;
@@ -2916,12 +2917,12 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s,
     int removedArgs = 0;
     for (int argIdx = 0; argIdx < func->arguments().count(); ++argIdx) {
         bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, argIdx + 1).isEmpty();
-        const AbstractMetaArgument *arg = func->arguments().at(argIdx);
+        const AbstractMetaArgument &arg = func->arguments().at(argIdx);
         if (func->argumentRemoved(argIdx + 1)) {
-            if (!arg->defaultValueExpression().isEmpty()) {
+            if (!arg.defaultValueExpression().isEmpty()) {
                 const QString cppArgRemoved = QLatin1String(CPP_ARG_REMOVED)
                     + QString::number(argIdx);
-                s << INDENT << getFullTypeName(arg->type()) << ' ' << cppArgRemoved;
+                s << INDENT << getFullTypeName(arg.type()) << ' ' << cppArgRemoved;
                 s << " = " << guessScopeForDefaultValue(func, arg) << ";\n";
                 writeUnusedVariableCast(s, cppArgRemoved);
             } else if (!injectCodeCallsFunc && !func->isUserAdded() && !hasConversionRule) {
@@ -3248,10 +3249,11 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream &s, const AbstractMe
         Indentation indent(INDENT);
         s << INDENT << "PyObject *keyName = nullptr;\n";
         s << INDENT << "PyObject *value = nullptr;\n";
-        for (const AbstractMetaArgument *arg : args) {
-            int pyArgIndex = arg->argumentIndex() - OverloadData::numberOfRemovedArguments(func, arg->argumentIndex());
+        for (const AbstractMetaArgument &arg : args) {
+            const int pyArgIndex = arg.argumentIndex()
+                - OverloadData::numberOfRemovedArguments(func, arg.argumentIndex());
             QString pyArgName = usePyArgs ? pythonArgsAt(pyArgIndex) : QLatin1String(PYTHON_ARG);
-            s << INDENT << "keyName = Py_BuildValue(\"s\",\"" << arg->name() << "\");\n";
+            s << INDENT << "keyName = Py_BuildValue(\"s\",\"" << arg.name() << "\");\n";
             s << INDENT << "if (PyDict_Contains(kwds, keyName)) {\n";
             {
                 Indentation indent(INDENT);
@@ -3259,7 +3261,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream &s, const AbstractMe
                 s << INDENT << "if (value && " << pyArgName << ") {\n";
                 {
                     Indentation indent(INDENT);
-                    s << INDENT << pyErrString.arg(arg->name()) << Qt::endl;
+                    s << INDENT << pyErrString.arg(arg.name()) << Qt::endl;
                     s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl;
                 }
                 s << INDENT << "}\n";
@@ -3268,7 +3270,8 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream &s, const AbstractMe
                     Indentation indent(INDENT);
                     s << INDENT << pyArgName << " = value;\n";
                     s << INDENT << "if (!";
-                    writeTypeCheck(s, arg->type(), pyArgName, isNumber(arg->type().typeEntry()), func->typeReplaced(arg->argumentIndex() + 1));
+                    writeTypeCheck(s, arg.type(), pyArgName, isNumber(arg.type().typeEntry()),
+                                   func->typeReplaced(arg.argumentIndex() + 1));
                     s << ")\n";
                     {
                         Indentation indent(INDENT);
@@ -3306,7 +3309,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction *func, in
         }
     } else {
         int realIndex = argIndex - 1 - OverloadData::numberOfRemovedArguments(func, argIndex - 1);
-        AbstractMetaType argType = getTypeWithoutContainer(func->arguments().at(realIndex)->type());
+        AbstractMetaType argType = getTypeWithoutContainer(func->arguments().at(realIndex).type());
 
         if (argType) {
             *wrappedClass = AbstractMetaClass::findClass(classes(), argType.typeEntry());
@@ -3373,12 +3376,12 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
         if (maxArgs > 0 && maxArgs < func->arguments().size() - OverloadData::numberOfRemovedArguments(func)) {
             int removedArgs = 0;
             for (int i = 0; i < maxArgs + removedArgs; i++) {
-                lastArg = func->arguments().at(i);
+                lastArg = &func->arguments().at(i);
                 if (func->argumentRemoved(i + 1))
                     removedArgs++;
             }
         } else if (maxArgs != 0 && !func->arguments().isEmpty()) {
-            lastArg = func->arguments().constLast();
+            lastArg = &func->arguments().constLast();
         }
 
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, func, lastArg);
@@ -3391,8 +3394,9 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
         if (func->functionType() != AbstractMetaFunction::CopyConstructorFunction) {
             int removedArgs = 0;
             for (int i = 0; i < maxArgs + removedArgs; i++) {
-                const AbstractMetaArgument *arg = func->arguments().at(i);
-                bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty();
+                const AbstractMetaArgument &arg = func->arguments().at(i);
+                bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode,
+                                                               arg.argumentIndex() + 1).isEmpty();
                 if (func->argumentRemoved(i + 1)) {
                     // If some argument with default value is removed from a
                     // method signature, the said value must be explicitly
@@ -3401,16 +3405,17 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
 
                     // If have conversion rules I will use this for removed args
                     if (hasConversionRule)
-                        userArgs << arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
-                    else if (!arg->defaultValueExpression().isEmpty())
+                        userArgs << arg.name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
+                    else if (!arg.defaultValueExpression().isEmpty())
                         userArgs.append(QLatin1String(CPP_ARG_REMOVED) + QString::number(i));
                 } else {
-                    int idx = arg->argumentIndex() - removedArgs;
-                    bool deRef = isValueTypeWithCopyConstructorOnly(arg->type())
-                                 || isObjectTypeUsedAsValueType(arg->type())
-                                 || (arg->type().referenceType() == LValueReference && isWrapperType(arg->type()) && !isPointer(arg->type()));
+                    int idx = arg.argumentIndex() - removedArgs;
+                    bool deRef = isValueTypeWithCopyConstructorOnly(arg.type())
+                                 || isObjectTypeUsedAsValueType(arg.type())
+                                 || (arg.type().referenceType() == LValueReference
+                                     && isWrapperType(arg.type()) && !isPointer(arg.type()));
                     if (hasConversionRule) {
-                        userArgs.append(arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX));
+                        userArgs.append(arg.name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX));
                     } else {
                         QString argName;
                         if (deRef)
@@ -3429,15 +3434,16 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
             bool otherArgsModified = false;
             bool argsClear = true;
             for (int i = func->arguments().size() - 1; i >= maxArgs + removedArgs; i--) {
-                const AbstractMetaArgument *arg = func->arguments().at(i);
-                const bool defValModified = arg->hasModifiedDefaultValueExpression();
-                bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty();
+                const AbstractMetaArgument &arg = func->arguments().at(i);
+                const bool defValModified = arg.hasModifiedDefaultValueExpression();
+                bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode,
+                                                               arg.argumentIndex() + 1).isEmpty();
                 if (argsClear && !defValModified && !hasConversionRule)
                     continue;
                 argsClear = false;
                 otherArgsModified |= defValModified || hasConversionRule || func->argumentRemoved(i + 1);
                 if (hasConversionRule)
-                    otherArgs.prepend(arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX));
+                    otherArgs.prepend(arg.name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX));
                 else
                     otherArgs.prepend(QLatin1String(CPP_ARG_REMOVED) + QString::number(i));
             }
@@ -4297,7 +4303,8 @@ void CppGenerator::writeMappingMethods(QTextStream &s,
 
         writeCppSelfDefinition(s, func, context);
 
-        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty()
+            ? nullptr : &func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode, func, lastArg);
         s<< "}\n\n";
     }
@@ -4324,7 +4331,7 @@ void CppGenerator::writeSequenceMethods(QTextStream &s,
 
         writeCppSelfDefinition(s, func, context);
 
-        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : &func->arguments().constLast();
         writeCodeSnips(s, snips,TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode, func, lastArg);
         s<< "}\n\n";
     }
@@ -4734,7 +4741,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, const GeneratorConte
             int alternativeNumericTypes = 0;
             for (const AbstractMetaFunction *func : overloads) {
                 if (!func->isStatic() &&
-                    ShibokenGenerator::isNumber(func->arguments().at(0)->type().typeEntry()))
+                    ShibokenGenerator::isNumber(func->arguments().at(0).type().typeEntry()))
                     alternativeNumericTypes++;
             }
 
@@ -4771,7 +4778,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, const GeneratorConte
                         if (!snips.isEmpty()) {
                             writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionAny,
                                            TypeSystem::TargetLangCode, func,
-                                           func->arguments().constLast());
+                                           &func->arguments().constLast());
                             generateOperatorCode = false;
                         }
                     }
@@ -4897,18 +4904,18 @@ void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunction
         if (!(f->isStatic()) && f->ownerClass())
             args << QLatin1String("self");
         const AbstractMetaArgumentList &arguments = f->arguments();
-        for (const AbstractMetaArgument *arg : arguments)  {
-            auto metaType = arg->type();
+        for (const AbstractMetaArgument &arg : arguments)  {
+            auto metaType = arg.type();
             if (auto viewOn = metaType.viewOn())
                 metaType = *viewOn;
             QString strArg = metaType.pythonSignature();
-            if (!arg->defaultValueExpression().isEmpty()) {
+            if (!arg.defaultValueExpression().isEmpty()) {
                 strArg += QLatin1Char('=');
-                QString e = arg->defaultValueExpression();
+                QString e = arg.defaultValueExpression();
                 e.replace(QLatin1String("::"), QLatin1String("."));
                 strArg += e;
             }
-            args << arg->name() + QLatin1Char(':') + strArg;
+            args << arg.name() + QLatin1Char(':') + strArg;
         }
         // mark the multiple signatures as such, to make it easier to generate different code
         if (multiple)
@@ -5075,8 +5082,8 @@ void CppGenerator::writeSignalInitialization(QTextStream &s, const AbstractMetaC
         if (cppSignal->declaringClass() != metaClass)
             continue;
         const AbstractMetaArgumentList &arguments = cppSignal->arguments();
-        for (AbstractMetaArgument *arg : arguments) {
-            AbstractMetaType metaType = arg->type();
+        for (const AbstractMetaArgument &arg : arguments) {
+            AbstractMetaType metaType = arg.type();
             const QByteArray origType =
                 QMetaObject::normalizedType(qPrintable(metaType.originalTypeDescription()));
             const QByteArray cppSig =
@@ -6231,8 +6238,8 @@ bool CppGenerator::writeParentChildManagement(QTextStream &s, const AbstractMeta
     int parentIndex = argOwner.index;
     int childIndex = argIndex;
     if (ctorHeuristicEnabled && argIndex > 0 && numArgs) {
-        AbstractMetaArgument *arg = func->arguments().at(argIndex-1);
-        if (arg->name() == QLatin1String("parent") && isObjectType(arg->type())) {
+        const AbstractMetaArgument &arg = func->arguments().at(argIndex-1);
+        if (arg.name() == QLatin1String("parent") && isObjectType(arg.type())) {
             action = ArgumentOwner::Add;
             parentIndex = argIndex;
             childIndex = -1;
diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.cpp b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
index 89f02f0b2..d607ed643 100644
--- a/sources/shiboken2/generator/shiboken2/headergenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
@@ -245,15 +245,15 @@ void HeaderGenerator::writeFunction(QTextStream &s, const AbstractMetaFunction *
         s << func->originalName() << '(';
         QStringList args;
         const AbstractMetaArgumentList &arguments = func->arguments();
-        for (const AbstractMetaArgument *arg : arguments) {
-            QString argName = arg->name();
+        for (const AbstractMetaArgument &arg : arguments) {
+            QString argName = arg.name();
             const TypeEntry *enumTypeEntry = nullptr;
-            if (arg->type().isFlags())
-                enumTypeEntry = static_cast<const FlagsTypeEntry *>(arg->type().typeEntry())->originator();
-            else if (arg->type().isEnum())
-                enumTypeEntry = arg->type().typeEntry();
+            if (arg.type().isFlags())
+                enumTypeEntry = static_cast<const FlagsTypeEntry *>(arg.type().typeEntry())->originator();
+            else if (arg.type().isEnum())
+                enumTypeEntry = arg.type().typeEntry();
             if (enumTypeEntry)
-                argName = QString::fromLatin1("%1(%2)").arg(arg->type().cppSignature(), argName);
+                argName = QString::fromLatin1("%1(%2)").arg(arg.type().cppSignature(), argName);
             args << argName;
         }
         s << args.join(QLatin1String(", ")) << ')';
@@ -644,15 +644,15 @@ void HeaderGenerator::writeInheritedOverloads(QTextStream &s)
         s << func->ownerClass()->qualifiedCppName() << "::" << func->originalName() << '(';
         QStringList args;
         const AbstractMetaArgumentList &arguments = func->arguments();
-        for (const AbstractMetaArgument *arg : arguments) {
-            QString argName = arg->name();
+        for (const AbstractMetaArgument &arg : arguments) {
+            QString argName = arg.name();
             const TypeEntry *enumTypeEntry = nullptr;
-            if (arg->type().isFlags())
-                enumTypeEntry = static_cast<const FlagsTypeEntry *>(arg->type().typeEntry())->originator();
-            else if (arg->type().isEnum())
-                enumTypeEntry = arg->type().typeEntry();
+            if (arg.type().isFlags())
+                enumTypeEntry = static_cast<const FlagsTypeEntry *>(arg.type().typeEntry())->originator();
+            else if (arg.type().isEnum())
+                enumTypeEntry = arg.type().typeEntry();
             if (enumTypeEntry)
-                argName = arg->type().cppSignature() + QLatin1Char('(') + argName + QLatin1Char(')');
+                argName = arg.type().cppSignature() + QLatin1Char('(') + argName + QLatin1Char(')');
             args << argName;
         }
         s << args.join(QLatin1String(", ")) << ')';
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.cpp b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
index dd0cb39eb..53fff9f25 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.cpp
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
@@ -143,7 +143,7 @@ static QString getImplicitConversionTypeName(const AbstractMetaType &containerTy
     else if (function->isConversionOperator())
         impConv = function->ownerClass()->typeEntry()->name();
     else
-        impConv = getTypeName(function->arguments().constFirst()->type());
+        impConv = getTypeName(function->arguments().constFirst().type());
 
     QStringList types;
     for (const auto &otherType : containerType.instantiations())
@@ -314,7 +314,7 @@ void OverloadData::sortNextOverloads()
             if (function->isConversionOperator())
                 convertibleType = function->ownerClass()->typeEntry()->name();
             else
-                convertibleType = getTypeName(function->arguments().constFirst()->type());
+                convertibleType = getTypeName(function->arguments().constFirst().type());
 
             if (convertibleType == intT() || convertibleType == unsignedIntT())
                 classesWithIntegerImplicitConversion << targetTypeEntryName;
@@ -489,8 +489,8 @@ OverloadData::OverloadData(const AbstractMetaFunctionList &overloads, const Shib
             m_maxArgs = argSize;
         OverloadData *currentOverloadData = this;
         const AbstractMetaArgumentList &arguments = func->arguments();
-        for (const AbstractMetaArgument *arg : arguments) {
-            if (func->argumentRemoved(arg->argumentIndex() + 1))
+        for (const AbstractMetaArgument &arg : arguments) {
+            if (func->argumentRemoved(arg.argumentIndex() + 1))
                 continue;
             currentOverloadData = currentOverloadData->addOverloadData(func, arg);
         }
@@ -530,7 +530,7 @@ void OverloadData::addOverload(const AbstractMetaFunction *func)
     for (int i = 0; m_headOverloadData->m_minArgs > 0 && i < origNumArgs; i++) {
         if (func->argumentRemoved(i + 1))
             continue;
-        if (func->arguments().at(i)->hasDefaultValueExpression()) {
+        if (func->arguments().at(i).hasDefaultValueExpression()) {
             int fixedArgIndex = i - removed;
             if (fixedArgIndex < m_headOverloadData->m_minArgs)
                 m_headOverloadData->m_minArgs = fixedArgIndex;
@@ -541,9 +541,9 @@ void OverloadData::addOverload(const AbstractMetaFunction *func)
 }
 
 OverloadData *OverloadData::addOverloadData(const AbstractMetaFunction *func,
-                                            const AbstractMetaArgument *arg)
+                                            const AbstractMetaArgument &arg)
 {
-    const AbstractMetaType &argType = arg->type();
+    const AbstractMetaType &argType = arg.type();
     OverloadData *overloadData = nullptr;
     if (!func->isOperatorOverload()) {
         for (OverloadData *tmp : qAsConst(m_nextOverloadData)) {
@@ -565,7 +565,7 @@ OverloadData *OverloadData::addOverloadData(const AbstractMetaFunction *func,
         overloadData = new OverloadData(m_headOverloadData, func, argType, m_argPos + 1);
         overloadData->m_previousOverloadData = this;
         overloadData->m_generator = this->m_generator;
-        QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1);
+        QString typeReplaced = func->typeReplaced(arg.argumentIndex() + 1);
 
         if (!typeReplaced.isEmpty())
             overloadData->m_argTypeReplaced = typeReplaced;
@@ -597,7 +597,7 @@ bool OverloadData::hasVarargs() const
 {
     for (const AbstractMetaFunction *func : m_overloads) {
         AbstractMetaArgumentList args = func->arguments();
-        if (args.size() > 1 && args.constLast()->type().isVarargs())
+        if (args.size() > 1 && args.constLast().type().isVarargs())
             return true;
     }
     return false;
@@ -677,7 +677,7 @@ const AbstractMetaArgument *OverloadData::argument(const AbstractMetaFunction *f
             argPos++;
     }
 
-    return func->arguments().at(m_argPos + removed);
+    return &func->arguments().at(m_argPos + removed);
 }
 
 OverloadDataList OverloadData::overloadDataOnPosition(OverloadData *overloadData, int argPos) const
@@ -762,7 +762,7 @@ const AbstractMetaFunction *OverloadData::getFunctionWithDefaultValue() const
             if (func->argumentRemoved(i + 1))
                 removedArgs++;
         }
-        if (func->arguments().at(m_argPos + removedArgs)->hasDefaultValueExpression())
+        if (func->arguments().at(m_argPos + removedArgs).hasDefaultValueExpression())
             return func;
     }
     return nullptr;
@@ -779,7 +779,7 @@ QVector<int> OverloadData::invalidArgumentLengths() const
             if (func->argumentRemoved(i+1)) {
                 offset++;
             } else {
-                if (args.at(i)->hasDefaultValueExpression())
+                if (args.at(i).hasDefaultValueExpression())
                     validArgLengths << i-offset;
             }
         }
@@ -828,7 +828,7 @@ QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList
             if (func->argumentRemoved(j + 1))
                 continue;
             int fixedArgIndex = j - removed;
-            if (fixedArgIndex < minArgs && func->arguments().at(j)->hasDefaultValueExpression())
+            if (fixedArgIndex < minArgs && func->arguments().at(j).hasDefaultValueExpression())
                 minArgs = fixedArgIndex;
         }
     }
@@ -1037,10 +1037,10 @@ bool OverloadData::hasArgumentWithDefaultValue() const
 bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction *func)
 {
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (const AbstractMetaArgument *arg : arguments) {
-        if (func->argumentRemoved(arg->argumentIndex() + 1))
+    for (const AbstractMetaArgument &arg : arguments) {
+        if (func->argumentRemoved(arg.argumentIndex() + 1))
             continue;
-        if (arg->hasDefaultValueExpression())
+        if (arg.hasDefaultValueExpression())
             return true;
     }
     return false;
@@ -1050,9 +1050,9 @@ AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const Abstr
 {
     AbstractMetaArgumentList args;
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (AbstractMetaArgument *arg : arguments) {
-        if (!arg->hasDefaultValueExpression()
-            || func->argumentRemoved(arg->argumentIndex() + 1))
+    for (const AbstractMetaArgument &arg : arguments) {
+        if (!arg.hasDefaultValueExpression()
+            || func->argumentRemoved(arg.argumentIndex() + 1))
             continue;
         args << arg;
     }
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.h b/sources/shiboken2/generator/shiboken2/overloaddata.h
index 8c165a0be..2507c3213 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.h
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.h
@@ -136,7 +136,7 @@ private:
                  const AbstractMetaType &argType, int argPos);
 
     void addOverload(const AbstractMetaFunction *func);
-    OverloadData *addOverloadData(const AbstractMetaFunction *func, const AbstractMetaArgument *arg);
+    OverloadData *addOverloadData(const AbstractMetaFunction *func, const AbstractMetaArgument &arg);
 
     void sortNextOverloads();
     bool sortByOverloadNumberModification();
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
index efbb81194..c097f4355 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
@@ -499,17 +499,17 @@ static QString searchForEnumScope(const AbstractMetaClass *metaClass, const QStr
 
 // Handle QFlags<> for guessScopeForDefaultValue()
 QString ShibokenGenerator::guessScopeForDefaultFlagsValue(const AbstractMetaFunction *func,
-                                                          const AbstractMetaArgument *arg,
+                                                          const AbstractMetaArgument &arg,
                                                           const QString &value) const
 {
     // Numeric values -> "Options(42)"
     static const QRegularExpression numberRegEx(QStringLiteral("^\\d+$")); // Numbers to flags
     Q_ASSERT(numberRegEx.isValid());
     if (numberRegEx.match(value).hasMatch()) {
-        QString typeName = translateTypeForWrapperMethod(arg->type(), func->implementingClass());
-        if (arg->type().isConstant())
+        QString typeName = translateTypeForWrapperMethod(arg.type(), func->implementingClass());
+        if (arg.type().isConstant())
             typeName.remove(0, sizeof("const ") / sizeof(char) - 1);
-        switch (arg->type().referenceType()) {
+        switch (arg.type().referenceType()) {
         case NoReference:
             break;
         case LValueReference:
@@ -564,13 +564,13 @@ QString ShibokenGenerator::guessScopeForDefaultFlagsValue(const AbstractMetaFunc
  * this method should be updated, do it with care.
  */
 QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction *func,
-                                                     const AbstractMetaArgument *arg) const
+                                                     const AbstractMetaArgument &arg) const
 {
-    QString value = arg->defaultValueExpression();
+    QString value = arg.defaultValueExpression();
 
     if (value.isEmpty() || value == QLatin1String("{}")
-        || arg->hasModifiedDefaultValueExpression()
-        || isPointer(arg->type())) {
+        || arg.hasModifiedDefaultValueExpression()
+        || isPointer(arg.type())) {
         return value;
     }
 
@@ -579,23 +579,24 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction
     // Do not qualify macros by class name, eg QSGGeometry(..., int t = GL_UNSIGNED_SHORT);
     static const QRegularExpression macroRegEx(QStringLiteral("^[A-Z_][A-Z0-9_]*$"));
     Q_ASSERT(macroRegEx.isValid());
-    if (arg->type().isPrimitive() && macroRegEx.match(value).hasMatch())
+    if (arg.type().isPrimitive() && macroRegEx.match(value).hasMatch())
         return value;
 
     QString prefix;
-    if (arg->type().isEnum()) {
-        if (const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(arg->type()))
+    if (arg.type().isEnum()) {
+        if (const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(arg.type()))
             prefix = resolveScopePrefix(metaEnum, value);
-    } else if (arg->type().isFlags()) {
+    } else if (arg.type().isFlags()) {
         value = guessScopeForDefaultFlagsValue(func, arg, value);
-    } else if (arg->type().typeEntry()->isValue()) {
-        const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), arg->type().typeEntry());
+    } else if (arg.type().typeEntry()->isValue()) {
+        const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(),
+                                                                          arg.type().typeEntry());
         if (enumValueRegEx.match(value).hasMatch() && value != QLatin1String("NULL"))
             prefix = resolveScopePrefix(metaClass, value);
-    } else if (arg->type().isPrimitive() && arg->type().name() == intT()) {
+    } else if (arg.type().isPrimitive() && arg.type().name() == intT()) {
         if (enumValueRegEx.match(value).hasMatch() && func->implementingClass())
             prefix = resolveScopePrefix(func->implementingClass(), value);
-    } else if (arg->type().isPrimitive()) {
+    } else if (arg.type().isPrimitive()) {
         static const QRegularExpression unknowArgumentRegEx(QStringLiteral("^(?:[A-Za-z_][\\w:]*\\()?([A-Za-z_]\\w*)(?:\\))?$")); // [PrimitiveType(] DESIREDNAME [)]
         Q_ASSERT(unknowArgumentRegEx.isValid());
         const QRegularExpressionMatch match = unknowArgumentRegEx.match(value);
@@ -705,13 +706,13 @@ bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFuncti
     if (argIndex < 0 || argIndex >= func->arguments().count())
         return false;
 
-    const AbstractMetaArgument *arg = func->arguments().at(argIndex);
-    if (isValueTypeWithCopyConstructorOnly(arg->type()))
+    const AbstractMetaArgument &arg = func->arguments().at(argIndex);
+    if (isValueTypeWithCopyConstructorOnly(arg.type()))
         return true;
 
     // Argument type is not a pointer, a None rejection should not be
     // necessary because the type checking would handle that already.
-    if (!isPointer(arg->type()))
+    if (!isPointer(arg.type()))
         return false;
     if (func->argumentRemoved(argIndex + 1))
         return false;
@@ -730,38 +731,39 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction *func,
     QString result;
     const char objType = (incRef ? 'O' : 'N');
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (const AbstractMetaArgument *arg : arguments) {
-        if (func->argumentRemoved(arg->argumentIndex() + 1))
+    for (const AbstractMetaArgument &arg : arguments) {
+        if (func->argumentRemoved(arg.argumentIndex() + 1))
             continue;
 
-        if (!func->typeReplaced(arg->argumentIndex() + 1).isEmpty()) {
+        const auto &type = arg.type();
+        if (!func->typeReplaced(arg.argumentIndex() + 1).isEmpty()) {
             result += QLatin1Char(objType);
-        } else if (arg->type().isObject()
-            || arg->type().isValue()
-            || arg->type().isValuePointer()
-            || arg->type().isNativePointer()
-            || arg->type().isEnum()
-            || arg->type().isFlags()
-            || arg->type().isContainer()
-            || arg->type().isSmartPointer()
-            || arg->type().referenceType() == LValueReference) {
+        } else if (arg.type().isObject()
+            || type.isValue()
+            || type.isValuePointer()
+            || type.isNativePointer()
+            || type.isEnum()
+            || type.isFlags()
+            || type.isContainer()
+            || type.isSmartPointer()
+            || type.referenceType() == LValueReference) {
             result += QLatin1Char(objType);
-        } else if (arg->type().isPrimitive()) {
+        } else if (type.isPrimitive()) {
             const auto *ptype =
-                static_cast<const PrimitiveTypeEntry *>(arg->type().typeEntry());
+                static_cast<const PrimitiveTypeEntry *>(type.typeEntry());
             if (ptype->basicReferencedTypeEntry())
                 ptype = ptype->basicReferencedTypeEntry();
             if (m_formatUnits.contains(ptype->name()))
                 result += m_formatUnits[ptype->name()];
             else
                 result += QLatin1Char(objType);
-        } else if (isCString(arg->type())) {
+        } else if (isCString(type)) {
             result += QLatin1Char('z');
         } else {
             qCWarning(lcShiboken).noquote().nospace()
                 << "Method: " << func->ownerClass()->qualifiedCppName()
                 << "::" << func->signature() << " => Arg:"
-                << arg->name() << "index: " << arg->argumentIndex()
+                << arg.name() << "index: " << arg.argumentIndex()
                 << " - cannot be handled properly. Use an inject-code to fix it!";
             result += QLatin1Char('?');
         }
@@ -1137,9 +1139,9 @@ bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType &type)
     return isCppPrimitive(type.typeEntry());
 }
 
-bool ShibokenGenerator::shouldDereferenceArgumentPointer(const AbstractMetaArgument *arg)
+bool ShibokenGenerator::shouldDereferenceArgumentPointer(const AbstractMetaArgument &arg)
 {
-    return shouldDereferenceAbstractMetaTypePointer(arg->type());
+    return shouldDereferenceAbstractMetaTypePointer(arg.type());
 }
 
 bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType &metaType)
@@ -1336,9 +1338,9 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(AbstractMetaType metaTyp
     return result;
 }
 
-QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgument *metaArg, bool genericNumberType)
+QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgument &metaArg, bool genericNumberType)
 {
-    return cpythonIsConvertibleFunction(metaArg->type(), genericNumberType);
+    return cpythonIsConvertibleFunction(metaArg.type(), genericNumberType);
 }
 
 QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass *metaClass)
@@ -1404,16 +1406,16 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry *ty
 }
 
 QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
-                                          const AbstractMetaArgument *argument,
+                                          const AbstractMetaArgument &argument,
                                           Options options) const
 {
     QString modified_type;
     if (!(options & OriginalTypeDescription))
-        modified_type = func->typeReplaced(argument->argumentIndex() + 1);
+        modified_type = func->typeReplaced(argument.argumentIndex() + 1);
     QString arg;
 
     if (modified_type.isEmpty())
-        arg = translateType(argument->type(), func->implementingClass(), options);
+        arg = translateType(argument.type(), func->implementingClass(), options);
     else
         arg = modified_type.replace(QLatin1Char('$'), QLatin1Char('.'));
 
@@ -1421,15 +1423,15 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
         // "int a", "int a[]"
         const int arrayPos = arg.indexOf(QLatin1Char('['));
         if (arrayPos != -1)
-            arg.insert(arrayPos, QLatin1Char(' ') + argument->name());
+            arg.insert(arrayPos, QLatin1Char(' ') + argument.name());
         else
-            arg.append(QLatin1Char(' ') + argument->name());
+            arg.append(QLatin1Char(' ') + argument.name());
     }
 
     if ((options & Generator::SkipDefaultValues) != Generator::SkipDefaultValues &&
-        !argument->originalDefaultValueExpression().isEmpty())
+        !argument.originalDefaultValueExpression().isEmpty())
     {
-        QString default_value = argument->originalDefaultValueExpression();
+        QString default_value = argument.originalDefaultValueExpression();
         if (default_value == QLatin1String("NULL"))
             default_value = QLatin1String(NULL_PTR);
 
@@ -1445,7 +1447,7 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
 
 void ShibokenGenerator::writeArgument(QTextStream &s,
                                       const AbstractMetaFunction *func,
-                                      const AbstractMetaArgument *argument,
+                                      const AbstractMetaArgument &argument,
                                       Options options) const
 {
     s << argumentString(func, argument, options);
@@ -1535,11 +1537,11 @@ void ShibokenGenerator::writeArgumentNames(QTextStream &s,
     const AbstractMetaArgumentList arguments = func->arguments();
     int argCount = 0;
     for (auto argument : arguments) {
-        const int index = argument->argumentIndex() + 1;
+        const int index = argument.argumentIndex() + 1;
         if ((options & Generator::SkipRemovedArguments) && (func->argumentRemoved(index)))
             continue;
 
-        s << ((argCount > 0) ? ", " : "") << argument->name();
+        s << ((argCount > 0) ? ", " : "") << argument.name();
 
         if (((options & Generator::VirtualCall) == 0)
             && (!func->conversionRule(TypeSystem::NativeCode, index).isEmpty()
@@ -1718,7 +1720,7 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
                                     ? TypeSystem::NativeCode : TypeSystem::TargetLangCode;
     int removed = 0;
     for (int i = 0; i < func->arguments().size(); ++i) {
-        const AbstractMetaArgument *arg = func->arguments().at(i);
+        const AbstractMetaArgument &arg = func->arguments().at(i);
         QString argValue;
         if (language == TypeSystem::TargetLangCode) {
             bool hasConversionRule = !func->conversionRule(convLang, i+1).isEmpty();
@@ -1726,13 +1728,13 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
             if (argRemoved)
                 ++removed;
             if (argRemoved && hasConversionRule)
-                argValue = arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
-            else if (argRemoved || (lastArg && arg->argumentIndex() > lastArg->argumentIndex()))
+                argValue = arg.name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
+            else if (argRemoved || (lastArg && arg.argumentIndex() > lastArg->argumentIndex()))
                 argValue = QLatin1String(CPP_ARG_REMOVED) + QString::number(i);
             if (!argRemoved && argValue.isEmpty()) {
                 int argPos = i - removed;
-                AbstractMetaType type = arg->type();
-                QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1);
+                AbstractMetaType type = arg.type();
+                QString typeReplaced = func->typeReplaced(arg.argumentIndex() + 1);
                 if (!typeReplaced.isEmpty()) {
                     AbstractMetaType builtType = buildAbstractMetaTypeFromString(typeReplaced);
                     if (builtType)
@@ -1743,7 +1745,7 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
                                ? pythonArgsAt(argPos) : QLatin1String(PYTHON_ARG);
                 } else {
                     argValue = hasConversionRule
-                               ? arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX)
+                               ? arg.name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX)
                                : QLatin1String(CPP_ARG) + QString::number(argPos);
                     if (isWrapperType(type)) {
                         if (type.referenceType() == LValueReference && !isPointer(type))
@@ -1752,7 +1754,7 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
                 }
             }
         } else {
-            argValue = arg->name();
+            argValue = arg.name();
         }
         if (!argValue.isEmpty())
             argReplacements << ArgumentVarReplacementPair(arg, argValue);
@@ -1846,9 +1848,9 @@ void ShibokenGenerator::writeCodeSnips(QTextStream &s,
 
     // Replace %ARG#_TYPE variables.
     const AbstractMetaArgumentList &arguments = func->arguments();
-    for (const AbstractMetaArgument *arg : arguments) {
-        QString argTypeVar = QStringLiteral("%ARG%1_TYPE").arg(arg->argumentIndex() + 1);
-        QString argTypeVal = arg->type().cppSignature();
+    for (const AbstractMetaArgument &arg : arguments) {
+        QString argTypeVar = QStringLiteral("%ARG%1_TYPE").arg(arg.argumentIndex() + 1);
+        QString argTypeVal = arg.type().cppSignature();
         code.replace(argTypeVar, argTypeVal);
     }
 
@@ -1951,10 +1953,10 @@ void ShibokenGenerator::writeCodeSnips(QTextStream &s,
     code.replace(QLatin1String("%ARGUMENT_NAMES"), args.join(QLatin1String(", ")));
 
     for (const ArgumentVarReplacementPair &pair : argReplacements) {
-        const AbstractMetaArgument *arg = pair.first;
-        int idx = arg->argumentIndex() + 1;
-        AbstractMetaType type = arg->type();
-        QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1);
+        const AbstractMetaArgument &arg = pair.first;
+        int idx = arg.argumentIndex() + 1;
+        AbstractMetaType type = arg.type();
+        QString typeReplaced = func->typeReplaced(arg.argumentIndex() + 1);
         if (!typeReplaced.isEmpty()) {
             AbstractMetaType builtType = buildAbstractMetaTypeFromString(typeReplaced);
             if (builtType)
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
index 7b2f0cb39..0d49764ab 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
@@ -297,7 +297,7 @@ protected:
     static bool isCppIntegralPrimitive(const AbstractMetaType &type);
 
     /// Checks if an argument type should be dereferenced by the Python method wrapper before calling the C++ method.
-    static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument *arg);
+    static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument &arg);
     /// Checks if a meta type should be dereferenced by the Python method wrapper passing it to C++.
     static bool shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType &metaType);
 
@@ -330,7 +330,7 @@ protected:
     QString guessCPythonCheckFunction(const QString &type, AbstractMetaType *metaType);
     QString cpythonIsConvertibleFunction(const TypeEntry *type, bool genericNumberType = false, bool checkExact = false);
     QString cpythonIsConvertibleFunction(AbstractMetaType metaType, bool genericNumberType = false);
-    QString cpythonIsConvertibleFunction(const AbstractMetaArgument *metaArg, bool genericNumberType = false);
+    QString cpythonIsConvertibleFunction(const AbstractMetaArgument &metaArg, bool genericNumberType = false);
 
     QString cpythonToCppConversionFunction(const AbstractMetaClass *metaClass);
     QString cpythonToCppConversionFunction(const AbstractMetaType &type, const AbstractMetaClass *context = nullptr);
@@ -356,9 +356,9 @@ protected:
 
     /// Guesses the scope to where belongs an argument's default value.
     QString guessScopeForDefaultValue(const AbstractMetaFunction *func,
-                                      const AbstractMetaArgument *arg) const;
+                                      const AbstractMetaArgument &arg) const;
     QString guessScopeForDefaultFlagsValue(const AbstractMetaFunction *func,
-                                           const AbstractMetaArgument *arg,
+                                           const AbstractMetaArgument &arg,
                                            const QString &value) const;
 
     static QString cpythonEnumName(const EnumTypeEntry *enumEntry);
@@ -505,7 +505,7 @@ private:
      */
     void writeArgument(QTextStream &s,
                        const AbstractMetaFunction *func,
-                       const AbstractMetaArgument *argument,
+                       const AbstractMetaArgument &argument,
                        Options options = NoOption) const;
     /**
      *   Create a QString in the C++ format to an function argument.
@@ -514,13 +514,13 @@ private:
      *   \param options some extra options.
      */
     QString argumentString(const AbstractMetaFunction *func,
-                           const AbstractMetaArgument *argument,
+                           const AbstractMetaArgument &argument,
                            Options options = NoOption) const;
 
     QString functionReturnType(const AbstractMetaFunction *func, Options options = NoOption) const;
 
     /// Utility function for writeCodeSnips.
-    using ArgumentVarReplacementPair = QPair<const AbstractMetaArgument *, QString>;
+    using ArgumentVarReplacementPair = QPair<AbstractMetaArgument, QString>;
     using ArgumentVarReplacementList = QVector<ArgumentVarReplacementPair>;
     ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
                                                       bool usePyArgs, TypeSystem::Language language,