shiboken6: Introduce class ApiExtractorResult

Separate the generators from ApiExtractor by introducing
a class ApiExtractorResult storing the results of an  ApiExtractor run.
Move some query functions there.

With that, some generator functions can already be made static by
passing the ApiExtractorResult and OverloadData can be decoupled from
the generator.

Change-Id: Iaba3ebff4aecb722eec4a606423738260983d905
Reviewed-by: Christian Tismer <tismer@stackless.com>
(cherry picked from commit b9286bd08a4e7bf8f603e274c80cbd86cb9c1a4a)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

19 files changed, 353 insertions, 243 deletions

diff --git a/sources/shiboken6/ApiExtractor/CMakeLists.txt b/sources/shiboken6/ApiExtractor/CMakeLists.txt
index c4bb5f09c..94571aee0 100644
--- a/sources/shiboken6/ApiExtractor/CMakeLists.txt
+++ b/sources/shiboken6/ApiExtractor/CMakeLists.txt
@@ -7,6 +7,7 @@ set(CMAKE_AUTOMOC ON)
 
 set(apiextractor_SRC
 apiextractor.cpp
+apiextractorresult.cpp
 abstractmetaattributes.cpp
 abstractmetaargument.cpp
 abstractmetabuilder.cpp
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 787094f76..0c679140a 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -112,15 +112,9 @@ const AbstractMetaEnumList &AbstractMetaBuilder::globalEnums() const
     return d->m_globalEnums;
 }
 
-std::optional<AbstractMetaEnum>
-    AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const
+const QHash<const TypeEntry *, AbstractMetaEnum> &AbstractMetaBuilder::typeEntryToEnumsHash() const
 {
-    if (typeEntry && typeEntry->isFlags())
-        typeEntry = static_cast<const FlagsTypeEntry *>(typeEntry)->originator();
-    const auto it = d->m_enums.constFind(typeEntry);
-    if (it == d->m_enums.constEnd())
-        return {};
-    return it.value();
+    return d->m_enums;
 }
 
 void AbstractMetaBuilderPrivate::checkFunctionModifications()
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
index e9635233d..ee2c12869 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h
@@ -70,7 +70,7 @@ public:
     const AbstractMetaClassList &smartPointers() const;
     const AbstractMetaFunctionCList &globalFunctions() const;
     const AbstractMetaEnumList &globalEnums() const;
-    std::optional<AbstractMetaEnum> findEnum(const TypeEntry *typeEntry) const;
+    const QHash<const TypeEntry *, AbstractMetaEnum> &typeEntryToEnumsHash() const;
 
     bool build(const QByteArrayList &arguments,
                LanguageLevel level = LanguageLevel::Default,
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp
index f429b7dee..8e4501c74 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.cpp
+++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp
@@ -27,6 +27,7 @@
 ****************************************************************************/
 
 #include "apiextractor.h"
+#include "apiextractorresult.h"
 #include "abstractmetalang.h"
 
 #include <QDir>
@@ -146,18 +147,6 @@ const AbstractMetaClassList &ApiExtractor::smartPointers() const
     return m_builder->smartPointers();
 }
 
-std::optional<AbstractMetaEnum>
-    ApiExtractor::findAbstractMetaEnum(const TypeEntry* typeEntry) const
-{
-    return m_builder->findEnum(typeEntry);
-}
-
-int ApiExtractor::classCount() const
-{
-    Q_ASSERT(m_builder);
-    return m_builder->classes().count();
-}
-
 // Add defines required for parsing Qt code headers
 static void addPySideExtensions(QByteArrayList *a)
 {
@@ -176,7 +165,7 @@ static void addPySideExtensions(QByteArrayList *a)
     a->append(QByteArrayLiteral("-DQSIMD_H"));
 }
 
-bool ApiExtractor::run(bool usePySideExtensions)
+bool ApiExtractor::runHelper(bool usePySideExtensions)
 {
     if (m_builder)
         return false;
@@ -233,6 +222,19 @@ bool ApiExtractor::run(bool usePySideExtensions)
     return result;
 }
 
+std::optional<ApiExtractorResult> ApiExtractor::run(bool usePySideExtensions)
+{
+    if (!runHelper(usePySideExtensions))
+        return {};
+    ApiExtractorResult result;
+    result.m_metaClasses = m_builder->classes();
+    result.m_smartPointers = m_builder->smartPointers();
+    result.m_globalFunctions = m_builder->globalFunctions();
+    result.m_globalEnums = m_builder->globalEnums();
+    result.m_enums = m_builder->typeEntryToEnumsHash();
+    return result;
+}
+
 LanguageLevel ApiExtractor::languageLevel() const
 {
     return m_languageLevel;
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h
index 0d05f51ac..ddc7fbc00 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.h
+++ b/sources/shiboken6/ApiExtractor/apiextractor.h
@@ -39,6 +39,7 @@
 
 #include <optional>
 
+class ApiExtractorResult;
 class AbstractMetaBuilder;
 class AbstractMetaClass;
 class AbstractMetaEnum;
@@ -86,12 +87,11 @@ public:
     const AbstractMetaClassList &classes() const;
     const AbstractMetaClassList &smartPointers() const;
 
-    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const TypeEntry* typeEntry) const;
+    std::optional<ApiExtractorResult> run(bool usePySideExtensions);
 
-    int classCount() const;
-
-    bool run(bool usePySideExtensions);
 private:
+    bool runHelper(bool usePySideExtensions);
+
     QString m_typeSystemFileName;
     QFileInfoList m_cppFileNames;
     HeaderPaths m_includePaths;
diff --git a/sources/shiboken6/ApiExtractor/apiextractorresult.cpp b/sources/shiboken6/ApiExtractor/apiextractorresult.cpp
new file mode 100644
index 000000000..04566ada2
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/apiextractorresult.cpp
@@ -0,0 +1,57 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt for Python.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "apiextractorresult.h"
+#include "abstractmetalang.h"
+#include "abstractmetaenum.h"
+
+#include "typesystem.h"
+
+std::optional<AbstractMetaEnum> ApiExtractorResult::findAbstractMetaEnum(const TypeEntry *typeEntry) const
+{
+    if (typeEntry && typeEntry->isFlags())
+        typeEntry = static_cast<const FlagsTypeEntry *>(typeEntry)->originator();
+    const auto it = m_enums.constFind(typeEntry);
+    if (it == m_enums.constEnd())
+        return {};
+    return it.value();
+}
+
+AbstractMetaFunctionCList ApiExtractorResult::implicitConversions(const TypeEntry *type) const
+{
+    if (type->isValue()) {
+        if (auto metaClass = AbstractMetaClass::findClass(m_metaClasses, type))
+            return metaClass->implicitConversions();
+    }
+    return {};
+}
+
+AbstractMetaFunctionCList ApiExtractorResult::implicitConversions(const AbstractMetaType &metaType) const
+{
+    return implicitConversions(metaType.typeEntry());
+}
diff --git a/sources/shiboken6/ApiExtractor/apiextractorresult.h b/sources/shiboken6/ApiExtractor/apiextractorresult.h
new file mode 100644
index 000000000..5d30073e9
--- /dev/null
+++ b/sources/shiboken6/ApiExtractor/apiextractorresult.h
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt for Python.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef APIEXTRACTORRESULT_H
+#define APIEXTRACTORRESULT_H
+
+#include "abstractmetalang.h"
+#include "abstractmetaenum.h"
+#include "abstractmetatype.h"
+#include "typesystem_typedefs.h"
+
+#include <QtCore/QHash>
+
+#include <optional>
+
+/// Result of an ApiExtractor run.
+/// Note: The class lists in here are flat, non-owning lists, currently
+/// (pending introduction of QSharedPointer for AbstractMetaClass); the
+/// ApiExtractor/AbstractMetaBuilder must be kept alive during the
+/// generator run since it owns the classes.
+class ApiExtractorResult
+{
+    friend class ApiExtractor;
+public:
+    const AbstractMetaEnumList &globalEnums() const { return m_globalEnums; }
+    const AbstractMetaFunctionCList &globalFunctions() const { return m_globalFunctions; }
+    const AbstractMetaClassList &classes() const { return m_metaClasses; }
+    const AbstractMetaClassList &smartPointers() const { return m_smartPointers; }
+
+    // Query functions for the generators
+    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const TypeEntry* typeEntry) const;
+
+    /// Retrieves a list of constructors used in implicit conversions
+    /// available on the given type. The TypeEntry must be a value-type
+    /// or else it will return an empty list.
+    ///  \param type a TypeEntry that is expected to be a value-type
+    /// \return a list of constructors that could be used as implicit converters
+    AbstractMetaFunctionCList implicitConversions(const TypeEntry *type) const;
+    AbstractMetaFunctionCList implicitConversions(const AbstractMetaType &metaType) const;
+
+private:
+    AbstractMetaClassList m_metaClasses;
+    AbstractMetaClassList m_smartPointers;
+    AbstractMetaFunctionCList m_globalFunctions;
+    AbstractMetaEnumList m_globalEnums;
+
+    QHash<const TypeEntry *, AbstractMetaEnum> m_enums;
+};
+
+#endif // APIEXTRACTORRESULT_H
diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp
index 1958d00a5..deb27de80 100644
--- a/sources/shiboken6/generator/generator.cpp
+++ b/sources/shiboken6/generator/generator.cpp
@@ -27,6 +27,7 @@
 ****************************************************************************/
 
 #include "generator.h"
