shiboken6: Extract common C++ function attributes

Extract attributes common to C++ functions from
AbstractMetaFunction's attributes to a flags type in
codemodel_enums.h for re-use in AbstractMetaFunction,
FunctionModelItem and AddedFunction.

A lot of boolean setters and getters can then be removed and
the flags easily transferred from code model to the meta
language code.

Task-number: PYSIDE-2602
Change-Id: I9da1bb0d70051cd6bb3113290e8ccedfe4d13908
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>
(cherry picked from commit 8d5b1bdf238cda67a50e489a77de1f4f6996b3b2)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

12 files changed, 96 insertions, 153 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 4b75c78ce..d2c2ffcbe 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -1410,7 +1410,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(const ScopeModelItem& scopeIt
 
     for (AbstractMetaFunction *metaFunction : functions) {
         if (metaClass->isNamespace())
-            *metaFunction += AbstractMetaFunction::Static;
+            metaFunction->setCppAttribute(FunctionAttribute::Static);
 
         const auto propertyFunction = metaClass->searchPropertyFunction(metaFunction->name());
         if (propertyFunction.index >= 0) {
@@ -1781,7 +1781,7 @@ bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunction
 
     const AbstractMetaArgumentList fargs = metaFunction->arguments();
     if (metaClass->isNamespace())
-        *metaFunction += AbstractMetaFunction::Static;
+        metaFunction->setCppAttribute(FunctionAttribute::Static);
     if (metaFunction->name() == metaClass->name()) {
         metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction);
         if (fargs.size() == 1) {
@@ -2046,7 +2046,8 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
     if (functionItem->isFriend())
         return nullptr;
 
-    const bool deprecated = functionItem->isDeprecated();
+    const auto cppAttributes = functionItem->attributes();
+    const bool deprecated = cppAttributes.testFlag(FunctionAttribute::Deprecated);
     if (deprecated && m_skipDeprecated) {
         rejectFunction(functionItem, currentClass,
                        AbstractMetaBuilder::GenerationDisabled, u" is deprecated."_s);
@@ -2055,6 +2056,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
 
     AbstractMetaFunction::Flags flags;
     auto *metaFunction = new AbstractMetaFunction(functionName);
+    metaFunction->setCppAttributes(cppAttributes);
     const QByteArray cSignature = signature.toUtf8();
     const QString unresolvedSignature =
         QString::fromUtf8(QMetaObject::normalizedSignature(cSignature.constData()));
@@ -2062,28 +2064,12 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
     if (functionItem->isHiddenFriend())
         flags.setFlag(AbstractMetaFunction::Flag::HiddenFriend);
     metaFunction->setSourceLocation(functionItem->sourceLocation());
-    if (deprecated)
-        *metaFunction += AbstractMetaFunction::Deprecated;
 
     // Additional check for assignment/move assignment down below
     metaFunction->setFunctionType(functionTypeFromCodeModel(functionItem->functionType()));
     metaFunction->setConstant(functionItem->isConstant());
     metaFunction->setExceptionSpecification(functionItem->exceptionSpecification());
 
-    if (functionItem->isAbstract())
-        *metaFunction += AbstractMetaFunction::Abstract;
-
-    if (functionItem->isVirtual()) {
-        *metaFunction += AbstractMetaFunction::VirtualCppMethod;
-        if (functionItem->isOverride())
-            *metaFunction += AbstractMetaFunction::OverriddenCppMethod;
-        if (functionItem->isFinal())
-            *metaFunction += AbstractMetaFunction::FinalCppMethod;
-    }
-
-    if (functionItem->isStatic())
-        *metaFunction += AbstractMetaFunction::Static;
-
     // Access rights
     metaFunction->setAccess(functionItem->accessPolicy());
 
@@ -2093,7 +2079,6 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
          metaFunction->setType(AbstractMetaType::createVoid());
         break;
     case AbstractMetaFunction::ConstructorFunction:
-        metaFunction->setExplicit(functionItem->isExplicit());
         metaFunction->setName(currentClass->name());
         metaFunction->setType(AbstractMetaType::createVoid());
         break;
@@ -2162,7 +2147,8 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
             // If an invalid argument has a default value, simply remove it
             // unless the function is virtual (since the override in the
             // wrapper can then not correctly be generated).
-            if (arg->defaultValue() && !functionItem->isVirtual()) {
+            if (arg->defaultValue()
+                && !functionItem->attributes().testFlag(FunctionAttribute::Virtual)) {
                 if (!currentClass || currentClass->typeEntry()->generateCode()) {
                     const QString signature = qualifiedFunctionSignatureWithType(functionItem, className);
                     qCWarning(lcShiboken, "%s",
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
index ed939569e..f8faba103 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
@@ -48,7 +48,6 @@ public:
     AbstractMetaFunctionPrivate()
         : m_constant(false),
           m_reverse(false),
-          m_explicit(false),
           m_pointerOperator(false),
           m_isCallOperator(false)
     {
@@ -87,10 +86,10 @@ public:
     AddedFunctionPtr m_addedFunction;
     SourceLocation m_sourceLocation;
     AbstractMetaFunction::Attributes m_attributes;
+    FunctionAttributes m_cppAttributes;
     AbstractMetaFunction::Flags m_flags;
     uint m_constant                 : 1;
     uint m_reverse                  : 1;
-    uint m_explicit                 : 1;
     uint m_pointerOperator          : 1;
     uint m_isCallOperator           : 1;
     mutable int m_cachedOverloadNumber = TypeSystem::OverloadNumberUnset;
@@ -122,7 +121,7 @@ AbstractMetaFunction::AbstractMetaFunction(const AddedFunctionPtr &addedFunc) :
     }
     AbstractMetaFunction::Attributes atts;
     if (addedFunc->isStatic())
-        atts |= AbstractMetaFunction::Static;
+        setCppAttribute(FunctionAttribute::Static);
     if (addedFunc->isClassMethod())
         atts |= AbstractMetaFunction::ClassMethod;
     setAttributes(atts);
@@ -215,12 +214,12 @@ void AbstractMetaFunction::setPointerOperator(bool value)
 
 bool AbstractMetaFunction::isExplicit() const
 {
-    return d->m_explicit;
+    return d->m_cppAttributes.testFlag(FunctionAttribute::Explicit);
 }
 
 void AbstractMetaFunction::setExplicit(bool isExplicit)
 {
-    d->m_explicit = isExplicit;
+    d->m_cppAttributes.setFlag(FunctionAttribute::Explicit, isExplicit);
 }
 
 bool AbstractMetaFunction::returnsBool() const
@@ -262,6 +261,21 @@ void AbstractMetaFunction::operator-=(AbstractMetaFunction::Attribute attribute)
     d->m_attributes.setFlag(attribute, false);
 }
 
+FunctionAttributes AbstractMetaFunction::cppAttributes() const
+{
+    return d->m_cppAttributes;
+}
+
+void AbstractMetaFunction::setCppAttributes(FunctionAttributes a)
+{
+    d->m_cppAttributes = a;
+}
+
+void AbstractMetaFunction::setCppAttribute(FunctionAttribute a, bool on)
+{
+    d->m_cppAttributes.setFlag(a, on);
+}
+
 AbstractMetaFunction::Flags AbstractMetaFunction::flags() const
 {
     return d->m_flags;
@@ -342,7 +356,7 @@ AbstractMetaFunction::CompareResult AbstractMetaFunction::compareTo(const Abstra
         result |= EqualImplementor;
 
     // Attributes
-    if (attributes() == other->attributes())
+    if (attributes() == other->attributes() && cppAttributes() == other->cppAttributes())
         result |= EqualAttributes;
 
     // Compare types
@@ -427,6 +441,10 @@ AbstractMetaFunction *AbstractMetaFunction::copy() const
 {
     auto *cpy = new AbstractMetaFunction;
     cpy->setAttributes(attributes());
+    auto ca = cppAttributes();
+    // Historical bug: explicit was not copied! (causing nontypetemplate_test.py fail)
+    ca.setFlag(FunctionAttribute::Explicit, false);
+    cpy->setCppAttributes(ca);
     cpy->setFlags(flags());
     cpy->setAccess(access());
     cpy->setName(name());
@@ -729,7 +747,8 @@ static bool modifiedUndeprecated(const FunctionModification &mod)
 bool AbstractMetaFunction::isDeprecated() const
 {
     const auto &mods = modifications(declaringClass());
-    return d->m_attributes.testFlag(Attribute::Deprecated)
+
+    return d->m_cppAttributes.testFlag(FunctionAttribute::Deprecated)
            ? std::none_of(mods.cbegin(), mods.cend(), modifiedUndeprecated)
            : std::any_of(mods.cbegin(), mods.cend(), modifiedDeprecated);
 }
@@ -1020,9 +1039,10 @@ QString AbstractMetaFunction::signatureComment() const
 QString AbstractMetaFunction::debugSignature() const
 {
     QString result;
-    const bool isOverride = attributes() & AbstractMetaFunction::OverriddenCppMethod;
-    const bool isFinal = attributes() & AbstractMetaFunction::FinalCppMethod;
-    if (!isOverride && !isFinal && (attributes() & AbstractMetaFunction::VirtualCppMethod))
+    const auto attributes = cppAttributes();
+    const bool isOverride = attributes.testFlag(FunctionAttribute::Override);
+    const bool isFinal = attributes.testFlag(FunctionAttribute::Final);
+    if (!isOverride && !isFinal && (attributes.testFlag(FunctionAttribute::Virtual)))
         result += u"virtual "_s;
     if (d->m_implementingClass)
         result += d->m_implementingClass->qualifiedCppName() + u"::"_s;
@@ -1386,7 +1406,7 @@ bool AbstractMetaFunction::isInplaceOperator() const
 
 bool AbstractMetaFunction::isVirtual() const
 {
-    return d->m_attributes.testFlag(AbstractMetaFunction::VirtualCppMethod);
+    return d->m_cppAttributes.testFlag(FunctionAttribute::Virtual);
 }
 
 QString AbstractMetaFunctionPrivate::modifiedName(const AbstractMetaFunction *q) const
@@ -1644,9 +1664,9 @@ void AbstractMetaFunction::formatDebugVerbose(QDebug &debug) const
         debug << " [userAdded]";
     if (isUserDeclared())
         debug << " [userDeclared]";
-    if (d->m_explicit)
+    if (d->m_cppAttributes.testFlag(FunctionAttribute::Explicit))
         debug << " [explicit]";
-    if (attributes().testFlag(AbstractMetaFunction::Deprecated))
+    if (d->m_cppAttributes.testFlag(FunctionAttribute::Deprecated))
         debug << " [deprecated]";
     if (d->m_pointerOperator)
         debug << " [operator->]";
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
index 334afe0e2..bdf5127d1 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
@@ -92,8 +92,6 @@ public:
     enum Attribute {
         None                        = 0x00000000,
 
-        Abstract                    = 0x00000002,
-        Static                      = 0x00000004,
         ClassMethod                 = 0x00000008,
 
         GetterFunction              = 0x00000020,
@@ -104,12 +102,8 @@ public:
         PropertyResetter            = 0x00000400,
         PropertyNotify              = 0x00000800,
 
-        VirtualCppMethod            = 0x00010000,
-        OverriddenCppMethod         = 0x00020000,
-        FinalCppMethod              = 0x00040000,
         // Add by meta builder (implicit constructors, inherited methods, etc)
         AddedMethod                 = 0x001000000,
-        Deprecated                  = 0x002000000 // Code annotation
     };
     Q_DECLARE_FLAGS(Attributes, Attribute)
     Q_FLAG(Attribute)
@@ -120,6 +114,10 @@ public:
     void operator+=(Attribute attribute);
     void operator-=(Attribute attribute);
 
+    FunctionAttributes cppAttributes() const;
+    void setCppAttributes(FunctionAttributes a);
+    void setCppAttribute(FunctionAttribute a, bool on = true);
+
     enum class Flag { // Internal flags not relevant for comparing functions
         // Binary operator whose leading/trailing argument was removed by metabuilder
         OperatorLeadingClassArgumentRemoved = 0x1,
@@ -447,12 +445,12 @@ private:
 
 inline bool AbstractMetaFunction::isAbstract() const
 {
-    return attributes().testFlag(Abstract);
+    return cppAttributes().testFlag(FunctionAttribute::Abstract);
 }
 
 inline bool AbstractMetaFunction::isStatic() const
 {
-    return attributes().testFlag(Static);
+    return cppAttributes().testFlag(FunctionAttribute::Static);
 }
 
 inline bool AbstractMetaFunction::isClassMethod() const
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index 17bc9cd81..7cc036cbc 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -1492,11 +1492,11 @@ void AbstractMetaClass::fixFunctions(const AbstractMetaClassPtr &klass)
                     if (cmp & AbstractMetaFunction::EqualArguments) {
                         // Set "override" in case it was not spelled out (since it
                         // is then not detected by clang parsing).
-                        const auto attributes = cf->attributes();
-                        if (cf->isVirtual()
-                            && !attributes.testFlag(AbstractMetaFunction::OverriddenCppMethod)
-                            && !attributes.testFlag(AbstractMetaFunction::FinalCppMethod)) {
-                            *f += AbstractMetaFunction::OverriddenCppMethod;
+                        const auto attributes = cf->cppAttributes();
+                        if (attributes.testFlag(FunctionAttribute::Virtual)
+                            && !attributes.testFlag(FunctionAttribute::Override)
+                            && !attributes.testFlag(FunctionAttribute::Final)) {
+                            f->setCppAttribute(FunctionAttribute::Override);
                         }
 
                         if (f->access() != sf->access()) {
diff --git a/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp b/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp
index 47ac2e962..31e7efb05 100644
--- a/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp
@@ -346,7 +346,7 @@ FunctionModelItem BuilderPrivate::createFunction(const CXCursor &cursor,
     case CXAvailability_Available:
         break;
     case CXAvailability_Deprecated:
-        result->setDeprecated(true);
+        result->setAttribute(FunctionAttribute::Deprecated);
         break;
     case CXAvailability_NotAvailable: // "Foo(const Foo&) = delete;"
         result->setDeleted(true);
@@ -389,9 +389,9 @@ FunctionModelItem BuilderPrivate::createMemberFunction(const CXCursor &cursor,
     auto result = createFunction(cursor, functionType, isTemplateCode);
     result->setAccessPolicy(accessPolicy(clang_getCXXAccessSpecifier(cursor)));
     result->setConstant(clang_CXXMethod_isConst(cursor) != 0);
-    result->setStatic(clang_CXXMethod_isStatic(cursor) != 0);
-    result->setVirtual(clang_CXXMethod_isVirtual(cursor) != 0);
-    result->setAbstract(clang_CXXMethod_isPureVirtual(cursor) != 0);
+    result->setAttribute(FunctionAttribute::Static, clang_CXXMethod_isStatic(cursor) != 0);
+    result->setAttribute(FunctionAttribute::Virtual, clang_CXXMethod_isVirtual(cursor) != 0);
+    result->setAttribute(FunctionAttribute::Abstract, clang_CXXMethod_isPureVirtual(cursor) != 0);
     return result;
 }
 
@@ -407,7 +407,8 @@ void BuilderPrivate::qualifyConstructor(const CXCursor &cursor)
         && m_currentFunction->arguments().size() == 1
         && clang_CXXConstructor_isCopyConstructor(cursor) == 0
         && clang_CXXConstructor_isMoveConstructor(cursor) == 0) {
-        m_currentFunction->setExplicit(clang_CXXConstructor_isConvertingConstructor(cursor) == 0);
+        m_currentFunction->setAttribute(FunctionAttribute::Explicit,
+                                        clang_CXXConstructor_isConvertingConstructor(cursor) == 0);
     }
 }
 
@@ -1182,13 +1183,13 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
         break;
     case CXCursor_CXXFinalAttr:
          if (d->m_currentFunction)
-             d->m_currentFunction->setFinal(true);
+            d->m_currentFunction->setAttribute(FunctionAttribute::Final);
          else if (d->m_currentClass)
              d->m_currentClass->setFinal(true);
         break;
     case CXCursor_CXXOverrideAttr:
         if (d->m_currentFunction)
-            d->m_currentFunction->setOverride(true);
+            d->m_currentFunction->setAttribute(FunctionAttribute::Override);
         break;
     case CXCursor_StaticAssert:
         // Check for Q_PROPERTY() (see PySide6/global.h.in for an explanation
diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp
index 6bd82eaa7..f9f46f520 100644
--- a/sources/shiboken6/ApiExtractor/messages.cpp
+++ b/sources/shiboken6/ApiExtractor/messages.cpp
@@ -319,10 +319,11 @@ QString msgSkippingFunction(const FunctionModelItem &functionItem,
     QTextStream str(&result);
     str << functionItem->sourceLocation() << "skipping "
         << functionItem->accessPolicy() << ' ';
-    if (functionItem->isAbstract())
+    const bool isAbstract = functionItem->attributes().testFlag(FunctionAttribute::Abstract);
+    if (isAbstract)
         str << "abstract ";
     str << "function '" << signature << "', " << why;
-    if (functionItem->isAbstract()) {
+    if (isAbstract) {
         str << "\nThis will lead to compilation errors due to not "
                "being able to instantiate the wrapper.";
     }
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel.cpp b/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
index abee048de..259a706dc 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
@@ -1002,66 +1002,16 @@ void _FunctionModelItem::setDeleted(bool d)
     m_isDeleted = d;
 }
 
-bool _FunctionModelItem::isDeprecated() const
-{
-    return m_isDeprecated;
-}
-
-void _FunctionModelItem::setDeprecated(bool d)
-{
-    m_isDeprecated = d;
-}
-
-bool _FunctionModelItem::isVirtual() const
-{
-    return m_isVirtual;
-}
-
-void _FunctionModelItem::setVirtual(bool isVirtual)
-{
-    m_isVirtual = isVirtual;
-}
-
 bool _FunctionModelItem::isInline() const
 {
     return m_isInline;
 }
 
-bool _FunctionModelItem::isOverride() const
-{
-    return m_isOverride;
-}
-
-void _FunctionModelItem::setOverride(bool o)
-{
-    m_isOverride = o;
-}
-
-bool _FunctionModelItem::isFinal() const
-{
-    return m_isFinal;
-}
-
-void _FunctionModelItem::setFinal(bool f)
-{
-    m_isFinal = f;
-}
-
 void _FunctionModelItem::setInline(bool isInline)
 {
     m_isInline = isInline;
 }
 
-bool _FunctionModelItem::isExplicit() const
-{
-    return m_isExplicit;
-}
-
-void _FunctionModelItem::setExplicit(bool isExplicit)
-{
-    m_isExplicit = isExplicit;
-}
-
 bool _FunctionModelItem::isHiddenFriend() const
 {
     return m_isHiddenFriend;
@@ -1072,16 +1022,6 @@ void _FunctionModelItem::setHiddenFriend(bool f)
     m_isHiddenFriend = f;
 }
 
-bool _FunctionModelItem::isAbstract() const
-{
-    return m_isAbstract;
-}
-
-void _FunctionModelItem::setAbstract(bool isAbstract)
-{
-    m_isAbstract = isAbstract;
-}
-
 QString _FunctionModelItem::typeSystemSignature() const  // For dumping out type system files
 {
     QString result;
@@ -1206,17 +1146,17 @@ void _FunctionModelItem::formatDebug(QDebug &d) const
         d << " [deleted!]";
     if (m_isInline)
         d << " [inline]";
-    if (m_isVirtual)
+    if (m_attributes.testFlag(FunctionAttribute::Virtual))
         d << " [virtual]";
-    if (m_isOverride)
+    if (m_attributes.testFlag(FunctionAttribute::Override))
         d << " [override]";
-    if (m_isDeprecated)
+    if (m_attributes.testFlag(FunctionAttribute::Deprecated))
         d << " [deprecated]";
-    if (m_isFinal)
+    if (m_attributes.testFlag(FunctionAttribute::Final))
         d << " [final]";
-    if (m_isAbstract)
+    if (m_attributes.testFlag(FunctionAttribute::Abstract))
         d << " [abstract]";
-    if (m_isExplicit)
+    if (m_attributes.testFlag(FunctionAttribute::Explicit))
         d << " [explicit]";
     if (m_isInvokable)
         d << " [invokable]";
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel.h b/sources/shiboken6/ApiExtractor/parser/codemodel.h
index 435e57913..b31c09163 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel.h
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel.h
@@ -485,33 +485,19 @@ public:
 
     static std::optional<CodeModel::FunctionType> functionTypeFromName(QStringView name);
 
+    FunctionAttributes attributes() const { return m_attributes; }
+    void setAttributes(FunctionAttributes a) { m_attributes = a; }
+    void setAttribute(FunctionAttribute a, bool on = true) { m_attributes.setFlag(a, on); }
+
     bool isDeleted() const;
     void setDeleted(bool d);
 
-    bool isDeprecated() const;
-    void setDeprecated(bool d);
-
-    bool isVirtual() const;
-    void setVirtual(bool isVirtual);
-
-    bool isOverride() const;
-    void setOverride(bool o);
-
-    bool isFinal() const;
-    void setFinal(bool f);
-
     bool isInline() const;
     void setInline(bool isInline);
 
-    bool isExplicit() const;
-    void setExplicit(bool isExplicit);
-
     bool isHiddenFriend() const;
     void setHiddenFriend(bool f);
 
-    bool isAbstract() const;
-    void setAbstract(bool isAbstract);
-
     bool isVariadics() const;
     void setVariadics(bool isVariadics);
 
@@ -543,17 +529,12 @@ private:
     CodeModel::FunctionType _determineTypeHelper() const;
 
     ArgumentList m_arguments;
+    FunctionAttributes m_attributes;
     CodeModel::FunctionType m_functionType = CodeModel::Normal;
     union {
         struct {
             uint m_isDeleted: 1;
-            uint m_isVirtual: 1;
-            uint m_isOverride: 1;
-            uint m_isFinal: 1;
-            uint m_isDeprecated: 1;
             uint m_isInline: 1;
-            uint m_isAbstract: 1;
-            uint m_isExplicit: 1;
             uint m_isVariadics: 1;
             uint m_isHiddenFriend: 1;
             uint m_isInvokable : 1; // Qt
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h b/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h
index 1a058bdfe..e5c429bd0 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel_enums.h
@@ -4,6 +4,8 @@
 #ifndef CODEMODEL_ENUMS_H
 #define CODEMODEL_ENUMS_H
 
+#include <QtCore/qflags.h>
+
 enum ReferenceType {
     NoReference,
     LValueReference,
@@ -43,4 +45,17 @@ enum class Access
     Public
 };
 
+enum class FunctionAttribute {
+    Abstract   = 0x00000001,
+    Static     = 0x00000002,
+    Virtual    = 0x00000004,
+    Override   = 0x00000008,
+    Final      = 0x00000010,
+    Deprecated = 0x00000020, // Code annotation
+    Explicit   = 0x00000040, // Constructor
+};
+
+Q_DECLARE_FLAGS(FunctionAttributes, FunctionAttribute)
+Q_DECLARE_OPERATORS_FOR_FLAGS(FunctionAttributes)
+
 #endif // CODEMODEL_ENUMS_H
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
index ddfee1f0f..4b5da0c3a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -159,11 +159,11 @@ public:
     const auto funcF = virtualFunctionsF.constFirst();
 
     QCOMPARE(funcA->ownerClass(), a);
-    QVERIFY(funcC->attributes().testFlag(AbstractMetaFunction::VirtualCppMethod));
+    QVERIFY(funcC->isVirtual());
     QCOMPARE(funcB->ownerClass(), b);
     QCOMPARE(funcC->ownerClass(), c);
-    QVERIFY(funcC->attributes().testFlag(AbstractMetaFunction::OverriddenCppMethod));
-    QVERIFY(funcF->attributes().testFlag(AbstractMetaFunction::FinalCppMethod));
+    QVERIFY(funcC->cppAttributes().testFlag(FunctionAttribute::Override));
+    QVERIFY(funcF->cppAttributes().testFlag(FunctionAttribute::Final));
 
     QCOMPARE(funcA->declaringClass(), a);
     QCOMPARE(funcB->declaringClass(), a);
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index 9f1915e96..1103cef29 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -889,7 +889,7 @@ void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaFunctionCPtr
         Indentation indentation(s);
         if (!indexed)
             s << "\n:noindex:";
-        if (func->attributes().testFlag(AbstractMetaFunction::Attribute::FinalCppMethod))
+        if (func->cppAttributes().testFlag(FunctionAttribute::Final))
             s << "\n:final:";
         else if (func->isAbstract())
             s << "\n:abstractmethod:";
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 680f9fc53..ac098f394 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -276,7 +276,7 @@ ShibokenGenerator::FunctionGeneration ShibokenGenerator::functionGeneration(
     // Check on virtuals (including operators).
     const bool isAbstract = func->isAbstract();
     if (!(isAbstract || func->isVirtual())
-        || func->attributes().testFlag(AbstractMetaFunction::FinalCppMethod)
+        || func->cppAttributes().testFlag(FunctionAttribute::Final)
         || func->isModifiedFinal()) {
         return result;
     }
@@ -2255,8 +2255,9 @@ ShibokenGenerator::filterGroupedOperatorFunctions(const AbstractMetaClassCPtr &m
 
 static bool hidesBaseClassFunctions(const AbstractMetaFunctionCPtr &f)
 {
-    return 0 == (f->attributes()
-                 & (AbstractMetaFunction::OverriddenCppMethod | AbstractMetaFunction::FinalCppMethod));
+    auto attributes = f->cppAttributes();
+    return !attributes.testFlag(FunctionAttribute::Override)
+        && !attributes.testFlag(FunctionAttribute::Final);
 }
 
 void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClassCPtr &scope,