shiboken: Remove unused code in abstractmetalang.h

The AbstractMeta* classes had a lot of functions trying to determine
whether wrapper functions/classes should be generated. Apparently at
some stage, this functionality was moved to the generator classes
(apparently in conjunction with the "protected hack"), leaving the functions
unused.

Change-Id: Ia3fef96fe86cc6a6f9c70c674635bccf510362bc
Reviewed-by: Christian Tismer <tismer@stackless.com>
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

3 files changed, 25 insertions, 547 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index ae71597bd..ceb45524f 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -212,30 +212,6 @@ AbstractMetaType::TypeUsagePattern AbstractMetaType::determineUsagePattern() con
     if (m_typeEntry->isVarargs())
         return VarargsPattern;
 
-    if (m_typeEntry->isString() && indirections() == 0
-        && (isConstant() == (m_referenceType == LValueReference)
-        || isConstant())) {
-        return StringPattern;
-    }
-
-    if (m_typeEntry->isChar()
-        && indirections() == 0
-        && isConstant() == (m_referenceType == LValueReference)) {
-        return CharPattern;
-    }
-
-    if (m_typeEntry->isJObjectWrapper()
-        && indirections() == 0
-        && isConstant() == (m_referenceType == LValueReference)) {
-        return JObjectWrapperPattern;
-    }
-
-    if (m_typeEntry->isVariant()
-        && indirections() == 0
-        && isConstant() == (m_referenceType == LValueReference)) {
-        return VariantPattern;
-    }
-
     if (m_typeEntry->isEnum() && actualIndirections() == 0)
         return EnumPattern;
 
@@ -259,11 +235,6 @@ AbstractMetaType::TypeUsagePattern AbstractMetaType::determineUsagePattern() con
     if (m_typeEntry->isArray())
         return ArrayPattern;
 
-    if (m_typeEntry->isThread()) {
-        Q_ASSERT(indirections() == 1);
-        return ThreadPattern;
-    }
-
     if (m_typeEntry->isValue())
         return indirections() == 1 ? ValuePointerPattern : ValuePattern;
 
@@ -411,63 +382,6 @@ bool AbstractMetaFunction::isModifiedRemoved(int types) const
     return false;
 }
 