+#include "apiextractorresult.h"
 #include "ctypenames.h"
 #include "abstractmetaenum.h"
 #include "abstractmetafield.h"
@@ -168,7 +169,7 @@ QString GeneratorContext::smartPointerWrapperName() const
 
 struct Generator::GeneratorPrivate
 {
-    const ApiExtractor *apiextractor = nullptr;
+    ApiExtractorResult api;
     QString outDir;
     // License comment
     QString licenseComment;
@@ -188,9 +189,9 @@ Generator::~Generator()
     delete m_d;
 }
 
-bool Generator::setup(const ApiExtractor &extractor)
+bool Generator::setup(const ApiExtractorResult &api)
 {
-    m_d->apiextractor = &extractor;
+    m_d->api = api;
     const auto moduleEntry = TypeDatabase::instance()->defaultTypeSystemType();
     if (!moduleEntry || !moduleEntry->generateCode()) {
         qCWarning(lcShiboken) << "Couldn't find the package name!!";
@@ -199,7 +200,7 @@ bool Generator::setup(const ApiExtractor &extractor)
 
     collectInstantiatedContainersAndSmartPointers();
 
-    for (auto c : classes()) {
+    for (auto c : api.classes()) {
         if (c->enclosingClass() == nullptr && c->isInvisibleNamespace()) {
             m_d->m_invisibleTopNamespaces.append(c);
             c->invisibleNamespaceRecursion([&](AbstractMetaClass *ic) {
@@ -326,9 +327,9 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
 
 void Generator::collectInstantiatedContainersAndSmartPointers()
 {
-    for (const auto &func : globalFunctions())
+    for (const auto &func : m_d->api.globalFunctions())
         collectInstantiatedContainersAndSmartPointers(func);
-    for (const AbstractMetaClass *metaClass : classes())
+    for (auto metaClass : m_d->api.classes())
         collectInstantiatedContainersAndSmartPointers(metaClass);
 }
 
@@ -352,26 +353,11 @@ bool Generator::handleOption(const QString & /* key */, const QString & /* value
     return false;
 }
 
-const AbstractMetaClassList &Generator::classes() const
-{
-    return m_d->apiextractor->classes();
-}
-
 const AbstractMetaClassList &Generator::invisibleTopNamespaces() const
 {
     return m_d->m_invisibleTopNamespaces;
 }
 
-const AbstractMetaFunctionCList &Generator::globalFunctions() const
-{
-    return m_d->apiextractor->globalFunctions();
-}
-
-const AbstractMetaEnumList &Generator::globalEnums() const
-{
-    return m_d->apiextractor->globalEnums();
-}
-
 PrimitiveTypeEntryList Generator::primitiveTypes()
 {
     return TypeDatabase::instance()->primitiveTypes();
@@ -382,18 +368,6 @@ ContainerTypeEntryList Generator::containerTypes()
     return TypeDatabase::instance()->containerTypes();
 }
 
-std::optional<AbstractMetaEnum>
-    Generator::findAbstractMetaEnum(const TypeEntry *typeEntry) const
-{
-    return m_d->apiextractor->findAbstractMetaEnum(typeEntry);
-}
-
-std::optional<AbstractMetaEnum>
-    Generator::findAbstractMetaEnum(const AbstractMetaType &metaType) const
-{
-    return m_d->apiextractor->findAbstractMetaEnum(metaType.typeEntry());
-}
-
 QString Generator::licenseComment() const
 {
     return m_d->licenseComment;
@@ -479,13 +453,12 @@ GeneratorContext Generator::contextForSmartPointer(const AbstractMetaClass *c,
 
 bool Generator::generate()
 {
-    const AbstractMetaClassList &classList = m_d->apiextractor->classes();
-    for (AbstractMetaClass *cls : classList) {
+    for (auto cls : m_d->api.classes()) {
         if (!generateFileForContext(contextForClass(cls)))
             return false;
     }
 
-    const auto smartPointers = m_d->apiextractor->smartPointers();
+    const auto smartPointers = m_d->api.smartPointers();
     for (const AbstractMetaType &type : qAsConst(m_d->instantiatedSmartPointers)) {
         AbstractMetaClass *smartPointerClass =
             AbstractMetaClass::findClass(smartPointers, type.typeEntry());
@@ -522,18 +495,9 @@ void verifyDirectoryFor(const QString &file)
     }
 }
 
-AbstractMetaFunctionCList Generator::implicitConversions(const TypeEntry *type) const
-{
-    if (type->isValue()) {
-        if (const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), type))
-            return metaClass->implicitConversions();
-    }
-    return {};
-}
-
-AbstractMetaFunctionCList Generator::implicitConversions(const AbstractMetaType &metaType) const
+const ApiExtractorResult &Generator::api() const
 {
-    return implicitConversions(metaType.typeEntry());
+    return m_d->api;
 }
 
 QString Generator::getFullTypeName(const TypeEntry *type)
@@ -594,8 +558,9 @@ QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType &type)
 }
 
 std::optional<DefaultValue>
-    Generator::minimalConstructor(const AbstractMetaType &type,
-                                  QString *errorString) const
+    Generator::minimalConstructor(const ApiExtractorResult &api,
+                                  const AbstractMetaType &type,
+                                  QString *errorString)
 {
     if (type.referenceType() == LValueReference && type.isObjectType())
         return {};
@@ -621,19 +586,19 @@ std::optional<DefaultValue>
         return DefaultValue(DefaultValue::Pointer, QLatin1String("::") + type.typeEntry()->qualifiedCppName());
 
     if (type.typeEntry()->isSmartPointer())
-        return minimalConstructor(type.typeEntry());
+        return minimalConstructor(api, type.typeEntry());
 
     if (type.typeEntry()->isComplex()) {
         auto cType = static_cast<const ComplexTypeEntry *>(type.typeEntry());
         if (cType->hasDefaultConstructor())
             return DefaultValue(DefaultValue::Custom, cType->defaultConstructor());
-        auto klass = AbstractMetaClass::findClass(classes(), cType);
+        auto klass = AbstractMetaClass::findClass(api.classes(), cType);
         if (!klass) {
             if (errorString != nullptr)
                 *errorString = msgClassNotFound(cType);
             return {};
         }
-        auto ctorO = minimalConstructor(klass);
+        auto ctorO = minimalConstructor(api, klass);
         if (ctorO.has_value() && type.hasInstantiations()) {
             auto ctor = ctorO.value();
             QString v = ctor.value();
@@ -644,12 +609,13 @@ std::optional<DefaultValue>
         return ctorO;
     }
 
-    return minimalConstructor(type.typeEntry(), errorString);
+    return minimalConstructor(api, type.typeEntry(), errorString);
 }
 
 std::optional<DefaultValue>
-   Generator::minimalConstructor(const TypeEntry *type,
-                                 QString *errorString) const
+   Generator::minimalConstructor(const ApiExtractorResult &api,
+                                 const TypeEntry *type,
+                                 QString *errorString)
 {
     if (!type)
         return {};
@@ -691,13 +657,13 @@ std::optional<DefaultValue>
         return DefaultValue(DefaultValue::DefaultConstructor, type->qualifiedCppName());
 
     if (type->isComplex()) {
-        auto klass = AbstractMetaClass::findClass(classes(), type);
+        auto klass = AbstractMetaClass::findClass(api.classes(), type);
         if (!klass) {
             if (errorString != nullptr)
                 *errorString = msgClassNotFound(type);
             return {};
         }
-        return minimalConstructor(klass, errorString);
+        return minimalConstructor(api, klass, errorString);
     }
 
     if (errorString != nullptr)
@@ -712,8 +678,9 @@ static QString constructorCall(const QString &qualifiedCppName, const QStringLis
 }
 
 std::optional<DefaultValue>
-    Generator::minimalConstructor(const AbstractMetaClass *metaClass,
-                                  QString *errorString) const
+    Generator::minimalConstructor(const ApiExtractorResult &api,
+                                  const AbstractMetaClass *metaClass,
+                                  QString *errorString)
 {
     if (!metaClass)
         return {};
@@ -766,7 +733,7 @@ std::optional<DefaultValue>
             }
             if (arg.hasOriginalDefaultValueExpression())
                 break;
-            auto argValue = minimalConstructor(arg.type(), errorString);
+            auto argValue = minimalConstructor(api, arg.type(), errorString);
             if (!argValue.has_value())
                 return {};
             args << argValue->constructorParameter();
@@ -784,7 +751,7 @@ bool Generator::useEnumAsIntForProtectedHack(const AbstractMetaType &metaType) c
         return true;
     if (!metaType.isEnum())
         return false;
-    auto metaEnum = findAbstractMetaEnum(metaType);
+    auto metaEnum = m_d->api.findAbstractMetaEnum(metaType.typeEntry());
     if (!metaEnum.has_value())
         return true;
     if (metaEnum->attributes() & AbstractMetaAttributes::Public) // No reason, type is public
diff --git a/sources/shiboken6/generator/generator.h b/sources/shiboken6/generator/generator.h
index d61fa0117..5773d4097 100644
--- a/sources/shiboken6/generator/generator.h
+++ b/sources/shiboken6/generator/generator.h
@@ -38,8 +38,7 @@
 
 #include <optional>
 
-class ApiExtractor;
-class AbstractMetaBuilder;
+class ApiExtractorResult;
 class AbstractMetaFunction;
 class AbstractMetaClass;
 class AbstractMetaEnum;
@@ -212,14 +211,11 @@ public:
     Generator();
     virtual ~Generator();
 
-    bool setup(const ApiExtractor &extractor);
+    bool setup(const ApiExtractorResult &api);
 
     virtual OptionDescriptions options() const;
     virtual bool handleOption(const QString &key, const QString &value);
 
-    /// Returns the classes used to generate the binding code.
-    const AbstractMetaClassList &classes() const;
-
     /// Returns the top namespace made invisible
     const AbstractMetaClassList &invisibleTopNamespaces() const;
 
@@ -246,6 +242,9 @@ public:
     /// Returns the generator's name. Used for cosmetic purposes.
     virtual const char *name() const = 0;
 
+    /// Returns the API as determined by ApiExtractor
+    const ApiExtractorResult &api() const;
+
     /**
      *  Retrieves the name of the currently processed module.
      *  While package name is a complete package idetification, e.g. 'PySide.QtCore',
@@ -256,37 +255,13 @@ public:
      */
     QString moduleName() const;
 
-    /**
-     *   Retrieves a list of constructors used in implicit conversions
-     *   available on the given type. The TypeEntry must be a value-type
-     *   or else it will return an empty list.
-     *   \param type a TypeEntry that is expected to be a value-type
-     *   \return a list of constructors that could be used as implicit converters
-     */
-    AbstractMetaFunctionCList implicitConversions(const TypeEntry *type) const;
-
-    /// Convenience function for implicitConversions(const TypeEntry *type).
-    AbstractMetaFunctionCList implicitConversions(const AbstractMetaType &metaType) const;
-
 protected:
-    /// Returns all global functions found by APIExtractor
-    const AbstractMetaFunctionCList &globalFunctions() const;
-
-    /// Returns all global enums found by APIExtractor
-    const AbstractMetaEnumList &globalEnums() const;
-
     /// Returns all primitive types found by APIExtractor
     static PrimitiveTypeEntryList primitiveTypes();
 
     /// Returns all container types found by APIExtractor
     static ContainerTypeEntryList containerTypes();
 
-    /// Returns an AbstractMetaEnum for a given TypeEntry that is an EnumTypeEntry, or nullptr if not found.
-    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const TypeEntry *typeEntry) const;
-
-    /// Returns an AbstractMetaEnum for a given AbstractMetaType that holds an EnumTypeEntry, or nullptr if not found.
-    std::optional<AbstractMetaEnum> findAbstractMetaEnum(const AbstractMetaType &metaType) const;
-
     virtual GeneratorContext contextForClass(const AbstractMetaClass *c) const;
     GeneratorContext contextForSmartPointer(const AbstractMetaClass *c,
                                             const AbstractMetaType &t) const;
@@ -340,12 +315,16 @@ protected:
      *   It will check first for a user defined default constructor.
      *   Returns a null string if it fails.
      */
-    std::optional<DefaultValue> minimalConstructor(const TypeEntry *type,
-                                                   QString *errorString = nullptr) const;
-    std::optional<DefaultValue> minimalConstructor(const AbstractMetaType &type,
-                                                   QString *errorString = nullptr) const;
-    std::optional<DefaultValue> minimalConstructor(const AbstractMetaClass *metaClass,
-                                                   QString *errorString = nullptr) const;
+    static std::optional<DefaultValue>
+        minimalConstructor(const ApiExtractorResult &api, const TypeEntry *type,
+                           QString *errorString = nullptr);
+    static std::optional<DefaultValue>
+        minimalConstructor(const ApiExtractorResult &api, const AbstractMetaType &type,
+                           QString *errorString = nullptr);
+    static std::optional<DefaultValue>
+        minimalConstructor(const ApiExtractorResult &api,
+                           const AbstractMetaClass *metaClass,
+                           QString *errorString = nullptr);
 
     /**
      *   Returns the file name used to write the binding code of an AbstractMetaClass/Type.
diff --git a/sources/shiboken6/generator/main.cpp b/sources/shiboken6/generator/main.cpp
index 3c5c5876c..ec0cf5de9 100644
--- a/sources/shiboken6/generator/main.cpp
+++ b/sources/shiboken6/generator/main.cpp
@@ -32,6 +32,7 @@
 #include <QtCore/QDir>
 #include <iostream>
 #include <apiextractor.h>
+#include <apiextractorresult.h>
 #include <fileout.h>
 #include <reporthandler.h>
 #include <typedatabase.h>
@@ -615,12 +616,14 @@ int main(int argc, char *argv[])
     auto shibokenGenerator = dynamic_cast<const ShibokenGenerator *>(generators.constFirst().data());
     const bool usePySideExtensions = shibokenGenerator && shibokenGenerator->usePySideExtensions();
 
-    if (!extractor.run(usePySideExtensions)) {
+    const std::optional<ApiExtractorResult> apiOpt = extractor.run(usePySideExtensions);
+
+    if (!apiOpt.has_value()) {
         errorPrint(QLatin1String("Error running ApiExtractor."));
         return EXIT_FAILURE;
     }
 
-    if (!extractor.classCount())
+    if (apiOpt->classes().isEmpty())
         qCWarning(lcShiboken) << "No C++ classes found!";
 
     if (ReportHandler::isDebug(ReportHandler::FullDebug)
@@ -633,7 +636,7 @@ int main(int argc, char *argv[])
         g->setOutputDirectory(outputDirectory);
         g->setLicenseComment(licenseComment);
         ReportHandler::startProgress(QByteArray("Running ") + g->name() + "...");
-        const bool ok = g->setup(extractor) && g->generate();
+        const bool ok = g->setup(apiOpt.value()) && g->generate();
         ReportHandler::endProgress();
          if (!ok) {
              errorPrint(QLatin1String("Error running generator: ")
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index 07ec29f03..ad0e9e78d 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -27,6 +27,7 @@
 ****************************************************************************/
 
 #include "qtdocgenerator.h"
+#include "apiextractorresult.h"
 #include "qtxmltosphinx.h"
 #include "rstformat.h"
 #include "ctypenames.h"
@@ -283,7 +284,7 @@ void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classC
     // TODO: This would be a parameter in the future...
 
 
-    writeInheritedByList(s, metaClass, classes());
+    writeInheritedByList(s, metaClass, api().classes());
 
     const auto version = versionOf(metaClass->typeEntry());
     if (!version.isNull())
@@ -698,7 +699,7 @@ QString QtDocGenerator::translateToPythonType(const AbstractMetaType &type,
                                          .arg(types[0], types[1]);
         }
     } else {
-        const AbstractMetaClass *k = AbstractMetaClass::findClass(classes(), type.typeEntry());
+        auto k = AbstractMetaClass::findClass(api().classes(), type.typeEntry());
         strType = k ? k->fullName() : type.name();
         strType = QStringLiteral(":any:`") + strType + QLatin1Char('`');
     }
@@ -834,7 +835,7 @@ static void writeFancyToc(TextStream& s, const QStringList& items, int cols = 2)
 
 bool QtDocGenerator::finishGeneration()
 {
-    if (!classes().isEmpty())
+    if (!api().classes().isEmpty())
         writeModuleDocumentation();
     if (!m_additionalDocumentationList.isEmpty())
         writeAdditionalDocumentation();
@@ -1098,7 +1099,7 @@ QString QtDocGenerator::expandFunction(const QString &function) const
     const AbstractMetaClass *metaClass = nullptr;
     if (firstDot != -1) {
         const auto className = QStringView{function}.left(firstDot);
-        for (const AbstractMetaClass *cls : classes()) {
+        for (auto cls : api().classes()) {
             if (cls->name() == className) {
                 metaClass = cls;
                 break;
@@ -1135,7 +1136,7 @@ QString QtDocGenerator::resolveContextForMethod(const QString &context,
     const auto currentClass = QStringView{context}.split(QLatin1Char('.')).constLast();
 
     const AbstractMetaClass *metaClass = nullptr;
-    for (const AbstractMetaClass *cls : classes()) {
+    for (auto cls : api().classes()) {
         if (cls->name() == currentClass) {
             metaClass = cls;
             break;
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 766ef25d9..cb4f9c890 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -29,6 +29,7 @@
 #include <memory>
 
 #include "cppgenerator.h"
+#include "apiextractorresult.h"
 #include "ctypenames.h"
 #include "pytypenames.h"
 #include "fileout.h"
@@ -845,7 +846,7 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
         return QLatin1Char('"') + typeEntry->qualifiedCppName() + QLatin1Char('"');
 
     if (avoidProtectedHack()) {
-        auto metaEnum = findAbstractMetaEnum(func->type());
+        auto metaEnum = api().findAbstractMetaEnum(func->type().typeEntry());
         if (metaEnum.has_value() && metaEnum->isProtected()) {
             return QLatin1Char('"') + protectedEnumSurrogateName(metaEnum.value())
                     + QLatin1Char('"');
@@ -897,9 +898,9 @@ void CppGenerator::writeVirtualMethodCppCall(TextStream &s,
 }
 
 // Determine the return statement (void or a result value).
-QString CppGenerator::virtualMethodReturn(TextStream &s,
+QString CppGenerator::virtualMethodReturn(TextStream &s, const ApiExtractorResult &api,
                                           const AbstractMetaFunctionCPtr &func,
-                                          const FunctionModificationList &functionModifications) const
+                                          const FunctionModificationList &functionModifications)
 {
     if (func->isVoid())
         return QLatin1String("return;");
@@ -929,7 +930,7 @@ QString CppGenerator::virtualMethodReturn(TextStream &s,
         }
     }
     QString errorMessage;
-    const auto defaultReturnExpr = minimalConstructor(returnType, &errorMessage);
+    const auto defaultReturnExpr = minimalConstructor(api, returnType, &errorMessage);
     if (!defaultReturnExpr.has_value()) {
         QString errorMsg = QLatin1String(__FUNCTION__) + QLatin1String(": ");
         if (const AbstractMetaClass *c = func->implementingClass())
@@ -969,7 +970,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
 
     const FunctionModificationList &functionModifications = func->modifications();
 
-    const QString returnStatement = virtualMethodReturn(s, func, functionModifications);
+    const QString returnStatement = virtualMethodReturn(s, api(), func, functionModifications);
 
     if (func->isAbstract() && func->isModifiedRemoved()) {
         qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func.data())));
@@ -1215,7 +1216,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
     if (!func->isVoid()) {
         s << "return ";
         if (avoidProtectedHack() && retType->isEnum()) {
-            auto metaEnum = findAbstractMetaEnum(retType);
+            auto metaEnum = api().findAbstractMetaEnum(retType);
             bool isProtectedEnum = metaEnum.has_value() && metaEnum->isProtected();
             if (isProtectedEnum) {
                 QString typeCast;
@@ -1302,7 +1303,7 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const TypeEntry *e
     QString enumPythonType = cpythonTypeNameExt(enumType);
     QString cppTypeName = getFullTypeName(enumType).trimmed();
     if (avoidProtectedHack()) {
-        auto metaEnum = findAbstractMetaEnum(enumType);
+        auto metaEnum = api().findAbstractMetaEnum(enumType);
         if (metaEnum.has_value() && metaEnum->isProtected())
             cppTypeName = protectedEnumSurrogateName(metaEnum.value());
     }
@@ -1502,7 +1503,7 @@ return result;)";
     // Implicit conversions.
     AbstractMetaFunctionCList implicitConvs;
     if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
-        const auto &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+        const auto &allImplicitConvs = api().implicitConversions(metaClass->typeEntry());
         for (const auto &func : allImplicitConvs) {
             if (!func->isUserAdded())
                 implicitConvs << func;
@@ -1559,7 +1560,7 @@ return result;)";
                 || sourceType.typeEntry()->isFlags()) {
                 StringStream pc(TextStream::Language::Cpp);
                 pc << getFullTypeNameWithoutModifiers(sourceType) << " cppIn";
-                writeMinimalConstructorExpression(pc, sourceType);
+                writeMinimalConstructorExpression(pc, api(), sourceType);
                 pc << ";\n";
                 writeToCppConversion(pc, sourceType, nullptr, QLatin1String("pyIn"), QLatin1String("cppIn"));
                 pc << ';';
@@ -1689,7 +1690,7 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
     // Add implicit conversions.
     AbstractMetaFunctionCList implicitConvs;
     if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
-        const auto &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+        const auto &allImplicitConvs = api().implicitConversions(metaClass->typeEntry());
         for (const auto &func : allImplicitConvs) {
             if (!func->isUserAdded())
                 implicitConvs << func;
@@ -1746,7 +1747,8 @@ void CppGenerator::writeContainerConverterFunctions(TextStream &s,
 void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s,
                                                        const AbstractMetaType &smartPointerType) const
 {
-    const AbstractMetaClass *targetClass = AbstractMetaClass::findClass(classes(), smartPointerType.instantiations().at(0).typeEntry());
+    auto targetClass = AbstractMetaClass::findClass(api().classes(),
+                                                    smartPointerType.instantiations().at(0).typeEntry());
 
     if (targetClass) {
         const auto *smartPointerTypeEntry =
@@ -1847,7 +1849,7 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunc
                                            const GeneratorContext &classContext) const
 {
     ErrorCode errorCode(-1);
-    OverloadData overloadData(overloads, this);
+    OverloadData overloadData(overloads, api());
 
     const auto rfunc = overloadData.referenceFunction();
     const AbstractMetaClass *metaClass = rfunc->ownerClass();
@@ -1980,7 +1982,7 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const AbstractMetaFunc
 void CppGenerator::writeMethodWrapper(TextStream &s, const AbstractMetaFunctionCList &overloads,
                                       const GeneratorContext &classContext) const
 {
-    OverloadData overloadData(overloads, this);
+    OverloadData overloadData(overloads, api());
     const auto rfunc = overloadData.referenceFunction();
 
     int maxArgs = overloadData.maxArgs();
@@ -2418,7 +2420,8 @@ void CppGenerator::writeTypeCheck(TextStream &s, const OverloadData *overloadDat
         argType = *viewOn;
     bool numberType = numericTypes.count() == 1 || ShibokenGenerator::isPyInt(argType);
     QString customType = (overloadData->hasArgumentTypeReplace() ? overloadData->argumentTypeReplaced() : QString());
-    bool rejectNull = shouldRejectNullPointerArgument(overloadData->referenceFunction(), overloadData->argPos());
+    bool rejectNull =
+        shouldRejectNullPointerArgument(api(), overloadData->referenceFunction(), overloadData->argPos());
     writeTypeCheck(s, argType, argumentName, numberType, customType, rejectNull);
 }
 
@@ -2507,7 +2510,7 @@ void CppGenerator::writePythonToCppTypeConversion(TextStream &s,
 
     const bool isEnum = typeEntry->isEnum();
     const bool isFlags = typeEntry->isFlags();
-    bool treatAsPointer = isValueTypeWithCopyConstructorOnly(type);
+    bool treatAsPointer = isValueTypeWithCopyConstructorOnly(api(), type);
     bool isPointerOrObjectType = (type.isObjectType() || type.isPointer())
         && !type.isUserPrimitive() && !type.isExtendedCppPrimitive()
         && !isEnum && !isFlags;
@@ -2530,10 +2533,10 @@ void CppGenerator::writePythonToCppTypeConversion(TextStream &s,
 
     if (mayHaveImplicitConversion) {
         s << typeName << ' ' << cppOutAux;
-        writeMinimalConstructorExpression(s, type, defaultValue);
+        writeMinimalConstructorExpression(s, api(), type, defaultValue);
         s << ";\n";
     } else if (avoidProtectedHack() && isEnum) {
-        auto metaEnum = findAbstractMetaEnum(type);
+        auto metaEnum = api().findAbstractMetaEnum(type.typeEntry());
         if (metaEnum.has_value() && metaEnum->isProtected()) {
             typeName = QLatin1String("long");
             isProtectedEnum = true;
@@ -2567,9 +2570,9 @@ void CppGenerator::writePythonToCppTypeConversion(TextStream &s,
             else
                 s << "(long)" << defaultValue;
         } else if (type.isUserPrimitive() || isEnum || isFlags) {
-            writeMinimalConstructorExpression(s, typeEntry, defaultValue);
+            writeMinimalConstructorExpression(s, api(), typeEntry, defaultValue);
         } else if (!type.isContainer() && !type.isSmartPointer()) {
-            writeMinimalConstructorExpression(s, type, defaultValue);
+            writeMinimalConstructorExpression(s, api(), type, defaultValue);
         }
     }
     s << ";\n";
@@ -3191,7 +3194,7 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const Abst
     for (int i = 0; i < containerType.instantiations().count(); ++i) {
         const AbstractMetaType &type = containerType.instantiations().at(i);
         QString typeName = getFullTypeName(type);
-        if (type.isValue() && isValueTypeWithCopyConstructorOnly(type)) {
+        if (type.isValue() && isValueTypeWithCopyConstructorOnly(api(), type)) {
             for (int pos = 0; ; ) {
                 const QRegularExpressionMatch match = convertToCppRegEx().match(code, pos);
                 if (!match.hasMatch())
@@ -3314,9 +3317,10 @@ void CppGenerator::writeNamedArgumentResolution(TextStream &s, const AbstractMet
     s << "}\n";
 }
 
-QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunctionCPtr &func, int argIndex,
+QString CppGenerator::argumentNameFromIndex(const ApiExtractorResult &api,
+                                            const AbstractMetaFunctionCPtr &func, int argIndex,
                                             const AbstractMetaClass **wrappedClass,
-                                            QString *errorMessage) const
+                                            QString *errorMessage)
 {
     if (errorMessage != nullptr)
         errorMessage->clear();
@@ -3330,7 +3334,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunctionCPtr &func
         AbstractMetaType returnType = getTypeWithoutContainer(funcType);
         if (!returnType.isVoid()) {
             pyArgName = QLatin1String(PYTHON_RETURN_VAR);
-            *wrappedClass = AbstractMetaClass::findClass(classes(), returnType.typeEntry());
+            *wrappedClass = AbstractMetaClass::findClass(api.classes(), returnType.typeEntry());
             if (*wrappedClass == nullptr && errorMessage != nullptr)
                 *errorMessage = msgClassNotFound(returnType.typeEntry());
         } else {
@@ -3346,7 +3350,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunctionCPtr &func
     } else {
         int realIndex = argIndex - 1 - OverloadData::numberOfRemovedArguments(func, argIndex - 1);
         AbstractMetaType argType = getTypeWithoutContainer(func->arguments().at(realIndex).type());
-        *wrappedClass = AbstractMetaClass::findClass(classes(), argType.typeEntry());
+        *wrappedClass = AbstractMetaClass::findClass(api.classes(), argType.typeEntry());
         if (*wrappedClass == nullptr && errorMessage != nullptr)
             *errorMessage = msgClassNotFound(argType.typeEntry());
         if (argIndex == 1
@@ -3441,7 +3445,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                         userArgs.append(QLatin1String(CPP_ARG_REMOVED) + QString::number(i));
                 } else {
                     int idx = arg.argumentIndex() - removedArgs;
-                    bool deRef = isValueTypeWithCopyConstructorOnly(arg.type())
+                    bool deRef = isValueTypeWithCopyConstructorOnly(api(), arg.type())
                                  || arg.type().isObjectTypeUsedAsValueType()
                                  || (arg.type().referenceType() == LValueReference
                                      && arg.type().isWrapperType() && !arg.type().isPointer());
@@ -3652,7 +3656,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
             } else if (!func->isVoid() && !func->isInplaceOperator()) {
                 bool writeReturnType = true;
                 if (avoidProtectedHack()) {
-                    auto metaEnum = findAbstractMetaEnum(func->type());
+                    auto metaEnum = api().findAbstractMetaEnum(func->type().typeEntry());
                     if (metaEnum.has_value()) {
                         QString enumName;
                         if (metaEnum->isProtected())
@@ -3736,7 +3740,8 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
         for (const ArgumentModification &arg_mod : qAsConst(ownership_mods)) {
             const AbstractMetaClass *wrappedClass = nullptr;
             QString errorMessage;
-            QString pyArgName = argumentNameFromIndex(func, arg_mod.index(), &wrappedClass, &errorMessage);
+            QString pyArgName = argumentNameFromIndex(api(), func, arg_mod.index(),
+                                                      &wrappedClass, &errorMessage);
             if (!wrappedClass) {
                 QString message;
                 QTextStream str(&message);
@@ -3790,7 +3795,8 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
                 pyArgName = QLatin1String("Py_None");
             } else {
                 QString errorMessage;
-                pyArgName = argumentNameFromIndex(func, arg_mod.index(), &wrappedClass, &errorMessage);
+                pyArgName = argumentNameFromIndex(api(), func, arg_mod.index(),
+                                                  &wrappedClass, &errorMessage);
                 if (pyArgName.isEmpty()) {
                     QString message;
                     QTextStream str(&message);
@@ -4034,7 +4040,7 @@ void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s, const
         writeAddPythonToCppConversion(s, targetConverter, toCpp, isConv);
     };
 
-    auto klass = AbstractMetaClass::findClass(classes(), type.instantiations().at(0).typeEntry());
+    auto klass = AbstractMetaClass::findClass(api().classes(), type.instantiations().at(0).typeEntry());
     if (!klass)
         return;
 
@@ -4176,7 +4182,7 @@ void CppGenerator::writeClassDefinition(TextStream &s,
 
     bool onlyPrivCtor = !metaClass->hasNonPrivateConstructor();
 
-    const AbstractMetaClass *qCoreApp = AbstractMetaClass::findClass(classes(), QLatin1String("QCoreApplication"));
+    const AbstractMetaClass *qCoreApp = AbstractMetaClass::findClass(api().classes(), QLatin1String("QCoreApplication"));
     const bool isQApp = qCoreApp != Q_NULLPTR && metaClass->inheritsFrom(qCoreApp);
 
     tp_flags = QLatin1String("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES");
@@ -4801,7 +4807,7 @@ void CppGenerator::writeRichCompareFunction(TextStream &s,
             }
 
             bool first = true;
-            OverloadData overloadData(overloads, this);
+            OverloadData overloadData(overloads, api());
             const OverloadDataList &nextOverloads = overloadData.nextOverloadData();
             for (OverloadData *od : nextOverloads) {
                 const auto func = od->referenceFunction();
@@ -4930,7 +4936,7 @@ void CppGenerator::writeMethodDefinitionEntries(TextStream &s,
                                                 qsizetype maxEntries) const
 {
     Q_ASSERT(!overloads.isEmpty());
-    OverloadData overloadData(overloads, this);
+    OverloadData overloadData(overloads, api());
     const QStringList names = overloadData.referenceFunction()->definitionNames();
     const QString parameters = methodDefinitionParameters(overloadData);
     const qsizetype count = maxEntries > 0
@@ -4959,7 +4965,7 @@ void CppGenerator::writeMethodDefinition(TextStream &s, const AbstractMetaFuncti
 
 void CppGenerator::writeSignatureInfo(TextStream &s, const AbstractMetaFunctionCList &overloads) const
 {
-    OverloadData overloadData(overloads, this);
+    OverloadData overloadData(overloads, api());
     const auto rfunc = overloadData.referenceFunction();
     QString funcName = fullPythonFunctionName(rfunc, false);
 
@@ -5743,7 +5749,7 @@ QString CppGenerator::qObjectGetAttroFunction() const
 {
     static QString result;
     if (result.isEmpty()) {
-        AbstractMetaClass *qobjectClass = AbstractMetaClass::findClass(classes(), qObjectT());
+        AbstractMetaClass *qobjectClass = AbstractMetaClass::findClass(api().classes(), qObjectT());
         Q_ASSERT(qobjectClass);
         result = QLatin1String("PySide::getMetaDataFromQObject(")
                  + cpythonWrapperCPtr(qobjectClass, QLatin1String("self"))
@@ -5929,7 +5935,7 @@ bool CppGenerator::finishGeneration()
         writeMethodDefinition(s_globalFunctionDef, overloads);
     }
 
-    for (const AbstractMetaClass *cls : classes()){
+    for (auto cls : api().classes()){
         if (shouldGenerate(cls)) {
             writeInitFunc(s_classInitDecl, s_classPythonDefines,
                           getSimpleClassInitFunctionName(cls),
@@ -5978,7 +5984,7 @@ bool CppGenerator::finishGeneration()
     s << '\n';
 
     // Global enums
-    AbstractMetaEnumList globalEnums = this->globalEnums();
+    AbstractMetaEnumList globalEnums = api().globalEnums();
     for (const AbstractMetaClass *nsp : invisibleTopNamespaces())
         nsp->getEnumsToBeGenerated(&globalEnums);
 
@@ -6269,7 +6275,7 @@ bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaF
     const auto &groups = func->implementingClass()
         ? getFunctionGroups(func->implementingClass())
         : getGlobalFunctionGroups();
-    bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(OverloadData(groups[func->name()], this));
+    bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(OverloadData(groups[func->name()], api()));
 
     ArgumentOwner argOwner = getArgumentOwner(func, argIndex);
     ArgumentOwner::Action action = argOwner.action;
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h
index adf349d78..97811c946 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.h
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.h
@@ -67,9 +67,9 @@ private:
                                    const QString &funcName, const CodeSnipList &snips,
                                    const AbstractMetaArgument *lastArg, const TypeEntry *retType,
                                    const QString &returnStatement) const;
-    QString virtualMethodReturn(TextStream &s,
-                                const AbstractMetaFunctionCPtr &func,
-                                const FunctionModificationList &functionModifications) const;
+    static QString virtualMethodReturn(TextStream &s, const ApiExtractorResult &api,
+                                       const AbstractMetaFunctionCPtr &func,
+                                       const FunctionModificationList &functionModifications);
     void writeMetaObjectMethod(TextStream &s, const GeneratorContext &classContext) const;
     void writeMetaCast(TextStream &s, const GeneratorContext &classContext) const;
 
@@ -269,9 +269,10 @@ private:
                                       bool usePyArgs, const OverloadData &overloadData) const;
 
     /// Returns a string containing the name of an argument for the given function and argument index.
-    QString argumentNameFromIndex(const AbstractMetaFunctionCPtr &func, int argIndex,
-                                  const AbstractMetaClass **wrappedClass,
-                                  QString *errorMessage = nullptr) const;
+    static QString argumentNameFromIndex(const ApiExtractorResult &api,
+                                         const AbstractMetaFunctionCPtr &func, int argIndex,
+                                         const AbstractMetaClass **wrappedClass,
+                                         QString *errorMessage = nullptr);
     void writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr &func,
                          const GeneratorContext &context, int maxArgs = 0) const;
 
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp
index bb968a0ee..fb7e36524 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp
@@ -27,6 +27,7 @@
 ****************************************************************************/
 
 #include "headergenerator.h"
+#include <apiextractorresult.h>
 #include <abstractmetaenum.h>
 #include <abstractmetafield.h>
 #include <abstractmetafunction.h>
@@ -314,7 +315,8 @@ static inline void _writeTypeIndexValueLine(TextStream &s,
     s << ",\n";
 }
 
-void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const TypeEntry *typeEntry) const
+void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api,
+                                              const TypeEntry *typeEntry)
 {
     if (!typeEntry || !typeEntry->generateCode())
         return;
@@ -324,7 +326,8 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const TypeEntry *ty
     if (typeEntry->isComplex()) {
         const auto *cType = static_cast<const ComplexTypeEntry *>(typeEntry);
         if (cType->baseContainerType()) {
-            const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), cType);
+            auto metaClass = AbstractMetaClass::findClass(api.classes(), cType);
+            Q_ASSERT(metaClass != nullptr);
             if (metaClass->templateBaseClass())
                 _writeTypeIndexValueLine(s, getTypeIndexVariableName(metaClass, true), typeIndex);
         }
@@ -332,11 +335,12 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const TypeEntry *ty
     if (typeEntry->isEnum()) {
         auto ete = static_cast<const EnumTypeEntry *>(typeEntry);
         if (ete->flags())
-            writeTypeIndexValueLine(s, ete->flags());
+            writeTypeIndexValueLine(s, api, ete->flags());
     }
 }
 
-void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const AbstractMetaClass *metaClass) const
+void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api,
+                                               const AbstractMetaClass *metaClass)
 {
     auto typeEntry = metaClass->typeEntry();
     if (!typeEntry->generateCode())
@@ -344,10 +348,10 @@ void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const AbstractMeta
     // enum indices are required for invisible namespaces as well.
     for (const AbstractMetaEnum &metaEnum : metaClass->enums()) {
         if (!metaEnum.isPrivate())
-            writeTypeIndexValueLine(s, metaEnum.typeEntry());
+            writeTypeIndexValueLine(s, api, metaEnum.typeEntry());
     }
     if (NamespaceTypeEntry::isVisibleScope(typeEntry))
-        writeTypeIndexValueLine(s, metaClass->typeEntry());
+        writeTypeIndexValueLine(s, api, metaClass->typeEntry());
 }
 
 // Format the typedefs for the typedef entries to be generated
@@ -392,17 +396,17 @@ bool HeaderGenerator::finishGeneration()
     }
 
     macrosStream << "// Type indices\nenum : int {\n";
-    AbstractMetaClassList classList = classes();
+    AbstractMetaClassList classList = api().classes();
 
     std::sort(classList.begin(), classList.end(), [](AbstractMetaClass *a, AbstractMetaClass *b) {
         return a->typeEntry()->sbkIndex() < b->typeEntry()->sbkIndex();
     });
 
     for (const AbstractMetaClass *metaClass : classList)
-        writeTypeIndexValueLines(macrosStream, metaClass);
+        writeTypeIndexValueLines(macrosStream, api(), metaClass);
 
-    for (const AbstractMetaEnum &metaEnum : globalEnums())
-        writeTypeIndexValueLine(macrosStream, metaEnum.typeEntry());
+    for (const AbstractMetaEnum &metaEnum : api().globalEnums())
+        writeTypeIndexValueLine(macrosStream, api(), metaEnum.typeEntry());
 
     // Write the smart pointer define indexes.
     int smartPointerCountIndex = getMaxTypeIndex();
@@ -477,7 +481,7 @@ bool HeaderGenerator::finishGeneration()
         typeFunctions << "QT_WARNING_PUSH\n";
         typeFunctions << "QT_WARNING_DISABLE_DEPRECATED\n";
     }
-    for (const AbstractMetaEnum &cppEnum : globalEnums()) {
+    for (const AbstractMetaEnum &cppEnum : api().globalEnums()) {
         if (!cppEnum.isAnonymous()) {
             includes << cppEnum.typeEntry()->include();
             writeSbkTypeFunction(typeFunctions, cppEnum);
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h
index a5cf2f272..049ebd30a 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.h
+++ b/sources/shiboken6/generator/shiboken/headergenerator.h
@@ -58,8 +58,10 @@ private:
     void writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum) const;
     void writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass) const;
     void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType) const;
-    void writeTypeIndexValueLine(TextStream &s, const TypeEntry *typeEntry) const;
-    void writeTypeIndexValueLines(TextStream &s, const AbstractMetaClass *metaClass) const;
+    static void writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api,
+                                        const TypeEntry *typeEntry);
+    static void writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api,
+                                         const AbstractMetaClass *metaClass);
     void writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum) const;
     void writeInheritedOverloads(TextStream &s) const;
 
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp
index 4f887fc87..b77fa2c57 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.cpp
+++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp
@@ -27,12 +27,13 @@
 ****************************************************************************/
 
 #include <abstractmetafunction.h>
+#include <apiextractorresult.h>
 #include <abstractmetalang.h>
 #include <reporthandler.h>
+#include <typesystem.h>
 #include <graph.h>
 #include "overloaddata.h"
 #include "ctypenames.h"
-#include "shibokengenerator.h"
 #include "textstream.h"
 
 #include <QtCore/QDir>
@@ -239,7 +240,7 @@ void OverloadData::sortNextOverloads()
                 for (const QString &primitive : qAsConst(nonIntegerPrimitives))
                     graph.addNode(getImplicitConversionTypeName(ov->argType(), instantiation, nullptr, primitive));
             } else {
-                const auto &funcs = m_generator->implicitConversions(instantiation);
+                const auto &funcs = m_api.implicitConversions(instantiation);
                 for (const auto &function : funcs)
                     graph.addNode(getImplicitConversionTypeName(ov->argType(), instantiation, function));
             }
@@ -271,7 +272,7 @@ void OverloadData::sortNextOverloads()
         const QString targetTypeEntryName = getTypeName(ov);
 
         // Process implicit conversions
-        const auto &functions = m_generator->implicitConversions(targetType);
+        const auto &functions = m_api.implicitConversions(targetType);
         for (const auto &function : functions) {
             QString convertibleType;
             if (function->isConversionOperator())
@@ -294,7 +295,8 @@ void OverloadData::sortNextOverloads()
 
         // Process inheritance relationships
         if (targetType.isValue() || targetType.isObject()) {
-            const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_generator->classes(), targetType.typeEntry());
+            auto metaClass = AbstractMetaClass::findClass(m_api.classes(),
+                                                          targetType.typeEntry());
             const AbstractMetaClassList &ancestors = metaClass->allTypeSystemAncestors();
             for (const AbstractMetaClass *ancestor : ancestors) {
                 QString ancestorTypeName = ancestor->typeEntry()->name();
@@ -322,7 +324,7 @@ void OverloadData::sortNextOverloads()
                     }
 
                 } else {
-                    const auto &funcs = m_generator->implicitConversions(instantiation);
+                    const auto &funcs = m_api.implicitConversions(instantiation);
                     for (const auto &function : funcs) {
                         QString convertibleTypeName =
                             getImplicitConversionTypeName(ov->argType(), instantiation, function);
@@ -441,9 +443,11 @@ void OverloadData::sortNextOverloads()
  *                    \- int
  *
  */
-OverloadData::OverloadData(const AbstractMetaFunctionCList &overloads, const ShibokenGenerator *generator)
+OverloadData::OverloadData(const AbstractMetaFunctionCList &overloads,
+                           const ApiExtractorResult &api)
     : m_minArgs(256), m_maxArgs(0), m_argPos(-1), m_argType(nullptr),
-    m_headOverloadData(this), m_previousOverloadData(nullptr), m_generator(generator)
+    m_headOverloadData(this), m_previousOverloadData(nullptr),
+    m_api(api)
 {
     for (const auto &func : overloads) {
         m_overloads.append(func);
@@ -471,10 +475,10 @@ OverloadData::OverloadData(const AbstractMetaFunctionCList &overloads, const Shi
 }
 
 OverloadData::OverloadData(OverloadData *headOverloadData, const AbstractMetaFunctionCPtr &func,
-                                 const AbstractMetaType &argType, int argPos)
-    : m_minArgs(256), m_maxArgs(0), m_argPos(argPos), m_argType(argType),
-      m_headOverloadData(headOverloadData), m_previousOverloadData(nullptr),
-      m_generator(nullptr)
+                           const AbstractMetaType &argType, int argPos,
+                           const ApiExtractorResult &api) :
+      m_minArgs(256), m_maxArgs(0), m_argPos(argPos), m_argType(argType),
+      m_headOverloadData(headOverloadData), m_previousOverloadData(nullptr), m_api(api)
 {
     if (func)
         this->addOverload(func);
@@ -527,9 +531,8 @@ OverloadData *OverloadData::addOverloadData(const AbstractMetaFunctionCPtr &func
     }
 
     if (!overloadData) {
-        overloadData = new OverloadData(m_headOverloadData, func, argType, m_argPos + 1);
+        overloadData = new OverloadData(m_headOverloadData, func, argType, m_argPos + 1, m_api);
         overloadData->m_previousOverloadData = this;
-        overloadData->m_generator = this->m_generator;
         QString typeReplaced = func->typeReplaced(arg.argumentIndex() + 1);
 
         if (!typeReplaced.isEmpty())
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.h b/sources/shiboken6/generator/shiboken/overloaddata.h
index 317b1d022..ecd7a5596 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.h
+++ b/sources/shiboken6/generator/shiboken/overloaddata.h
@@ -29,21 +29,21 @@
 #ifndef OVERLOADDATA_H
 #define OVERLOADDATA_H
 
-#include <abstractmetalang_typedefs.h>
+#include <apiextractorresult.h>
+
 #include <QtCore/QBitArray>
 #include <QtCore/QList>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
-class ShibokenGenerator;
-
 class OverloadData;
 using OverloadDataList = QList<OverloadData *>;
 
 class OverloadData
 {
 public:
-    OverloadData(const AbstractMetaFunctionCList &overloads, const ShibokenGenerator *generator);
+    OverloadData(const AbstractMetaFunctionCList &overloads,
+                 const ApiExtractorResult &api);
     ~OverloadData();
 
     int minArgs() const { return m_headOverloadData->m_minArgs; }
@@ -129,7 +129,8 @@ public:
 
 private:
     OverloadData(OverloadData *headOverloadData, const AbstractMetaFunctionCPtr &func,
-                 const AbstractMetaType &argType, int argPos);
+                 const AbstractMetaType &argType, int argPos,
+                 const ApiExtractorResult &api);
 
     void addOverload(const AbstractMetaFunctionCPtr &func);
     OverloadData *addOverloadData(const AbstractMetaFunctionCPtr &func, const AbstractMetaArgument &arg);
@@ -150,7 +151,7 @@ private:
     OverloadData *m_headOverloadData;
     OverloadDataList m_nextOverloadData;
     OverloadData *m_previousOverloadData;
-    const ShibokenGenerator *m_generator;
+    const ApiExtractorResult m_api;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 67584eff1..201576675 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -27,6 +27,7 @@
 ****************************************************************************/
 
 #include "shibokengenerator.h"
+#include "apiextractorresult.h"
 #include "ctypenames.h"
 #include <abstractmetaenum.h>
 #include <abstractmetafield.h>
@@ -212,7 +213,7 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType
         return translateTypeForWrapperMethod(*cType.arrayElementType(), context, options) + QLatin1String("[]");
 
     if (avoidProtectedHack() && cType.isEnum()) {
-        auto metaEnum = findAbstractMetaEnum(cType);
+        auto metaEnum = api().findAbstractMetaEnum(cType.typeEntry());
         if (metaEnum && metaEnum->isProtected())
             return protectedEnumSurrogateName(metaEnum.value());
     }
@@ -516,14 +517,14 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunctionC
 
     QString prefix;
     if (arg.type().isEnum()) {
-        auto metaEnum = findAbstractMetaEnum(arg.type());
+        auto metaEnum = api().findAbstractMetaEnum(arg.type().typeEntry());
         if (metaEnum.has_value())
             prefix = resolveScopePrefix(metaEnum.value(), value);
     } else if (arg.type().isFlags()) {
         value = guessScopeForDefaultFlagsValue(func, arg, value);
     } else if (arg.type().typeEntry()->isValue()) {
-        const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(),
-                                                                          arg.type().typeEntry());
+        auto metaClass = AbstractMetaClass::findClass(api().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()) {
@@ -634,13 +635,14 @@ void ShibokenGenerator::writeToCppConversion(TextStream &s, const AbstractMetaTy
     s << cpythonToCppConversionFunction(type, context) << inArgName << ", &" << outArgName << ')';
 }
 
-bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func, int argIndex) const
+bool ShibokenGenerator::shouldRejectNullPointerArgument(const ApiExtractorResult &api,
+                                                        const AbstractMetaFunctionCPtr &func, int argIndex)
 {
     if (argIndex < 0 || argIndex >= func->arguments().count())
         return false;
 
     const AbstractMetaArgument &arg = func->arguments().at(argIndex);
-    if (isValueTypeWithCopyConstructorOnly(arg.type()))
+    if (isValueTypeWithCopyConstructorOnly(api, arg.type()))
         return true;
 
     // Argument type is not a pointer, a None rejection should not be
@@ -804,7 +806,7 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType &type) const
     return converterObject(typeEntry);
 }
 
-QString ShibokenGenerator::converterObject(const TypeEntry *type) const
+QString ShibokenGenerator::converterObject(const TypeEntry *type)
 {
     if (type->isExtendedCppPrimitive())
         return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(type->qualifiedCppName());
@@ -1009,18 +1011,20 @@ bool ShibokenGenerator::isPyInt(const AbstractMetaType &type)
     return isPyInt(type.typeEntry());
 }
 
-bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const TypeEntry *type) const
+bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const ApiExtractorResult &api,
+                                                           const TypeEntry *type)
 {
     if (!type || !type->isValue())
         return false;
-    auto klass = AbstractMetaClass::findClass(classes(), type);
+    auto klass = AbstractMetaClass::findClass(api.classes(), type);
     return klass != nullptr && klass->isValueTypeWithCopyConstructorOnly();
 }
 
-bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaType &type) const
+bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const ApiExtractorResult &api,
+                                                           const AbstractMetaType &type)
 {
    return type.typeEntry()->isValue()
-       && isValueTypeWithCopyConstructorOnly(type.typeEntry());
+       && isValueTypeWithCopyConstructorOnly(api, type.typeEntry());
 }
 
 bool ShibokenGenerator::isNullPtr(const QString &value)
@@ -1111,7 +1115,7 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry *type, bool gene
     }
     QString typeCheck;
     if (type->targetLangApiName() == type->name())
-        typeCheck = cpythonIsConvertibleFunction(type);
+        typeCheck = cpythonIsConvertibleFunction(api(), type);
     else if (type->targetLangApiName() == QLatin1String("PyUnicode"))
         typeCheck = QLatin1String("Shiboken::String::check");
     else
@@ -1143,13 +1147,13 @@ ShibokenGenerator::CPythonCheckFunctionResult
     return result;
 }
 
-QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry *type,
+QString ShibokenGenerator::cpythonIsConvertibleFunction(const ApiExtractorResult &api, const TypeEntry *type,
                                                         bool /* genericNumberType */,
-                                                        bool /* checkExact */) const
+                                                        bool /* checkExact */)
 {
     if (type->isWrapperType()) {
         QString result = QLatin1String("Shiboken::Conversions::");
-        result += (type->isValue() && !isValueTypeWithCopyConstructorOnly(type))
+        result += (type->isValue() && !isValueTypeWithCopyConstructorOnly(api, type))
                          ? QLatin1String("isPythonToCppValueConvertible")
                          : QLatin1String("isPythonToCppPointerConvertible");
         result += QLatin1String("(reinterpret_cast<SbkObjectType *>(")
@@ -1172,7 +1176,7 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(AbstractMetaType metaTyp
 
     QString result = QLatin1String("Shiboken::Conversions::");
     if (metaType.isWrapperType()) {
-        if (metaType.isPointer() || isValueTypeWithCopyConstructorOnly(metaType))
+        if (metaType.isPointer() || isValueTypeWithCopyConstructorOnly(api(), metaType))
             result += QLatin1String("isPythonToCppPointerConvertible");
         else if (metaType.referenceType() == LValueReference)
             result += QLatin1String("isPythonToCppReferenceConvertible");
@@ -1462,7 +1466,7 @@ AbstractMetaFunctionCList ShibokenGenerator::filterFunctions(const AbstractMetaC
 ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverters() const
 {
     ExtendedConverterData extConvs;
-    for (const AbstractMetaClass *metaClass : classes()) {
+    for (auto metaClass : api().classes()) {
         // Use only the classes for the current module.
         if (!shouldGenerate(metaClass))
             continue;
@@ -1663,7 +1667,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
     const auto &groups = func->implementingClass()
         ? getFunctionGroups(func->implementingClass())
         : getGlobalFunctionGroups();
-    OverloadData od(groups[func->name()], this);
+    OverloadData od(groups[func->name()], api());
     bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(od);
 
     // Replace %PYARG_# variables.
@@ -1971,7 +1975,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
                     if (varType != QLatin1String("auto") && varType != conversionSignature)
                         qFatal("%s", qPrintable(msgConversionTypesDiffer(varType, conversionSignature)));
                     c << getFullTypeName(conversionType) << ' ' << varName;
-                    writeMinimalConstructorExpression(c, conversionType);
+                    writeMinimalConstructorExpression(c, api(), conversionType);
                     c << ";\n";
                 }
                 c << cpythonToCppConversionFunction(conversionType);
@@ -2239,7 +2243,7 @@ static void insertIntoFunctionGroups(const AbstractMetaFunctionCList &lst,
 ShibokenGenerator::FunctionGroups ShibokenGenerator::getGlobalFunctionGroups() const
 {
     FunctionGroups results;
-    insertIntoFunctionGroups(globalFunctions(), &results);
+    insertIntoFunctionGroups(api().globalFunctions(), &results);
     for (auto nsp : invisibleTopNamespaces())
         insertIntoFunctionGroups(nsp->functions(), &results);
     return results;
@@ -2322,7 +2326,7 @@ AbstractMetaFunctionCList
 AbstractMetaFunctionCList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass *scope,
                                                                  const QString &functionName) const
 {
-    const auto &lst = scope ? scope->functions() : globalFunctions();
+    const auto &lst = scope ? scope->functions() : api().globalFunctions();
 
     AbstractMetaFunctionCList results;
     QSet<QString> seenSignatures;
@@ -2413,7 +2417,7 @@ bool ShibokenGenerator::doSetup()
     const ContainerTypeEntryList &containerTypeList = containerTypes();
     for (const ContainerTypeEntry *type : containerTypeList)
         getCode(snips, type);
-    for (const AbstractMetaClass *metaClass : classes())
+    for (auto metaClass : api().classes())
         getCode(snips, metaClass->typeEntry());
 
     const TypeSystemTypeEntry *moduleEntry = TypeDatabase::instance()->defaultTypeSystemType();
@@ -2591,8 +2595,9 @@ bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadD
 }
 
 void ShibokenGenerator::writeMinimalConstructorExpression(TextStream &s,
+                                                          const ApiExtractorResult &api,
                                                           const AbstractMetaType &type,
-                                                          const QString &defaultCtor) const
+                                                          const QString &defaultCtor)
 {
     if (!defaultCtor.isEmpty()) {
          s << " = " << defaultCtor;
@@ -2601,7 +2606,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(TextStream &s,
     if (type.isExtendedCppPrimitive() || type.isSmartPointer())
         return;
     QString errorMessage;
-    const auto ctor = minimalConstructor(type, &errorMessage);
+    const auto ctor = minimalConstructor(api, type, &errorMessage);
     if (ctor.has_value()) {
         s << ctor->initialization();
     } else {
@@ -2613,8 +2618,10 @@ void ShibokenGenerator::writeMinimalConstructorExpression(TextStream &s,
     }
 }
 
-void ShibokenGenerator::writeMinimalConstructorExpression(TextStream &s, const TypeEntry *type,
-                                                          const QString &defaultCtor) const
+void ShibokenGenerator::writeMinimalConstructorExpression(TextStream &s,
+                                                          const ApiExtractorResult &api,
+                                                          const TypeEntry *type,
+                                                          const QString &defaultCtor)
 {
     if (!defaultCtor.isEmpty()) {
          s << " = " << defaultCtor;
@@ -2622,7 +2629,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(TextStream &s, const T
     }
     if (type->isExtendedCppPrimitive())
         return;
-    const auto ctor = minimalConstructor(type);
+    const auto ctor = minimalConstructor(api, type);
     if (ctor.has_value()) {
         s << ctor->initialization();
     } else {
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h
index 4a73e0c6d..321c70303 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.h
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h
@@ -176,7 +176,8 @@ protected:
                               const QString &outArgName) const;
 
     /// Returns true if the argument is a pointer that rejects nullptr values.
-    bool shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func, int argIndex) const;
+    static bool shouldRejectNullPointerArgument(const ApiExtractorResult &api,
+                                                const AbstractMetaFunctionCPtr &func, int argIndex);
 
     /// Verifies if the class should have a C++ wrapper generated for it, instead of only a Python wrapper.
     bool shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const;
@@ -213,13 +214,15 @@ protected:
     static bool isPyInt(const TypeEntry *type);
     static bool isPyInt(const AbstractMetaType &type);
 
-    bool isValueTypeWithCopyConstructorOnly(const TypeEntry *type) const;
-    bool isValueTypeWithCopyConstructorOnly(const AbstractMetaType &type) const;
+    static bool isValueTypeWithCopyConstructorOnly(const ApiExtractorResult &api,
+                                                   const TypeEntry *type);
+    static bool isValueTypeWithCopyConstructorOnly(const ApiExtractorResult &api,
+                                                   const AbstractMetaType &type);
 
     static bool isNullPtr(const QString &value);
 
     QString converterObject(const AbstractMetaType &type) const;
-    QString converterObject(const TypeEntry *type) const;
+    static QString converterObject(const TypeEntry *type);
 
     static QString cpythonBaseName(const AbstractMetaClass *metaClass);
     static QString cpythonBaseName(const TypeEntry *type);
@@ -246,8 +249,10 @@ protected:
         std::optional<AbstractMetaType> type;
     };
     CPythonCheckFunctionResult guessCPythonCheckFunction(const QString &type) const;
-    QString cpythonIsConvertibleFunction(const TypeEntry *type, bool genericNumberType = false,
-                                                bool checkExact = false) const;
+    static QString cpythonIsConvertibleFunction(const ApiExtractorResult &api,
+                                                const TypeEntry *type,
+                                                bool genericNumberType = false,
+                                                bool checkExact = false);
     QString cpythonIsConvertibleFunction(AbstractMetaType metaType,
                                          bool genericNumberType = false) const;
     QString cpythonIsConvertibleFunction(const AbstractMetaArgument &metaArg,
@@ -341,10 +346,12 @@ protected:
     /// Creates an AbstractMetaType object from an AbstractMetaClass.
     AbstractMetaType buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass *metaClass) const;
 
-    void writeMinimalConstructorExpression(TextStream &s, const AbstractMetaType &type,
-                                           const QString &defaultCtor = QString()) const;
-    void writeMinimalConstructorExpression(TextStream &s, const TypeEntry *type,
-                                           const QString &defaultCtor = QString()) const;
+    static void writeMinimalConstructorExpression(TextStream &s, const ApiExtractorResult &api,
+                                                  const AbstractMetaType &type,
+                                                  const QString &defaultCtor = QString());
+    static void writeMinimalConstructorExpression(TextStream &s, const ApiExtractorResult &api,
+                                                  const TypeEntry *type,
+                                                  const QString &defaultCtor = QString());
 
     void collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro);