shiboken6: AbstractMetaClass: Introduce a private class

Move the data members of AbstractMetaClass to a private class. Similar
to what was done for TypeEntry, the main motivation here is header
hygiene and decoupling.

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

6 files changed, 538 insertions, 247 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index d7393d82a..a742910ec 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -28,6 +28,7 @@
 
 #include "abstractmetalang.h"
 #include "abstractmetalang_helpers.h"
+#include "abstractmetaenum.h"
 #include "abstractmetafunction.h"
 #include "abstractmetafield.h"
 #include "modifications.h"
@@ -43,30 +44,79 @@ bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b)
     return a->signature() < b->signature();
 }
 
-AbstractMetaClass::AbstractMetaClass()
-    : m_hasVirtuals(false),
-      m_isPolymorphic(false),
-      m_hasNonpublic(false),
-      m_hasNonPrivateConstructor(false),
-      m_hasPrivateConstructor(false),
-      m_functionsFixed(false),
-      m_hasPrivateDestructor(false),
-      m_hasProtectedDestructor(false),
-      m_hasVirtualDestructor(false),
-      m_hasHashFunction(false),
-      m_hasEqualsOperator(false),
-      m_hasCloneOperator(false),
-      m_isTypeDef(false),
-      m_hasToStringCapability(false)
-{
-}
+class AbstractMetaClassPrivate
+{
+public:
+    AbstractMetaClassPrivate()
+        : m_hasVirtuals(false),
+          m_isPolymorphic(false),
+          m_hasNonpublic(false),
+          m_hasNonPrivateConstructor(false),
+          m_hasPrivateConstructor(false),
+          m_functionsFixed(false),
+          m_hasPrivateDestructor(false),
+          m_hasProtectedDestructor(false),
+          m_hasVirtualDestructor(false),
+          m_hasHashFunction(false),
+          m_hasEqualsOperator(false),
+          m_hasCloneOperator(false),
+          m_isTypeDef(false),
+          m_hasToStringCapability(false)
+    {
+    }
+
+    ~AbstractMetaClassPrivate()
+    {
+        qDeleteAll(m_functions);
+        qDeleteAll(m_propertySpecs);
+    }
+
+    uint m_hasVirtuals : 1;
+    uint m_isPolymorphic : 1;
+    uint m_hasNonpublic : 1;
+    uint m_hasNonPrivateConstructor : 1;
+    uint m_hasPrivateConstructor : 1;
+    uint m_functionsFixed : 1;
+    uint m_hasPrivateDestructor : 1;
+    uint m_hasProtectedDestructor : 1;
+    uint m_hasVirtualDestructor : 1;
+    uint m_hasHashFunction : 1;
+    uint m_hasEqualsOperator : 1;
+    uint m_hasCloneOperator : 1;
+    uint m_isTypeDef : 1;
+    uint m_hasToStringCapability : 1;
+
+    Documentation m_doc;
 
-AbstractMetaClass::~AbstractMetaClass()
+    const AbstractMetaClass *m_enclosingClass = nullptr;
+    AbstractMetaClassList m_baseClasses; // Real base classes after setting up inheritance
+    AbstractMetaTypeList m_baseTemplateInstantiations;
+    AbstractMetaClass *m_extendedNamespace = nullptr;
+
+    const AbstractMetaClass *m_templateBaseClass = nullptr;
+    AbstractMetaFunctionList m_functions;
+    AbstractMetaFieldList m_fields;
+    AbstractMetaEnumList m_enums;
+    QVector<QPropertySpec *> m_propertySpecs;
+    AbstractMetaClassList m_innerClasses;
+
+    AbstractMetaFunctionList m_externalConversionOperators;
+
+    QStringList m_baseClassNames;  // Base class names from C++, including rejected
+    QVector<TypeEntry *> m_templateArgs;
+    ComplexTypeEntry *m_typeEntry = nullptr;
+    SourceLocation m_sourceLocation;
+
+    bool m_stream = false;
+    uint m_toStringCapabilityIndirections = 0;
+};
+
+AbstractMetaClass::AbstractMetaClass() : d(new AbstractMetaClassPrivate)
 {
-    qDeleteAll(m_functions);
-    qDeleteAll(m_propertySpecs);
 }
 
+AbstractMetaClass::~AbstractMetaClass() = default;
+
 /*******************************************************************************
  * Returns true if this class is a subclass of the given class
  */
@@ -85,13 +135,18 @@ bool AbstractMetaClass::inheritsFrom(const AbstractMetaClass *cls) const
     return false;
 }
 
+bool AbstractMetaClass::isPolymorphic() const
+{
+    return d->m_isPolymorphic;
+}
+
 /*******************************************************************************
  * Returns a list of all the functions with a given name
  */
 AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const
 {
     AbstractMetaFunctionList returned;
-    for (AbstractMetaFunction *function : m_functions) {
+    for (AbstractMetaFunction *function : d->m_functions) {
         if (function->name() == name)
             returned.append(function);
     }
@@ -176,7 +231,7 @@ AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptio
 
 bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : m_functions) {
+    for (const AbstractMetaFunction *f : d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isArithmeticOperator() && !f->isPrivate())
             return true;
     }
@@ -185,7 +240,7 @@ bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 
 bool AbstractMetaClass::hasBitwiseOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : m_functions) {
+    for (const AbstractMetaFunction *f : d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isBitwiseOperator() && !f->isPrivate())
             return true;
     }
@@ -194,7 +249,7 @@ bool AbstractMetaClass::hasBitwiseOperatorOverload() const
 
 bool AbstractMetaClass::hasComparisonOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : m_functions) {
+    for (const AbstractMetaFunction *f : d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isComparisonOperator() && !f->isPrivate())
             return true;
     }
@@ -203,29 +258,64 @@ bool AbstractMetaClass::hasComparisonOperatorOverload() const
 
 bool AbstractMetaClass::hasLogicalOperatorOverload() const
 {
-    for (const AbstractMetaFunction *f : m_functions) {
+    for (const AbstractMetaFunction *f : d->m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isLogicalOperator() && !f->isPrivate())
             return true;
     }
     return false;
 }
 