-bool AbstractMetaFunction::needsCallThrough() const
-{
-    if (ownerClass()->isInterface())
-        return false;
-    if (referenceCounts(implementingClass()).size() > 0)
-        return true;
-    if (argumentsHaveNativeId() || !isStatic())
-        return true;
-
-    for (const AbstractMetaArgument *arg : m_arguments) {
-        if (arg->type()->isArray() || arg->type()->isTargetLangEnum() || arg->type()->isTargetLangFlags())
-            return true;
-    }
-
-    if (type() && (type()->isArray() || type()->isTargetLangEnum() || type()->isTargetLangFlags()))
-        return true;
-
-    for (int i = -1; i <= arguments().size(); ++i) {
-        TypeSystem::Ownership owner = this->ownership(implementingClass(), TypeSystem::TargetLangCode, i);
-        if (owner != TypeSystem::InvalidOwnership)
-            return true;
-    }
-
-    return false;
-}
-
-bool AbstractMetaFunction::needsSuppressUncheckedWarning() const
-{
-    for (int i = -1; i <= arguments().size(); ++i) {
-        const QVector<ReferenceCount> &referenceCounts = this->referenceCounts(implementingClass(), i);
-        for (const ReferenceCount &referenceCount : referenceCounts) {
-            if (referenceCount.action != ReferenceCount::Set)
-                return true;
-        }
-    }
-    return false;
-}
-
-QString AbstractMetaFunction::marshalledName() const
-{
-    QString returned = QLatin1String("__qt_") + name();
-    for (const AbstractMetaArgument *arg : m_arguments) {
-        returned += QLatin1Char('_');
-        if (arg->type()->isNativePointer()) {
-            returned += QLatin1String("nativepointer");
-        } else if (arg->type()->isIntegerEnum() || arg->type()->isIntegerFlags()) {
-            returned += QLatin1String("int");
-        } else {
-            QString a = arg->type()->name();
-            a.replace(QLatin1String("[]"), QLatin1String("_3"));
-            a.replace(QLatin1Char('.'), QLatin1Char('_'));
-            returned += a;
-        }
-    }
-    return returned;
-}
-
 bool AbstractMetaFunction::operator<(const AbstractMetaFunction &other) const
 {
     return compareTo(&other) & NameLessThan;
@@ -711,68 +625,6 @@ bool AbstractMetaFunction::removedDefaultExpression(const AbstractMetaClass *cls
     return false;
 }
 
-bool AbstractMetaFunction::resetObjectAfterUse(int argumentIdx) const
-{
-    const AbstractMetaClass *cls = declaringClass();
-    const FunctionModificationList &modifications = this->modifications(cls);
-    for (const FunctionModification &modification : modifications) {
-        for (const ArgumentModification &argumentModification : modification.argument_mods) {
-            if (argumentModification.index == argumentIdx && argumentModification.resetAfterUse)
-                return true;
-        }
-    }
-
-    return false;
-}
-
-QString AbstractMetaFunction::nullPointerDefaultValue(const AbstractMetaClass *mainClass, int argumentIdx) const
-{
-    Q_ASSERT(nullPointersDisabled(mainClass, argumentIdx));
-
-    const AbstractMetaClass *cls = mainClass;
-    if (!cls)
-        cls = implementingClass();
-
-    do {
-        const FunctionModificationList &modifications = this->modifications(cls);
-        for (const FunctionModification &modification : modifications) {
-            for (const ArgumentModification &argumentModification : modification.argument_mods) {
-                if (argumentModification.index == argumentIdx
-                    && argumentModification.noNullPointers) {
-                    return argumentModification.nullPointerDefaultValue;
-                }
-            }
-        }
-        cls = cls->baseClass();
-    } while (cls && !mainClass); // Once when mainClass, or once for all base classes of implementing class
-
-    return QString();
-
-}
-
-bool AbstractMetaFunction::nullPointersDisabled(const AbstractMetaClass *mainClass, int argumentIdx) const
-{
-    const AbstractMetaClass *cls = mainClass;
-    if (!cls)
-        cls = implementingClass();
-
-    do {
-        const FunctionModificationList &modifications = this->modifications(cls);
-        for (const FunctionModification &modification : modifications) {
-            for (const ArgumentModification &argumentModification : modification.argument_mods) {
-                if (argumentModification.index == argumentIdx
-                    && argumentModification.noNullPointers) {
-                    return true;
-                }
-            }
-        }
-
-        cls = cls->baseClass();
-    } while (cls && !mainClass); // Once when mainClass, or once for all base classes of implementing class
-
-    return false;
-}
-
 QString AbstractMetaFunction::conversionRule(TypeSystem::Language language, int key) const
 {
     const FunctionModificationList &modifications = this->modifications(declaringClass());
@@ -831,27 +683,6 @@ bool AbstractMetaFunction::isVirtualSlot() const
     return false;
 }
 
-bool AbstractMetaFunction::disabledGarbageCollection(const AbstractMetaClass *cls, int key) const
-{
-    typedef QHash<TypeSystem::Language, TypeSystem::Ownership>::const_iterator OwnershipMapIt;
-
-    const FunctionModificationList &modifications = this->modifications(cls);
-    for (const FunctionModification &modification : modifications) {
-        for (const ArgumentModification &argumentModification : modification.argument_mods) {
-            if (argumentModification.index != key)
-                continue;
-
-            for (OwnershipMapIt it = argumentModification.ownerships.cbegin(), end = argumentModification.ownerships.cend(); it != end; ++it) {
-                if (it.value() == TypeSystem::CppOwnership)
-                    return true;
-            }
-
-        }
-    }
-
-    return false;
-}
-
 bool AbstractMetaFunction::isDeprecated() const
 {
     const FunctionModificationList &modifications = this->modifications(declaringClass());
@@ -862,16 +693,6 @@ bool AbstractMetaFunction::isDeprecated() const
     return false;
 }
 
-bool AbstractMetaFunction::isThread() const
-{
-    const FunctionModificationList &modifications = this->modifications(declaringClass());
-    for (const FunctionModification &modification : modifications) {
-        if (modification.isThread())
-            return true;
-    }
-    return false;
-}
-
 bool AbstractMetaFunction::allowThread() const
 {
     const FunctionModificationList &modifications = this->modifications(declaringClass());
@@ -996,11 +817,6 @@ FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaC
     return mods;
 }
 
-bool AbstractMetaFunction::hasModifications(const AbstractMetaClass *implementor) const
-{
-    return !modifications(implementor).isEmpty();
-}
-
 QString AbstractMetaFunction::argumentName(int index,
                                            bool /* create */,
                                            const AbstractMetaClass * /* implementor */) const
@@ -1215,46 +1031,6 @@ QString AbstractMetaFunction::modifiedName() const
     return m_cachedModifiedName;
 }
 
-QString AbstractMetaFunction::targetLangSignature(bool minimal) const
-{
-    QString s;
-
-    // Attributes...
-    if (!minimal) {
-        // Return type
-        if (type())
-            s += type()->name() + QLatin1Char(' ');
-        else
-            s += QLatin1String("void ");
-    }
-
-    s += modifiedName();
-    s += QLatin1Char('(');
-
-    int j = 0;
-    for (int i = 0; i < m_arguments.size(); ++i) {
-        if (argumentRemoved(i + 1))
-            continue;
-        if (j) {
-            s += QLatin1Char(',');
-            if (!minimal)
-                s += QLatin1Char(' ');
-        }
-        s += m_arguments.at(i)->type()->name();
-
-        if (!minimal) {
-            s += QLatin1Char(' ');
-            s += m_arguments.at(i)->name();
-        }
-        ++j;
-    }
-
-    s += QLatin1Char(')');
-
-    return s;
-}
-
-
 bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b)
 {
     return a->signature() < b->signature();
@@ -1459,19 +1235,6 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
     return returned;
 }
 
-AbstractMetaFunctionList AbstractMetaClass::virtualFunctions() const
-{
-    const AbstractMetaFunctionList &list = functionsInShellClass();
-
-    AbstractMetaFunctionList returned;
-    for (AbstractMetaFunction *f : list) {
-        if (!f->isFinalInCpp() || f->isVirtualSlot())
-            returned += f;
-    }
-
-    return returned;
-}
-
 AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
 {
     if (!hasCloneOperator() && !hasExternalConversionOperators())
@@ -1515,15 +1278,6 @@ AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptio
     return returned;
 }
 