+const AbstractMetaFieldList &AbstractMetaClass::fields() const
+{
+    return d->m_fields;
+}
+
+AbstractMetaFieldList &AbstractMetaClass::fields()
+{
+    return d->m_fields;
+}
+
+void AbstractMetaClass::setFields(const AbstractMetaFieldList &fields)
+{
+    d->m_fields = fields;
+}
+
+void AbstractMetaClass::addField(const AbstractMetaField &field)
+{
+    d->m_fields << field;
+}
+
 void AbstractMetaClass::sortFunctions()
 {
-    std::sort(m_functions.begin(), m_functions.end(), function_sorter);
+    std::sort(d->m_functions.begin(), d->m_functions.end(), function_sorter);
+}
+
+const AbstractMetaClass *AbstractMetaClass::templateBaseClass() const
+{
+    return d->m_templateBaseClass;
+}
+
+void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClass *cls)
+{
+    d->m_templateBaseClass = cls;
+}
+
+const AbstractMetaFunctionList &AbstractMetaClass::functions() const
+{
+    return d->m_functions;
 }
 
 void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
 {
-    m_functions = functions;
+    d->m_functions = functions;
 
     // Functions must be sorted by name before next loop
     sortFunctions();
 
-    for (AbstractMetaFunction *f : qAsConst(m_functions)) {
+    for (AbstractMetaFunction *f : qAsConst(d->m_functions)) {
         f->setOwnerClass(this);
         if (!f->isPublic())
-            m_hasNonpublic = true;
+            d->m_hasNonpublic = true;
     }
 }
 
@@ -239,19 +329,49 @@ bool AbstractMetaClass::hasDefaultToStringFunction() const
     return false;
 }
 
+bool AbstractMetaClass::hasEqualsOperator() const
+{
+    return d->m_hasEqualsOperator;
+}
+
+void AbstractMetaClass::setHasEqualsOperator(bool on)
+{
+    d->m_hasEqualsOperator = on;
+}
+
+bool AbstractMetaClass::hasCloneOperator() const
+{
+    return d->m_hasCloneOperator;
+}
+
+void AbstractMetaClass::setHasCloneOperator(bool on)
+{
+    d->m_hasCloneOperator = on;
+}
+
+const QVector<QPropertySpec *> &AbstractMetaClass::propertySpecs() const
+{
+    return d->m_propertySpecs;
+}
+
+void AbstractMetaClass::addPropertySpec(QPropertySpec *spec)
+{
+    d->m_propertySpecs << spec;
+}
+
 void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
 {
     Q_ASSERT(!function->signature().startsWith(QLatin1Char('(')));
     function->setOwnerClass(this);
 
     if (!function->isDestructor())
-        m_functions << function;
+        d->m_functions << function;
     else
         Q_ASSERT(false); //memory leak
 
-    m_hasVirtuals |= function->isVirtual();
-    m_isPolymorphic |= m_hasVirtuals;
-    m_hasNonpublic |= !function->isPublic();
+    d->m_hasVirtuals |= function->isVirtual();
+    d->m_isPolymorphic |= d->m_hasVirtuals;
+    d->m_hasNonpublic |= !function->isPublic();
 }
 
 bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
@@ -259,7 +379,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
     if (!other->isSignal())
         return false;
 
-    for (const AbstractMetaFunction *f : m_functions) {
+    for (const AbstractMetaFunction *f : d->m_functions) {
         if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName)
             return other->modifiedName() == f->modifiedName();
     }
@@ -270,40 +390,90 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
 
 QString AbstractMetaClass::name() const
 {
-    return m_typeEntry->targetLangEntryName();
+    return d->m_typeEntry->targetLangEntryName();
+}
+
+const Documentation &AbstractMetaClass::documentation() const
+{
+    return d->m_doc;
+}
+
+void AbstractMetaClass::setDocumentation(const Documentation &doc)
+{
+    d->m_doc = doc;
+}
+
+QString AbstractMetaClass::baseClassName() const
+{
+    return d->m_baseClasses.isEmpty() ? QString() : d->m_baseClasses.constFirst()->name();
+}
+
+AbstractMetaClass *AbstractMetaClass::baseClass() const
+{
+    return d->m_baseClasses.value(0, nullptr);
+}
+
+const AbstractMetaClassList &AbstractMetaClass::baseClasses() const
+{
+    return d->m_baseClasses;
 }
 
 void AbstractMetaClass::addBaseClass(AbstractMetaClass *baseClass)
 {
     Q_ASSERT(baseClass);
-    m_baseClasses.append(baseClass);
-    m_isPolymorphic |= baseClass->isPolymorphic();
+    d->m_baseClasses.append(baseClass);
+    d->m_isPolymorphic |= baseClass->isPolymorphic();
 }
 
 void AbstractMetaClass::setBaseClass(AbstractMetaClass *baseClass)
 {
     if (baseClass) {
-        m_baseClasses.prepend(baseClass);
-        m_isPolymorphic |= baseClass->isPolymorphic();
+        d->m_baseClasses.prepend(baseClass);
+        d->m_isPolymorphic |= baseClass->isPolymorphic();
     }
 }
 
+AbstractMetaClass *AbstractMetaClass::extendedNamespace() const
+{
+    return d->m_extendedNamespace;
+}
+
+void AbstractMetaClass::setExtendedNamespace(AbstractMetaClass *e)
+{
+    d->m_extendedNamespace = e;
+}
+
+const AbstractMetaClassList &AbstractMetaClass::innerClasses() const
+{
+    return d->m_innerClasses;
+}
+
+void AbstractMetaClass::addInnerClass(AbstractMetaClass *cl)
+{
+    d->m_innerClasses << cl;
+}
+
+void AbstractMetaClass::setInnerClasses(const AbstractMetaClassList &innerClasses)
+{
+    d->m_innerClasses = innerClasses;
+}
+
 QString AbstractMetaClass::package() const
 {
-    return m_typeEntry->targetLangPackage();
+    return d->m_typeEntry->targetLangPackage();
 }
 
 bool AbstractMetaClass::isNamespace() const
 {
-    return m_typeEntry->isNamespace();
+    return d->m_typeEntry->isNamespace();
 }
 
 // Is an invisible namespaces whose functions/enums
 // should be mapped to the global space.
 bool AbstractMetaClass::isInvisibleNamespace() const
 {
-    return m_typeEntry->isNamespace() && m_typeEntry->generateCode()
-        && !NamespaceTypeEntry::isVisibleScope(m_typeEntry);
+    return d->m_typeEntry->isNamespace() && d->m_typeEntry->generateCode()
+        && !NamespaceTypeEntry::isVisibleScope(d->m_typeEntry);
 }
 
 static bool qObjectPredicate(const AbstractMetaClass *c)
@@ -316,9 +486,14 @@ bool AbstractMetaClass::isQObject() const
     return qObjectPredicate(this) || recurseClassHierarchy(this, qObjectPredicate) != nullptr;
 }
 
+bool AbstractMetaClass::isQtNamespace() const
+{
+    return isNamespace() && name() == QLatin1String("Qt");
+}
+
 QString AbstractMetaClass::qualifiedCppName() const
 {
-    return m_typeEntry->qualifiedCppName();
+    return d->m_typeEntry->qualifiedCppName();
 }
 
 bool AbstractMetaClass::hasFunction(const QString &str) const