-bool AbstractMetaClass::hasOperatorOverload() const
-{
-    for (const AbstractMetaFunction *f : m_functions) {
-        if (f->ownerClass() == f->implementingClass() && f->isOperatorOverload() && !f->isPrivate())
-            return true;
-    }
-    return false;
-}
-
 bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 {
     for (const AbstractMetaFunction *f : m_functions) {
@@ -1560,72 +1314,6 @@ bool AbstractMetaClass::hasLogicalOperatorOverload() const
     return false;
 }
 
-bool AbstractMetaClass::hasSubscriptOperatorOverload() const
-{
-    for (const AbstractMetaFunction *f : m_functions) {
-        if (f->ownerClass() == f->implementingClass() && f->isSubscriptOperator() && !f->isPrivate())
-            return true;
-    }
-    return false;
-}
-
-bool AbstractMetaClass::hasAssignmentOperatorOverload() const
-{
-    for (const AbstractMetaFunction *f : m_functions) {
-        if (f->ownerClass() == f->implementingClass() && f->isAssignmentOperator() && !f->isPrivate())
-            return true;
-    }
-    return false;
-}
-
-bool AbstractMetaClass::hasConversionOperatorOverload() const
-{
-    for (const AbstractMetaFunction *f : m_functions) {
-        if (f->ownerClass() == f->implementingClass() && f->isConversionOperator() && !f->isPrivate())
-            return true;
-    }
-    return false;
-}
-
-/*******************************************************************************
- * Returns a list of all functions that should be declared and implemented in
- * the shell class which is generated as a wrapper on top of the actual C++ class
- */
-AbstractMetaFunctionList AbstractMetaClass::functionsInShellClass() const
-{
-    // Only functions and only protected and public functions
-    FunctionQueryOptions default_flags = NormalFunctions | Visible | WasVisible | NotRemovedFromShell;
-
-    // All virtual functions
-    AbstractMetaFunctionList returned = queryFunctions(VirtualFunctions | default_flags);
-
-    // All functions explicitly set to be implemented by the shell class
-    // (mainly superclass functions that are hidden by other declarations)
-    returned += queryFunctions(ForcedShellFunctions | default_flags);
-
-    // All functions explicitly set to be virtual slots
-    returned += queryFunctions(VirtualSlots | default_flags);
-
-    return returned;
-}
-
-/*******************************************************************************
- * Returns a list of all functions that require a public override function to
- * be generated in the shell class. This includes all functions that were originally
- * protected in the superclass.
- */
-AbstractMetaFunctionList AbstractMetaClass::publicOverrideFunctions() const
-{
-    return queryFunctions(NormalFunctions | WasProtected | FinalInCppFunctions | NotRemovedFromTargetLang)
-           + queryFunctions(Signals | WasProtected | FinalInCppFunctions | NotRemovedFromTargetLang);
-}
-
-AbstractMetaFunctionList AbstractMetaClass::virtualOverrideFunctions() const
-{
-    return queryFunctions(NormalFunctions | NonEmptyFunctions | Visible | VirtualInCppFunctions | NotRemovedFromShell) +
-           queryFunctions(Signals | NonEmptyFunctions | Visible | VirtualInCppFunctions | NotRemovedFromShell);
-}
-
 void AbstractMetaClass::sortFunctions()
 {
     qSort(m_functions.begin(), m_functions.end(), function_sorter);
@@ -1639,8 +1327,6 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
     sortFunctions();
 
     QString currentName;
-    bool hasVirtuals = false;
-    AbstractMetaFunctionList finalFunctions;
     for (AbstractMetaFunction *f : qAsConst(m_functions)) {
         f->setOwnerClass(this);
 
@@ -1648,30 +1334,6 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
         m_hasVirtuals = m_hasVirtuals || f->isVirtualSlot() || hasVirtualDestructor();
         m_isPolymorphic = m_isPolymorphic || m_hasVirtuals;
         m_hasNonpublic = m_hasNonpublic || !f->isPublic();
-
-        // If we have non-virtual overloads of a virtual function, we have to implement
-        // all the overloads in the shell class to override the hiding rule
-        if (currentName == f->name()) {
-            hasVirtuals = hasVirtuals || !f->isFinal();
-            if (f->isFinal())
-                finalFunctions += f;
-        } else {
-            if (hasVirtuals && finalFunctions.size() > 0) {
-                for (AbstractMetaFunction *final_function : qAsConst(finalFunctions)) {
-                    *final_function += AbstractMetaAttributes::ForceShellImplementation;
-
-                    qCWarning(lcShiboken).noquote().nospace()
-                        << QStringLiteral("hiding of function '%1' in class '%2'")
-                                          .arg(final_function->name(), name());
-                }
-            }
-
-            hasVirtuals = !f->isFinal();
-            finalFunctions.clear();
-            if (f->isFinal())
-                finalFunctions += f;
-            currentName = f->name();
-        }
     }
 }
 
@@ -1799,13 +1461,6 @@ bool AbstractMetaClass::hasProtectedMembers() const
     return hasProtectedFields() || hasProtectedFunctions();
 }
 
-bool AbstractMetaClass::generateShellClass() const
-{
-    return m_forceShellClass ||
-           (isConstructible()
-            && (m_hasVirtuals || hasProtectedFunctions() || hasFieldAccessors()));
-}
-
 QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const
 {
     for (int i = 0; i < m_propertySpecs.size(); ++i)
@@ -2151,22 +1806,12 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions
     AbstractMetaFunctionList functions;
 
     for (AbstractMetaFunction *f : m_functions) {
-
-        if ((query & VirtualSlots) && !f->isVirtualSlot())
-            continue;
-
         if ((query & NotRemovedFromTargetLang) && f->isRemovedFrom(f->implementingClass(), TypeSystem::TargetLangCode))
             continue;
 
         if ((query & NotRemovedFromTargetLang) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode))
             continue;
 
-        if ((query & NotRemovedFromShell) && f->isRemovedFrom(f->implementingClass(), TypeSystem::ShellCode))
-            continue;
-
-        if ((query & NotRemovedFromShell) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::ShellCode))
-            continue;
-
         if ((query & Visible) && f->isPrivate())
             continue;
 