@@ -328,12 +503,12 @@ bool AbstractMetaClass::hasFunction(const QString &str) const
 
 const AbstractMetaFunction *AbstractMetaClass::findFunction(const QString &functionName) const
 {
-    return AbstractMetaFunction::find(m_functions, functionName);
+    return AbstractMetaFunction::find(d->m_functions, functionName);
 }
 
 bool AbstractMetaClass::hasProtectedFunctions() const
 {
-    for (AbstractMetaFunction *func : m_functions) {
+    for (AbstractMetaFunction *func : d->m_functions) {
         if (func->isProtected())
             return true;
     }
@@ -342,7 +517,7 @@ bool AbstractMetaClass::hasProtectedFunctions() const
 
 bool AbstractMetaClass::hasProtectedFields() const
 {
-    for (const AbstractMetaField &field : m_fields) {
+    for (const AbstractMetaField &field : d->m_fields) {
         if (field.isProtected())
             return true;
     }
@@ -354,9 +529,54 @@ bool AbstractMetaClass::hasProtectedMembers() const
     return hasProtectedFields() || hasProtectedFunctions();
 }
 
+const QVector<TypeEntry *> &AbstractMetaClass::templateArguments() const
+{
+    return d->m_templateArgs;
+}
+
+void AbstractMetaClass::setTemplateArguments(const QVector<TypeEntry *> &args)
+{
+    d->m_templateArgs = args;
+}
+
+const QStringList &AbstractMetaClass::baseClassNames() const
+{
+    return d->m_baseClassNames;
+}
+
+void AbstractMetaClass::setBaseClassNames(const QStringList &names)
+{
+    d->m_baseClassNames = names;
+}
+
+const ComplexTypeEntry *AbstractMetaClass::typeEntry() const
+{
+    return d->m_typeEntry;
+}
+
+ComplexTypeEntry *AbstractMetaClass::typeEntry()
+{
+    return d->m_typeEntry;
+}
+
+void AbstractMetaClass::setTypeEntry(ComplexTypeEntry *type)
+{
+    d->m_typeEntry = type;
+}
+
+void AbstractMetaClass::setHasHashFunction(bool on)
+{
+    d->m_hasHashFunction = on;
+}
+
+bool AbstractMetaClass::hasHashFunction() const
+{
+    return d->m_hasHashFunction;
+}
+
 QPropertySpec *AbstractMetaClass::propertySpecByName(const QString &name) const
 {
-    for (auto propertySpec : m_propertySpecs) {
+    for (auto propertySpec : d->m_propertySpecs) {
         if (name == propertySpec->name())
             return propertySpec;
     }
@@ -365,7 +585,7 @@ QPropertySpec *AbstractMetaClass::propertySpecByName(const QString &name) const
 
 QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const
 {
-    for (const auto &propertySpec : m_propertySpecs) {
+    for (const auto &propertySpec : d->m_propertySpecs) {
         if (name == propertySpec->read())
             return propertySpec;
     }
@@ -374,7 +594,7 @@ QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const
 
 QPropertySpec *AbstractMetaClass::propertySpecForWrite(const QString &name) const
 {
-    for (const auto &propertySpec : m_propertySpecs) {
+    for (const auto &propertySpec : d->m_propertySpecs) {
         if (name == propertySpec->write())
             return propertySpec;
     }
@@ -383,34 +603,86 @@ QPropertySpec *AbstractMetaClass::propertySpecForWrite(const QString &name) cons
 
 QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) const
 {
-    for (const auto &propertySpec : m_propertySpecs) {
+    for (const auto &propertySpec : d->m_propertySpecs) {
         if (name == propertySpec->reset())
             return propertySpec;
     }
     return nullptr;
 }
 
+AbstractMetaFunctionList AbstractMetaClass::externalConversionOperators() const
+{
+    return d->m_externalConversionOperators;
+}
+
+void AbstractMetaClass::addExternalConversionOperator(AbstractMetaFunction *conversionOp)
+{
+    if (!d->m_externalConversionOperators.contains(conversionOp))
+        d->m_externalConversionOperators.append(conversionOp);
+}
+
+bool AbstractMetaClass::hasExternalConversionOperators() const
+{
+    return !d->m_externalConversionOperators.isEmpty();
+}
+
 bool AbstractMetaClass::hasTemplateBaseClassInstantiations() const
 {
-    return m_templateBaseClass != nullptr && !m_baseTemplateInstantiations.isEmpty();
+    return d->m_templateBaseClass != nullptr && !d->m_baseTemplateInstantiations.isEmpty();
 }
 
 const AbstractMetaTypeList &AbstractMetaClass::templateBaseClassInstantiations() const
 {
-    return m_baseTemplateInstantiations;
+    return d->m_baseTemplateInstantiations;
 }
 
 void AbstractMetaClass::setTemplateBaseClassInstantiations(const AbstractMetaTypeList &instantiations)
 {
-    Q_ASSERT(m_templateBaseClass != nullptr);
-    m_baseTemplateInstantiations = instantiations;
+    Q_ASSERT(d->m_templateBaseClass != nullptr);
+    d->m_baseTemplateInstantiations = instantiations;
+}
+
+void AbstractMetaClass::setTypeDef(bool typeDef)
+{
+    d->m_isTypeDef = typeDef;
+}
+
+bool AbstractMetaClass::isTypeDef() const
+{
+    return d->m_isTypeDef;
+}
+
+bool AbstractMetaClass::isStream() const
+{
+    return d->m_stream;
+}
+
+void AbstractMetaClass::setStream(bool stream)
+{
+    d->m_stream = stream;
+}
+
+bool AbstractMetaClass::hasToStringCapability() const
+{
+    return d->m_hasToStringCapability;
+}
+
+void AbstractMetaClass::setToStringCapability(bool value, uint indirections)
+{
+    d->m_hasToStringCapability = value;
+    d->m_toStringCapabilityIndirections = indirections;
+}
+
+uint AbstractMetaClass::toStringCapabilityIndirections() const
+{
+    return d->m_toStringCapabilityIndirections;
 }
 
 // Does any of the base classes require deletion in the main thread?
 bool AbstractMetaClass::deleteInMainThread() const
 {
     return typeEntry()->deleteInMainThread()
-        || (!m_baseClasses.isEmpty() && m_baseClasses.constFirst()->deleteInMainThread());
+            || (!d->m_baseClasses.isEmpty() && d->m_baseClasses.constFirst()->deleteInMainThread());
 }
 
 static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func)
@@ -424,18 +696,23 @@ static bool functions_contains(const AbstractMetaFunctionList &l, const Abstract
 
 bool AbstractMetaClass::hasConstructors() const
 {
-    return AbstractMetaClass::queryFirstFunction(m_functions, Constructors) != nullptr;
+    return AbstractMetaClass::queryFirstFunction(d->m_functions, Constructors) != nullptr;
 }
 
 const AbstractMetaFunction *AbstractMetaClass::copyConstructor() const
 {
-    for (const AbstractMetaFunction *f : m_functions) {
+    for (const AbstractMetaFunction *f : d->m_functions) {
         if (f->functionType() == AbstractMetaFunction::CopyConstructorFunction)
             return f;
     }
     return nullptr;
 }
 
+bool AbstractMetaClass::hasCopyConstructor() const
+{
+    return copyConstructor() != nullptr;
+}
+
 bool AbstractMetaClass::hasPrivateCopyConstructor() const
 {
     const AbstractMetaFunction *copyCt = copyConstructor();
@@ -493,21 +770,71 @@ void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate)
     addFunction(f);
 }
 
+bool AbstractMetaClass::hasNonPrivateConstructor() const
+{
+    return d->m_hasNonPrivateConstructor;
+}
+
+void AbstractMetaClass::setHasNonPrivateConstructor(bool value)
+{
+    d->m_hasNonPrivateConstructor = value;
+}
+
+bool AbstractMetaClass::hasPrivateConstructor() const
+{
+    return d->m_hasPrivateConstructor;
+}
+
+void AbstractMetaClass::setHasPrivateConstructor(bool value)
+{
+    d->m_hasPrivateConstructor = value;
+}
+
+bool AbstractMetaClass::hasPrivateDestructor() const
+{
+    return d->m_hasPrivateDestructor;
+}
+
+void AbstractMetaClass::setHasPrivateDestructor(bool value)
+{
+    d->m_hasPrivateDestructor = value;
+}
+
+bool AbstractMetaClass::hasProtectedDestructor() const
+{
+    return d->m_hasProtectedDestructor;
+}
+
+void AbstractMetaClass::setHasProtectedDestructor(bool value)
+{
+    d->m_hasProtectedDestructor = value;
+}
+
+bool AbstractMetaClass::hasVirtualDestructor() const
+{
+    return d->m_hasVirtualDestructor;
+}
+
 void AbstractMetaClass::setHasVirtualDestructor(bool value)
 {
-    m_hasVirtualDestructor = value;
+    d->m_hasVirtualDestructor = value;
     if (value)
-        m_hasVirtuals = m_isPolymorphic = 1;
+        d->m_hasVirtuals = d->m_isPolymorphic = 1;
+}
+
+bool AbstractMetaClass::isConstructible() const
+{
+    return (hasNonPrivateConstructor() || !hasPrivateConstructor()) && !hasPrivateDestructor();
 }
 
 bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const
 {
-    return functions_contains(m_functions, f);
+    return functions_contains(d->m_functions, f);
 }
 
 bool AbstractMetaClass::generateExceptionHandling() const
 {
-    return queryFirstFunction(m_functions, AbstractMetaClass::Visible
+    return queryFirstFunction(d->m_functions, AbstractMetaClass::Visible
                               | AbstractMetaClass::GenerateExceptionHandling) != nullptr;
 }
 /* Goes through the list of functions and returns a list of all
@@ -619,12 +946,12 @@ const AbstractMetaFunction *AbstractMetaClass::queryFirstFunction(const Abstract
 
 AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const
 {
-    return AbstractMetaClass::queryFunctionList(m_functions, query);
+    return AbstractMetaClass::queryFunctionList(d->m_functions, query);
 }
 
 bool AbstractMetaClass::hasSignals() const
 {
-    return queryFirstFunction(m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr;
+    return queryFirstFunction(d->m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr;
 }
 
 AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
@@ -635,13 +962,33 @@ AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
 std::optional<AbstractMetaField>
     AbstractMetaClass::findField(const QString &name) const
 {
-    return AbstractMetaField::find(m_fields, name);
+    return AbstractMetaField::find(d->m_fields, name);
+}
+
+const AbstractMetaEnumList &AbstractMetaClass::enums() const
+{
+    return d->m_enums;
+}
+
+AbstractMetaEnumList &AbstractMetaClass::enums()
+{
+    return d->m_enums;
+}
+
+void AbstractMetaClass::setEnums(const AbstractMetaEnumList &enums)
+{
+    d->m_enums = enums;
+}
+
+void AbstractMetaClass::addEnum(const AbstractMetaEnum &e)
+{
+    d->m_enums << e;
 }
 
 std::optional<AbstractMetaEnum>
     AbstractMetaClass::findEnum(const QString &enumName) const
 {
-    for (const auto &e : m_enums) {
+    for (const auto &e : d->m_enums) {
         if (e.name() == enumName)
             return e;
     }
@@ -654,7 +1001,7 @@ std::optional<AbstractMetaEnum>
 std::optional<AbstractMetaEnumValue>
     AbstractMetaClass::findEnumValue(const QString &enumValueName) const
 {
-    for (const AbstractMetaEnum &e : qAsConst(m_enums)) {
+    for (const AbstractMetaEnum &e : qAsConst(d->m_enums)) {
         auto v = e.findEnumValue(enumValueName);
         if (v.has_value())
             return v;
@@ -667,7 +1014,7 @@ std::optional<AbstractMetaEnumValue>
 
 void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const
 {
-    for (const AbstractMetaEnum &metaEnum : m_enums) {
+    for (const AbstractMetaEnum &metaEnum : d->m_enums) {
         if (!metaEnum.isPrivate() && metaEnum.typeEntry()->generateCode())
             enumList->append(metaEnum);
     }
@@ -691,6 +1038,11 @@ void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(Abstrac
     }
 }
 
+QString AbstractMetaClass::fullName() const
+{
+    return package() + QLatin1Char('.') + name();
+}
+
 static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractMetaType &type)
 {
 
@@ -722,14 +1074,14 @@ static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, const Abst
 
 void AbstractMetaClass::fixFunctions()
 {
-    if (m_functionsFixed)
+    if (d->m_functionsFixed)
         return;
 
-    m_functionsFixed = true;
+    d->m_functionsFixed = true;
 
     AbstractMetaFunctionList funcs = functions();
 
-    for (auto superClass : m_baseClasses) {
+    for (auto superClass : d->m_baseClasses) {
         superClass->fixFunctions();
         // Since we always traverse the complete hierarchy we are only
         // interrested in what each super class implements, not what
@@ -1014,79 +1366,79 @@ AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &cla
 
 #ifndef QT_NO_DEBUG_STREAM
 
-void AbstractMetaClass::format(QDebug &d) const
+void AbstractMetaClass::format(QDebug &debug) const
 {
-    if (d.verbosity() > 2)
-        d << static_cast<const void *>(this) << ", ";
-    d << '"' << qualifiedCppName();
-    if (const int count = m_templateArgs.size()) {
+    if (debug.verbosity() > 2)
+        debug << static_cast<const void *>(this) << ", ";
+    debug << '"' << qualifiedCppName();
+    if (const int count = d->m_templateArgs.size()) {
         for (int i = 0; i < count; ++i)
-            d << (i ? ',' : '<') << m_templateArgs.at(i)->qualifiedCppName();
-        d << '>';
+            debug << (i ? ',' : '<') << d->m_templateArgs.at(i)->qualifiedCppName();
+        debug << '>';
     }
-    d << '"';
+    debug << '"';
     if (isNamespace())
-        d << " [namespace]";
+        debug << " [namespace]";
     if (attributes() & AbstractMetaAttributes::FinalCppClass)
-        d << " [final]";
+        debug << " [final]";
     if (attributes().testFlag(AbstractMetaAttributes::Deprecated))
-        d << " [deprecated]";
-    if (!m_baseClasses.isEmpty()) {
-        d << ", inherits ";
-        for (auto b : m_baseClasses)
-            d << " \"" << b->name() << '"';
+        debug << " [deprecated]";
+    if (!d->m_baseClasses.isEmpty()) {
+        debug << ", inherits ";
+        for (auto b : d->m_baseClasses)
+            debug << " \"" << b->name() << '"';
     }
     if (auto templateBase = templateBaseClass()) {
         const auto &instantiatedTypes = templateBaseClassInstantiations();
-        d << ", instantiates \"" << templateBase->name();
+        debug << ", instantiates \"" << templateBase->name();
         for (int i = 0, count = instantiatedTypes.size(); i < count; ++i)
-            d << (i ? ',' : '<') << instantiatedTypes.at(i).name();
-        d << ">\"";
+            debug << (i ? ',' : '<') << instantiatedTypes.at(i).name();
+        debug << ">\"";
     }
-    if (const int count = m_propertySpecs.size()) {
-        d << ", properties (" << count << "): [";
+    if (const int count = d->m_propertySpecs.size()) {
+        debug << ", properties (" << count << "): [";
         for (int i = 0; i < count; ++i) {
             if (i)
-                d << ", ";
-            m_propertySpecs.at(i)->formatDebug(d);
+                debug << ", ";
+            d->m_propertySpecs.at(i)->formatDebug(debug);
         }
-        d << ']';
+        debug << ']';
     }
 }
 
-void AbstractMetaClass::formatMembers(QDebug &d) const
+void AbstractMetaClass::formatMembers(QDebug &debug) const
 {
-    if (!m_enums.isEmpty())
-        d << ", enums[" << m_enums.size() << "]=" << m_enums;
-    if (!m_functions.isEmpty()) {
-        const int count = m_functions.size();
-        d << ", functions=[" << count << "](";
+    if (!d->m_enums.isEmpty())
+        debug << ", enums[" << d->m_enums.size() << "]=" << d->m_enums;
+    if (!d->m_functions.isEmpty()) {
+        const int count = d->m_functions.size();
+        debug << ", functions=[" << count << "](";
         for (int i = 0; i < count; ++i) {
             if (i)
-                d << ", ";
-            m_functions.at(i)->formatDebugBrief(d);
+                debug << ", ";
+            d->m_functions.at(i)->formatDebugBrief(debug);
         }
-        d << ')';
+        debug << ')';
     }
-    if (const int count = m_fields.size()) {
-        d << ", fields=[" << count << "](";
+    if (const int count = d->m_fields.size()) {
+        debug << ", fields=[" << count << "](";
         for (int i = 0; i < count; ++i) {
             if (i)
-                d << ", ";
-            m_fields.at(i).formatDebug(d);
+                debug << ", ";
+            d->m_fields.at(i).formatDebug(debug);
         }
-        d << ')';
+        debug << ')';
     }
 }
 
 SourceLocation AbstractMetaClass::sourceLocation() const
 {
-    return m_sourceLocation;
+    return d->m_sourceLocation;
 }
 
 void AbstractMetaClass::setSourceLocation(const SourceLocation &sourceLocation)
 {
-    m_sourceLocation = sourceLocation;
+    d->m_sourceLocation = sourceLocation;
 }
 
 QDebug operator<<(QDebug d, const AbstractMetaClass *ac)
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h
index 8de86ed2a..2087180cd 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h
@@ -31,27 +31,29 @@
 
 #include "abstractmetalang_typedefs.h"
 #include "abstractmetaattributes.h"
-#include "abstractmetaenum.h"
-#include "abstractmetafield.h"
 #include "enclosingclassmixin.h"
-#include "documentation.h"
-#include "sourcelocation.h"
 #include "typesystem_enums.h"
 #include "typesystem_typedefs.h"
 
 #include <QtCore/qobjectdefs.h>
+#include <QtCore/QScopedPointer>
 #include <QtCore/QStringList>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
-class QPropertySpec;
+class AbstractMetaClassPrivate;
 class ComplexTypeEntry;
+class Documentation;
 class EnumTypeEntry;
+class QPropertySpec;
+class SourceLocation;
 
 class AbstractMetaClass : public AbstractMetaAttributes, public EnclosingClassMixin
 {
     Q_GADGET
 public:
+    Q_DISABLE_COPY_MOVE(AbstractMetaClass)
+
     enum FunctionQueryOption {
         Constructors                 = 0x0000001, // Only constructors
         //Destructors                  = 0x0000002, // Only destructors. Not included in class.
@@ -97,8 +99,7 @@ public:
 
     void fixFunctions();
 
-    const AbstractMetaFunctionList &functions() const { return m_functions; }
-
+    const AbstractMetaFunctionList &functions() const;
     void setFunctions(const AbstractMetaFunctionList &functions);
     void addFunction(AbstractMetaFunction *function);
     bool hasFunction(const AbstractMetaFunction *f) const;
@@ -108,31 +109,28 @@ public:
 
     bool hasConstructors() const;
     const AbstractMetaFunction *copyConstructor() const;
-    bool hasCopyConstructor() const { return copyConstructor() != nullptr; }
+    bool hasCopyConstructor() const;
     bool hasPrivateCopyConstructor() const;
 
     void addDefaultConstructor();
     void addDefaultCopyConstructor(bool isPrivate = false);
 
-    bool hasNonPrivateConstructor() const { return m_hasNonPrivateConstructor; }
-    void setHasNonPrivateConstructor(bool value) { m_hasNonPrivateConstructor = value; }
+    bool hasNonPrivateConstructor() const;
+    void setHasNonPrivateConstructor(bool value);
 
-    bool hasPrivateConstructor() const { return m_hasPrivateConstructor; }
-    void setHasPrivateConstructor(bool value) { m_hasPrivateConstructor = value; }
+    bool hasPrivateConstructor() const;
+    void setHasPrivateConstructor(bool value);
 
-    bool hasPrivateDestructor() const { return m_hasPrivateDestructor; }
-    void setHasPrivateDestructor(bool value) { m_hasPrivateDestructor = value; }
+    bool hasPrivateDestructor() const;
+    void setHasPrivateDestructor(bool value);
 
-    bool hasProtectedDestructor() const { return m_hasProtectedDestructor; }
-    void setHasProtectedDestructor(bool value) { m_hasProtectedDestructor = value; }
+    bool hasProtectedDestructor() const;
+    void setHasProtectedDestructor(bool value);
 
-    bool hasVirtualDestructor() const { return m_hasVirtualDestructor; }
+    bool hasVirtualDestructor() const;
     void setHasVirtualDestructor(bool value);
 
-    bool isConstructible() const
-    {
-        return (hasNonPrivateConstructor() || !hasPrivateConstructor()) && !hasPrivateDestructor();
-    }
+    bool isConstructible() const;
 
     bool generateExceptionHandling() const;
 
@@ -163,17 +161,17 @@ public:
     bool hasComparisonOperatorOverload() const;
     bool hasLogicalOperatorOverload() const;
 
-    const AbstractMetaFieldList &fields() const { return m_fields; }
-    AbstractMetaFieldList &fields() { return m_fields; }
-    void setFields(const AbstractMetaFieldList &fields) { m_fields = fields; }
-    void addField(const AbstractMetaField &field) { m_fields << field; }
+    const AbstractMetaFieldList &fields() const;
+    AbstractMetaFieldList &fields();
+    void setFields(const AbstractMetaFieldList &fields);
+    void addField(const AbstractMetaField &field);
 
     std::optional<AbstractMetaField> findField(const QString &name) const;
 
-    const AbstractMetaEnumList &enums() const { return m_enums; }
-    AbstractMetaEnumList &enums() { return m_enums; }
-    void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; }
-    void addEnum(const AbstractMetaEnum &e) { m_enums << e; }
+    const AbstractMetaEnumList &enums() const;
+    AbstractMetaEnumList &enums();
+    void setEnums(const AbstractMetaEnumList &enums);
+    void addEnum(const AbstractMetaEnum &e);
 
     std::optional<AbstractMetaEnum> findEnum(const QString &enumName) const;
     std::optional<AbstractMetaEnumValue> findEnumValue(const QString &enumName) const;
@@ -182,10 +180,7 @@ public:
 
     void getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionList *funcList) const;
 
-    QString fullName() const
-    {
-        return package() + QLatin1Char('.') + name();
-    }
+    QString fullName() const;
 
     /**
      *   Retrieves the class name without any namespace/scope information.
@@ -193,19 +188,13 @@ public:
      */
     QString name() const;
 
-    const Documentation &documentation() const { return m_doc; }
-    void setDocumentation(const Documentation& doc) { m_doc = doc; }
+    const Documentation &documentation() const;
+    void setDocumentation(const Documentation& doc);
 
-    QString baseClassName() const
-    {
-        return m_baseClasses.isEmpty() ? QString() : m_baseClasses.constFirst()->name();
-    }
+    QString baseClassName() const;
 
-    AbstractMetaClass *baseClass() const
-    {
-        return m_baseClasses.value(0, nullptr);
-    }
-    const AbstractMetaClassList &baseClasses() const { return m_baseClasses; }
+    AbstractMetaClass *baseClass() const;
+    const AbstractMetaClassList &baseClasses() const;
 
     void addBaseClass(AbstractMetaClass *base_class);
     void setBaseClass(AbstractMetaClass *base_class);
@@ -213,12 +202,12 @@ public:
     /**
      *   \return the namespace from another package which this namespace extends.
      */
-    AbstractMetaClass *extendedNamespace() const { return m_extendedNamespace; }
-    void setExtendedNamespace(AbstractMetaClass *e) { m_extendedNamespace = e; }
+    AbstractMetaClass *extendedNamespace() const;
+    void setExtendedNamespace(AbstractMetaClass *e);
 
-    const AbstractMetaClassList& innerClasses() const { return m_innerClasses; }
-    void addInnerClass(AbstractMetaClass* cl) { m_innerClasses << cl; }
-    void setInnerClasses(const AbstractMetaClassList &innerClasses) { m_innerClasses = innerClasses; }
+    const AbstractMetaClassList &innerClasses() const;
+    void addInnerClass(AbstractMetaClass* cl);
+    void setInnerClasses(const AbstractMetaClassList &innerClasses);
 
     QString package() const;
 
@@ -227,10 +216,7 @@ public:
 
     bool isQObject() const;
 
-    bool isQtNamespace() const
-    {
-        return isNamespace() && name() == QLatin1String("Qt");
-    }
+    bool isQtNamespace() const;
 
     QString qualifiedCppName() const;
 
@@ -241,7 +227,7 @@ public:
     *   Says if the class that declares or inherits a virtual function.
     *   \return true if the class implements or inherits any virtual methods
     */
-    bool isPolymorphic() const { return m_isPolymorphic; }
+    bool isPolymorphic() const;
 
     /**
      * Tells if this class has one or more functions that are protected.
@@ -262,77 +248,64 @@ public:
     bool hasProtectedMembers() const;
 
 
-    const QVector<TypeEntry *> &templateArguments() const { return m_templateArgs; }
-    void setTemplateArguments(const QVector<TypeEntry *> &args) { m_templateArgs = args; }
+    const QVector<TypeEntry *> &templateArguments() const;
+    void setTemplateArguments(const QVector<TypeEntry *> &args);
 
     // only valid during metabuilder's run
-    const QStringList &baseClassNames() const { return m_baseClassNames; }
-    void setBaseClassNames(const QStringList &names) { m_baseClassNames = names; }
+    const QStringList &baseClassNames() const;
+    void setBaseClassNames(const QStringList &names);
 
-    const ComplexTypeEntry *typeEntry() const { return m_typeEntry; }
-    ComplexTypeEntry *typeEntry() { return m_typeEntry; }
-    void setTypeEntry(ComplexTypeEntry *type) { m_typeEntry = type; }
+    const ComplexTypeEntry *typeEntry() const;
+    ComplexTypeEntry *typeEntry();
+    void setTypeEntry(ComplexTypeEntry *type);
 
-    void setHasHashFunction(bool on) { m_hasHashFunction = on; }
+    void setHasHashFunction(bool on);
 
-    bool hasHashFunction() const { return m_hasHashFunction; }
+    bool hasHashFunction() const;
 
     bool hasDefaultToStringFunction() const;
 
-    bool hasEqualsOperator() const { return m_hasEqualsOperator; }
-    void setHasEqualsOperator(bool on) { m_hasEqualsOperator = on; }
+    bool hasEqualsOperator() const;
+    void setHasEqualsOperator(bool on);
 
-    bool hasCloneOperator() const { return m_hasCloneOperator; }
-    void setHasCloneOperator(bool on) { m_hasCloneOperator = on; }
+    bool hasCloneOperator() const;
+    void setHasCloneOperator(bool on);
 
-    const QVector<QPropertySpec *> &propertySpecs() const { return m_propertySpecs; }
-    void addPropertySpec(QPropertySpec *spec) { m_propertySpecs << spec; }
+    const QVector<QPropertySpec *> &propertySpecs() const;
+    void addPropertySpec(QPropertySpec *spec);
 
     QPropertySpec *propertySpecByName(const QString &name) const;
     QPropertySpec *propertySpecForRead(const QString &name) const;
     QPropertySpec *propertySpecForWrite(const QString &name) const;
     QPropertySpec *propertySpecForReset(const QString &name) const;
 
-    /// Returns a list of conversion operators for this class. The conversion operators are defined in other classes of the same module.
-    AbstractMetaFunctionList externalConversionOperators() const
-    {
-        return m_externalConversionOperators;
-    }
+    /// Returns a list of conversion operators for this class. The conversion
+    /// operators are defined in other classes of the same module.
+    AbstractMetaFunctionList externalConversionOperators() const;
     /// Adds a converter operator for this class.
-    void addExternalConversionOperator(AbstractMetaFunction* conversionOp)
-    {
-        if (!m_externalConversionOperators.contains(conversionOp))
-            m_externalConversionOperators.append(conversionOp);
-    }
+    void addExternalConversionOperator(AbstractMetaFunction* conversionOp);
     /// Returns true if this class has any converter operators defined elsewhere.
-    bool hasExternalConversionOperators() const
-    {
-        return !m_externalConversionOperators.isEmpty();
-    }
+    bool hasExternalConversionOperators() const;
 
     void sortFunctions();
 
-    const AbstractMetaClass *templateBaseClass() const { return m_templateBaseClass; }
-    void setTemplateBaseClass(const AbstractMetaClass *cls) { m_templateBaseClass = cls; }
+    const AbstractMetaClass *templateBaseClass() const;
+    void setTemplateBaseClass(const AbstractMetaClass *cls);
 
     bool hasTemplateBaseClassInstantiations() const;
     const AbstractMetaTypeList &templateBaseClassInstantiations() const;
     void setTemplateBaseClassInstantiations(const AbstractMetaTypeList& instantiations);
 
-    void setTypeDef(bool typeDef) { m_isTypeDef = typeDef; }
-    bool isTypeDef() const { return m_isTypeDef; }
+    void setTypeDef(bool typeDef);
+    bool isTypeDef() const;
 
-    bool isStream() const { return m_stream; }
-    void setStream(bool stream) { m_stream = stream; }
+    bool isStream() const;
+    void setStream(bool stream);
 
-    bool hasToStringCapability() const { return m_hasToStringCapability; }
-    void setToStringCapability(bool value, uint indirections = 0)
-    {
-        m_hasToStringCapability = value;
-        m_toStringCapabilityIndirections = indirections;
-    }
+    bool hasToStringCapability() const;
+    void setToStringCapability(bool value, uint indirections = 0);
 
-    uint toStringCapabilityIndirections() const { return m_toStringCapabilityIndirections; }
+    uint toStringCapabilityIndirections() const;
 
     bool deleteInMainThread() const;
 
@@ -357,45 +330,8 @@ private:
     void formatMembers(QDebug &d) const;
     friend QDebug operator<<(QDebug d, const AbstractMetaClass *ac);
 #endif
-    uint m_hasVirtuals : 1;
-    uint m_isPolymorphic : 1;
-    uint m_hasNonpublic : 1;
-    uint m_hasNonPrivateConstructor : 1;
-    uint m_hasPrivateConstructor : 1;
-    uint m_functionsFixed : 1;
-    uint m_hasPrivateDestructor : 1;
-    uint m_hasProtectedDestructor : 1;
-    uint m_hasVirtualDestructor : 1;
-    uint m_hasHashFunction : 1;
-    uint m_hasEqualsOperator : 1;
-    uint m_hasCloneOperator : 1;
-    uint m_isTypeDef : 1;
-    uint m_hasToStringCapability : 1;
-
-    Documentation m_doc;
-
-    const AbstractMetaClass *m_enclosingClass = nullptr;
-    AbstractMetaClassList m_baseClasses; // Real base classes after setting up inheritance
-    AbstractMetaTypeList m_baseTemplateInstantiations;
-    AbstractMetaClass *m_extendedNamespace = nullptr;
-
-    const AbstractMetaClass *m_templateBaseClass = nullptr;
-    AbstractMetaFunctionList m_functions;
-    AbstractMetaFieldList m_fields;
-    AbstractMetaEnumList m_enums;
-    QVector<QPropertySpec *> m_propertySpecs;
-    AbstractMetaClassList m_innerClasses;
-
-    AbstractMetaFunctionList m_externalConversionOperators;
-
-    QStringList m_baseClassNames;  // Base class names from C++, including rejected
-    QVector<TypeEntry *> m_templateArgs;
-    ComplexTypeEntry *m_typeEntry = nullptr;
-    SourceLocation m_sourceLocation;
-//     FunctionModelItem m_qDebugStreamFunction;
-
-    bool m_stream = false;
-    uint m_toStringCapabilityIndirections = 0;
+
+    QScopedPointer<AbstractMetaClassPrivate> d;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::FunctionQueryOptions)
@@ -404,7 +340,7 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::OperatorQueryOptions)
 template <class Function>
 void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const
 {
-    for (auto ic : m_innerClasses) {
+    for (auto ic : innerClasses()) {
         if (ic->isInvisibleNamespace()) {
             f(ic);
             ic->invisibleNamespaceRecursion(f);
diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp
index a6bdd3edb..dba0d23da 100644
--- a/sources/shiboken6/ApiExtractor/apiextractor.cpp
+++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp
@@ -40,6 +40,7 @@
 #include "typesystem.h"
 #include "fileout.h"
 #include "abstractmetabuilder.h"
+#include "abstractmetaenum.h"
 #include "typedatabase.h"
 #include "typesystem.h"
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
index 59c062f8c..a88c8554a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -33,6 +33,7 @@
 #include <QtTest/QTest>
 #include "testutil.h"
 #include <abstractmetalang.h>
+#include <documentation.h>
 #include <modifications.h>
 #include <typesystem.h>
 #include <qtdocparser.h>
diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
index 8bd830d14..7f0addd6b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
@@ -30,6 +30,7 @@
 #include <QtTest/QTest>
 #include "testutil.h"
 #include <abstractmetalang.h>
+#include <abstractmetaenum.h>
 #include <typesystem.h>
 
 void NamespaceTest::testNamespaceMembers()
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
index 70f6c7c26..2b91c14f3 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h
@@ -33,7 +33,7 @@
 #include <QtCore/QScopedPointer>
 #include <QtCore/QTextStream>
 #include <QXmlStreamReader>
-#include "abstractmetalang.h"
+#include "documentation.h"
 #include "generator.h"
 #include "docparser.h"
 #include "typesystem_enums.h"