@@ -2182,35 +1827,18 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions
         if ((query & WasPublic) && !f->wasPublic())
             continue;
 
-        if ((query & WasVisible) && f->wasPrivate())
-            continue;
-
-        if ((query & WasProtected) && !f->wasProtected())
-            continue;
-
         if ((query & ClassImplements) && f->ownerClass() != f->implementingClass())
             continue;
 
-        if ((query & Inconsistent) && (f->isFinalInTargetLang() || !f->isFinalInCpp() || f->isStatic()))
-            continue;
-
         if ((query & FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
             continue;
 
-        if ((query & FinalInCppFunctions) && !f->isFinalInCpp())
-            continue;
-
         if ((query & VirtualInCppFunctions) && f->isFinalInCpp())
             continue;
 
         if ((query & Signals) && (!f->isSignal()))
             continue;
 
-        if ((query & ForcedShellFunctions) &&
-            (!f->isForcedShellImplementation() || !f->isFinal())) {
-            continue;
-        }
-
         if ((query & Constructors) && (!f->isConstructor() || f->ownerClass() != f->implementingClass()))
             continue;
 
@@ -2225,24 +1853,15 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions
             continue;
         }*/
 
-        if ((query & VirtualFunctions) && (f->isFinal() || f->isSignal() || f->isStatic()))
-            continue;
-
         if ((query & StaticFunctions) && (!f->isStatic() || f->isSignal()))
             continue;
 
         if ((query & NonStaticFunctions) && (f->isStatic()))
             continue;
 
-        if ((query & NonEmptyFunctions) && (f->isEmptyFunction()))
-            continue;
-
         if ((query & NormalFunctions) && (f->isSignal()))
             continue;
 
-        if ((query & AbstractFunctions) && !f->isAbstract())
-            continue;
-
         if ((query & OperatorOverloads) && !f->isOperatorOverload())
             continue;
 
@@ -2675,27 +2294,11 @@ QString AbstractMetaType::formatSignature(bool minimal) const
     return result;
 }
 
-bool AbstractMetaType::hasNativeId() const
-{
-    return (isQObject() || isValue() || isObject()) && typeEntry()->isNativeIdBased();
-}
-
 bool AbstractMetaType::isCppPrimitive() const
 {
     return m_pattern == PrimitivePattern && m_typeEntry->isCppPrimitive();
 }
 
-bool AbstractMetaType::isTargetLangEnum() const
-{
-    return isEnum() && !static_cast<const EnumTypeEntry *>(typeEntry())->forceInteger();
-}
-
-bool AbstractMetaType::isTargetLangFlags() const
-{
-    return isFlags() && !static_cast<const FlagsTypeEntry *>(typeEntry())->forceInteger();
-}
-
-
 /*******************************************************************************
  * Other stuff...
  */
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index 615f8df35..ea2f4811e 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -119,7 +119,6 @@ public:
 
         FinalInTargetLang           = 0x00000080,
         FinalInCpp                  = 0x00000100,
-        ForceShellImplementation    = 0x00000200,
 
         GetterFunction              = 0x00000400,
         SetterFunction              = 0x00000800,
@@ -207,11 +206,6 @@ public:
         return m_attributes & Static;
     }
 
-    bool isForcedShellImplementation() const
-    {
-        return m_attributes & ForceShellImplementation;
-    }
-
     bool isInvokable() const
     {
         return m_attributes & Invokable;
@@ -308,8 +302,6 @@ public:
         FlagsPattern,
         EnumPattern,
         ValuePattern,
-        StringPattern,
-        CharPattern,
         ObjectPattern,
         QObjectPattern,
         ValuePointerPattern,
@@ -317,11 +309,8 @@ public:
         NativePointerAsArrayPattern, // "int*" as "int[]"
         ContainerPattern,
         SmartPointerPattern,
-        VariantPattern,
         VarargsPattern,
-        JObjectWrapperPattern,
-        ArrayPattern,
-        ThreadPattern
+        ArrayPattern
     };
     Q_ENUM(TypeUsagePattern)
 
@@ -372,16 +361,9 @@ public:
     {
         m_cppInstantiation = incpp;
     }
-    bool hasInstantiationInCpp() const
-    {
-        return hasInstantiations() && m_cppInstantiation;
-    }
 
     QString minimalSignature() const { return formatSignature(true); }
 
-    // true when the type is a QtJambiObject subclass
-    bool hasNativeId() const;
-
     // returns true if the typs is used as a non complex primitive, no & or *'s
     bool isPrimitive() const
     {
@@ -431,36 +413,12 @@ public:
         return m_pattern == NativePointerPattern;
     }
 
-    // returns true if the type was originally a QString or const QString & or equivalent for QLatin1String
-    bool isTargetLangString() const
-    {
-        return m_pattern == StringPattern;
-    }
-
-    // returns true if the type was originally a QChar or const QChar &
-    bool isTargetLangChar() const
-    {
-        return m_pattern == CharPattern;
-    }
-
-    // return true if the type was originally a QVariant or const QVariant &
-    bool isVariant() const
-    {
-        return m_pattern == VariantPattern;
-    }
-
     // return true if the type was originally a varargs
     bool isVarargs() const
     {
         return m_pattern == VarargsPattern;
     }
 
-    // return true if the type was originally a JObjectWrapper or const JObjectWrapper &
-    bool isJObjectWrapper() const
-    {
-        return m_pattern == JObjectWrapperPattern;
-    }
-
     // returns true if the type was used as a container
     bool isContainer() const
     {
@@ -476,12 +434,6 @@ public:
         return m_pattern == FlagsPattern;
     }
 
-    // returns true if the type was used as a thread
-    bool isThread() const
-    {
-        return m_pattern == ThreadPattern;
-    }
-
     bool isConstant() const
     {
         return m_constant;
@@ -494,30 +446,6 @@ public:
     ReferenceType referenceType() const { return m_referenceType; }
     void setReferenceType(ReferenceType ref) { m_referenceType = ref; }
 
-    /**
-     *   Says if the type is to be implemented using target language
-     *   equivalent of C++ enums, i.e. not plain ints.
-     *   /return true if the type is to be implemented using target
-     *   language enums
-     */
-    bool isTargetLangEnum() const;
-    bool isIntegerEnum() const
-    {
-        return isEnum() && !isTargetLangEnum();
-    }
-
-    /**
-     *   Says if the type is to be implemented using target language
-     *   equivalent of Qt's QFlags, i.e. not plain ints.
-     *   /return true if the type is to be implemented using target
-     *   language QFlags
-     */
-    bool isTargetLangFlags() const;
-    bool isIntegerFlags() const
-    {
-        return isFlags() && !isTargetLangFlags();
-    }
-
     int actualIndirections() const
     {
         return m_indirections + (m_referenceType == LValueReference ? 1 : 0);
@@ -925,7 +853,6 @@ public:
     bool isInplaceOperator() const;
 
     bool isVirtual() const;
-    bool isThread() const;
     bool allowThread() const;
     QString modifiedName() const;
 
@@ -933,19 +860,6 @@ public:
     QString debugSignature() const; // including virtual/override/final, etc., for debugging only.
     QStringList possibleIntrospectionCompatibleSignatures() const;
 
-    QString marshalledName() const;
-
-    // true if one or more of the arguments are of QtJambiObject subclasses
-    bool argumentsHaveNativeId() const
-    {
-        for (const AbstractMetaArgument *arg : m_arguments) {
-            if (arg->type()->hasNativeId())
-                return true;
-        }
-
-        return false;
-    }
-
     bool isModifiedRemoved(int types = TypeSystem::All) const;
 
     AbstractMetaType *type() const
@@ -995,8 +909,6 @@ public:
         m_implementingClass = cls;
     }
 
-    bool needsCallThrough() const;
-
     AbstractMetaArgumentList arguments() const
     {
         return m_arguments;
@@ -1053,15 +965,6 @@ public:
     bool usesRValueReferences() const;
     QStringList introspectionCompatibleSignatures(const QStringList &resolvedArguments = QStringList()) const;
     QString signature() const;
-    QString targetLangSignature(bool minimal = false) const;
-    bool shouldReturnThisObject() const
-    {
-        return QLatin1String("this") == argumentReplaced(0);
-    }
-    bool shouldIgnoreReturnValue() const
-    {
-        return QLatin1String("void") == argumentReplaced(0);
-    }
 
     bool isConstant() const
     {
@@ -1099,14 +1002,6 @@ public:
     QVector<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const;
     ArgumentOwner argumentOwner(const AbstractMetaClass *cls, int idx) const;
 
-    bool nullPointersDisabled(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
-    QString nullPointerDefaultValue(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
-
-    bool resetObjectAfterUse(int argument_idx) const;
-
-    // Returns whether garbage collection is disabled for the argument in any context
-    bool disabledGarbageCollection(const AbstractMetaClass *cls, int key) const;
-
     // Returns the ownership rules for the given argument in the given context
     TypeSystem::Ownership ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int idx) const;
 
@@ -1118,9 +1013,7 @@ public:
     bool argumentRemoved(int) const;
 
     QString argumentReplaced(int key) const;
-    bool needsSuppressUncheckedWarning() const;
 
-    bool hasModifications(const AbstractMetaClass *implementor) const;
     /**
     *   Verifies if any modification to the function is an inject code.
     *   \return true if there is inject code modifications to the function.
@@ -1214,7 +1107,6 @@ public:
 
     void setValue(int value)
     {
-        m_valueSet = true;
         m_value = value;
     }
 
@@ -1238,11 +1130,6 @@ public:
         m_name = name;
     }
 
-    bool isValueSet() const
-    {
-        return m_valueSet;
-    }
-
     void setDocumentation(const Documentation& doc)
     {
         m_doc = doc;
@@ -1257,7 +1144,6 @@ private:
     QString m_name;
     QString m_stringValue;
 
-    bool m_valueSet = false;
     int m_value = 0;
 
     Documentation m_doc;
@@ -1342,29 +1228,19 @@ public:
     enum FunctionQueryOption {
         Constructors                 = 0x0000001, // Only constructors
         //Destructors                  = 0x0000002, // Only destructors. Not included in class.
-        VirtualFunctions             = 0x0000004, // Only virtual functions (virtual in both TargetLang and C++)
         FinalInTargetLangFunctions   = 0x0000008, // Only functions that are non-virtual in TargetLang
-        FinalInCppFunctions          = 0x0000010, // Only functions that are non-virtual in C++
         ClassImplements              = 0x0000020, // Only functions implemented by the current class
-        Inconsistent                 = 0x0000040, // Only inconsistent functions (inconsistent virtualness in TargetLang/C++)
         StaticFunctions              = 0x0000080, // Only static functions
         Signals                      = 0x0000100, // Only signals
         NormalFunctions              = 0x0000200, // Only functions that aren't signals
         Visible                      = 0x0000400, // Only public and protected functions
-        ForcedShellFunctions         = 0x0000800, // Only functions that are overridden to be implemented in the shell class
         WasPublic                    = 0x0001000, // Only functions that were originally public
-        WasProtected                 = 0x0002000, // Only functions that were originally protected
         NonStaticFunctions           = 0x0004000, // No static functions
         Empty                        = 0x0008000, // Empty overrides of abstract functions
         Invisible                    = 0x0010000, // Only private functions
         VirtualInCppFunctions        = 0x0020000, // Only functions that are virtual in C++
-        NonEmptyFunctions            = 0x0040000, // Only functions with target language API implementations
         VirtualInTargetLangFunctions = 0x0080000, // Only functions which are virtual in TargetLang
-        AbstractFunctions            = 0x0100000, // Only abstract functions
-        WasVisible                   = 0x0200000, // Only functions that were public or protected in the original code
         NotRemovedFromTargetLang     = 0x0400000, // Only functions that have not been removed from TargetLang
-        NotRemovedFromShell          = 0x0800000, // Only functions that have not been removed from the shell class
-        VirtualSlots                 = 0x1000000, // Only functions that are set as virtual slots in the type system
         OperatorOverloads            = 0x2000000  // Only functions that are operator overloads
     };
     Q_DECLARE_FLAGS(FunctionQueryOptions, FunctionQueryOption)
@@ -1386,12 +1262,6 @@ public:
     Q_DECLARE_FLAGS(OperatorQueryOptions, OperatorQueryOption)
     Q_FLAG(OperatorQueryOption)
 
-    struct BaseClass
-    {
-        QString name;
-        int access = Public;
-    };
-
     AbstractMetaClass();
     ~AbstractMetaClass();
 
@@ -1475,11 +1345,7 @@ public:
     AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
     AbstractMetaFunctionList queryFunctions(FunctionQueryOptions query) const;
     AbstractMetaFunctionList functionsInTargetLang() const;
-    AbstractMetaFunctionList functionsInShellClass() const;
     inline AbstractMetaFunctionList cppSignalFunctions() const;
-    AbstractMetaFunctionList publicOverrideFunctions() const;
-    AbstractMetaFunctionList virtualOverrideFunctions() const;
-    AbstractMetaFunctionList virtualFunctions() const;
     AbstractMetaFunctionList implicitConversions() const;
 
     /**
@@ -1492,14 +1358,10 @@ public:
      */
     AbstractMetaFunctionList operatorOverloads(OperatorQueryOptions query = AllOperators) const;
 
-    bool hasOperatorOverload() const;
     bool hasArithmeticOperatorOverload() const;
     bool hasBitwiseOperatorOverload() const;
     bool hasComparisonOperatorOverload() const;
     bool hasLogicalOperatorOverload() const;
-    bool hasSubscriptOperatorOverload() const;
-    bool hasAssignmentOperatorOverload() const;
-    bool hasConversionOperatorOverload() const;
 
     AbstractMetaFieldList fields() const
     {
@@ -1612,8 +1474,6 @@ public:
         m_forceShellClass = on;
     }
 
-    bool generateShellClass() const;
-
     bool hasVirtualSlots() const
     {
         return m_hasVirtualSlots;
diff --git a/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp
index f67d8c9b2..9acbba675 100644
--- a/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -86,6 +86,17 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     // QVERIFY(classes[0]->hasNonPrivateConstructor());
 }
 
+static AbstractMetaFunctionList virtualFunctions(const AbstractMetaClass *c)
+{
+    AbstractMetaFunctionList result;
+    const AbstractMetaFunctionList &functions = c->functions();
+    for (AbstractMetaFunction *f : functions) {
+        if (f->isVirtual())
+            result.append(f);
+    }
+    return result;
+}
+
 void TestAbstractMetaClass::testVirtualMethods()
 {
     const char cppCode[] =R"CPP(
@@ -150,15 +161,19 @@ public:
     QCOMPARE(ctorA->ownerClass(), a);
     QCOMPARE(ctorA->declaringClass(), a);
 
-    QCOMPARE(a->virtualFunctions().size(), 1); // Add a pureVirtualMethods method !?
-    QCOMPARE(b->virtualFunctions().size(), 1);
-    QCOMPARE(c->virtualFunctions().size(), 1);
-    QCOMPARE(f->virtualFunctions().size(), 1);
-
-    AbstractMetaFunction* funcA = a->virtualFunctions().first();
-    AbstractMetaFunction* funcB = b->virtualFunctions().first();
-    AbstractMetaFunction* funcC = c->virtualFunctions().first();
-    const AbstractMetaFunction* funcF = f->virtualFunctions().constFirst();
+    const AbstractMetaFunctionList virtualFunctionsA = virtualFunctions(a);
+    const AbstractMetaFunctionList virtualFunctionsB = virtualFunctions(b);
+    const AbstractMetaFunctionList virtualFunctionsC = virtualFunctions(c);
+    const AbstractMetaFunctionList 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();
 
     QCOMPARE(funcA->ownerClass(), a);
     QVERIFY(funcC->attributes() & AbstractMetaAttributes::VirtualCppMethod);