Remove attributes Final and FinalInCpp

Apparently, the meaning of FinalInCpp for functions was "virtual and
not private". The previous code cleanup removed most uses
of them. For the remaining cases, checking for virtual is sufficient.

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

3 files changed, 17 insertions, 37 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
index 5cb6ac342..79d69abf3 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
@@ -374,7 +374,7 @@ void AbstractMetaBuilderPrivate::traverseStreamOperator(FunctionModelItem item)
 
                 streamFunction->setArguments(arguments);
 
-                *streamFunction += AbstractMetaAttributes::Final;
+                *streamFunction += AbstractMetaAttributes::FinalInTargetLang;
                 *streamFunction += AbstractMetaAttributes::Public;
                 streamFunction->setOriginalAttributes(streamFunction->attributes());
 
@@ -1486,11 +1486,6 @@ void AbstractMetaBuilderPrivate::setupFunctionDefaults(AbstractMetaFunction *met
 
     if (metaFunction->name() == QLatin1String("operator_equal"))
         metaClass->setHasEqualsOperator(true);
-
-    if (!metaFunction->isFinalInTargetLang()
-        && metaFunction->isRemovedFrom(metaClass, TypeSystem::TargetLangCode)) {
-        *metaFunction += AbstractMetaAttributes::FinalInCpp;
-    }
 }
 
 void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaFunction *metaFunction)
@@ -1707,16 +1702,18 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
             metaClass->setHasPrivateConstructor(true);
         if ((isInvalidDestructor || isInvalidConstructor)
             && !metaClass->hasNonPrivateConstructor()) {
-            *metaClass += AbstractMetaAttributes::Final;
+            *metaClass += AbstractMetaAttributes::FinalInTargetLang;
         } else if (metaFunction->isConstructor() && !metaFunction->isPrivate()) {
-            *metaClass -= AbstractMetaAttributes::Final;
+            *metaClass -= AbstractMetaAttributes::FinalInTargetLang;
             metaClass->setHasNonPrivateConstructor(true);
         }
 
         // Classes with virtual destructors should always have a shell class
         // (since we aren't registering the destructors, we need this extra check)
-        if (metaFunction->isDestructor() && !metaFunction->isFinal())
+        if (metaFunction->isDestructor() && metaFunction->isVirtual()
+            && metaFunction->visibility() != AbstractMetaAttributes::Private) {
             metaClass->setForceShellClass(true);
+        }
 
         if (!metaFunction->isDestructor()
             && !(metaFunction->isPrivate() && metaFunction->functionType() == AbstractMetaFunction::ConstructorFunction)) {
@@ -1929,7 +1926,7 @@ AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFu
     metaFunction->setVisibility(visibility);
     metaFunction->setUserAdded(true);
     AbstractMetaAttributes::Attribute isStatic = addedFunc.isStatic() ? AbstractMetaFunction::Static : AbstractMetaFunction::None;
-    metaFunction->setAttributes(metaFunction->attributes() | AbstractMetaAttributes::Final | isStatic);
+    metaFunction->setAttributes(metaFunction->attributes() | AbstractMetaAttributes::FinalInTargetLang | isStatic);
     metaFunction->setType(translateType(addedFunc.version(), addedFunc.returnType()));
 
 
@@ -2202,7 +2199,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
         if (functionItem->isFinal())
             *metaFunction += AbstractMetaAttributes::FinalCppMethod;
     } else {
-        *metaFunction += AbstractMetaAttributes::Final;
+        *metaFunction += AbstractMetaAttributes::FinalInTargetLang;
     }
 
     if (functionItem->isInvokable())
@@ -2210,7 +2207,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
 
     if (functionItem->isStatic()) {
         *metaFunction += AbstractMetaAttributes::Static;
-        *metaFunction += AbstractMetaAttributes::Final;
+        *metaFunction += AbstractMetaAttributes::FinalInTargetLang;
     }
 
     // Access rights
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index ceb45524f..19e6a0f26 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -1214,7 +1214,7 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
     // Only public functions in final classes
     // default_flags |= isFinal() ? WasPublic : 0;
     FunctionQueryOptions public_flags;
-    if (isFinal())
+    if (isFinalInTargetLang())
         public_flags |= WasPublic;
 
     // Constructors
@@ -1368,7 +1368,7 @@ void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
         Q_ASSERT(false); //memory leak
 
     m_hasVirtualSlots |= function->isVirtualSlot();
-    m_hasVirtuals |= !function->isFinal() || function->isVirtualSlot() || hasVirtualDestructor();
+    m_hasVirtuals |= function->isVirtual() || function->isVirtualSlot() || hasVirtualDestructor();
     m_isPolymorphic |= m_hasVirtuals;
     m_hasNonpublic |= !function->isPublic();
 }
@@ -1572,7 +1572,7 @@ static AbstractMetaFunction *createXetter(const AbstractMetaField *g, const QStr
     f->setImplementingClass(g->enclosingClass());
     f->setDeclaringClass(g->enclosingClass());
 
-    AbstractMetaAttributes::Attributes attr = AbstractMetaAttributes::Final | type;
+    AbstractMetaAttributes::Attributes attr = AbstractMetaAttributes::FinalInTargetLang | type;
     if (g->isStatic())
         attr |= AbstractMetaAttributes::Static;
     if (g->isPublic())
@@ -1752,7 +1752,7 @@ void AbstractMetaClass::addDefaultConstructor()
     f->setArguments(AbstractMetaArgumentList());
     f->setDeclaringClass(this);
 
-    f->setAttributes(AbstractMetaAttributes::Public | AbstractMetaAttributes::Final);
+    f->setAttributes(AbstractMetaAttributes::Public | AbstractMetaAttributes::FinalInTargetLang);
     f->setImplementingClass(this);
     f->setOriginalAttributes(f->attributes());
 
@@ -1780,7 +1780,7 @@ void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate)
     arg->setName(name());
     f->addArgument(arg);
 
-    AbstractMetaAttributes::Attributes attr = AbstractMetaAttributes::Final;
+    AbstractMetaAttributes::Attributes attr = AbstractMetaAttributes::FinalInTargetLang;
     if (isPrivate)
         attr |= AbstractMetaAttributes::Private;
     else
@@ -1809,7 +1809,7 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions
         if ((query & NotRemovedFromTargetLang) && f->isRemovedFrom(f->implementingClass(), TypeSystem::TargetLangCode))
             continue;
 
-        if ((query & NotRemovedFromTargetLang) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode))
+        if ((query & NotRemovedFromTargetLang) && f->isVirtual() && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode))
             continue;
 
         if ((query & Visible) && f->isPrivate())
@@ -1833,7 +1833,7 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions
         if ((query & FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
             continue;
 
-        if ((query & VirtualInCppFunctions) && f->isFinalInCpp())
+        if ((query & VirtualInCppFunctions) && !f->isVirtual())
             continue;
 
         if ((query & Signals) && (!f->isSignal()))
@@ -2091,9 +2091,6 @@ void AbstractMetaClass::fixFunctions()
                         // Same function, propegate virtual...
                         if (!(cmp & AbstractMetaFunction::EqualAttributes)) {
                             if (!f->isEmptyFunction()) {
-                                if (!sf->isFinalInCpp() && f->isFinalInCpp()) {
-                                    *f -= AbstractMetaAttributes::FinalInCpp;
-                                }
                                 if (!sf->isFinalInTargetLang() && f->isFinalInTargetLang()) {
                                     *f -= AbstractMetaAttributes::FinalInTargetLang;
                                 }
@@ -2128,7 +2125,6 @@ void AbstractMetaClass::fixFunctions()
                             if (f->isPrivate()) {
                                 f->setFunctionType(AbstractMetaFunction::EmptyFunction);
                                 *f += AbstractMetaAttributes::FinalInTargetLang;
-                                *f += AbstractMetaAttributes::FinalInCpp;
                             }
                         }
 
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index ea2f4811e..83c1c334f 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -118,7 +118,6 @@ public:
         Static                      = 0x00000040,
 
         FinalInTargetLang           = 0x00000080,
-        FinalInCpp                  = 0x00000100,
 
         GetterFunction              = 0x00000400,
         SetterFunction              = 0x00000800,
@@ -134,9 +133,7 @@ public:
         FinalCppClass               = 0x00100000,
         VirtualCppMethod            = 0x00200000,
         OverriddenCppMethod         = 0x00400000,
-        FinalCppMethod              = 0x00800000,
-
-        Final                       = FinalInTargetLang | FinalInCpp
+        FinalCppMethod              = 0x00800000
     };
     Q_DECLARE_FLAGS(Attributes, Attribute)
     Q_FLAG(Attribute)
@@ -181,21 +178,11 @@ public:
         m_attributes &= ~attribute;
     }
 
-    bool isFinal() const
-    {
-        return (m_attributes & Final) == Final;
-    }
-
     bool isFinalInTargetLang() const
     {
         return m_attributes & FinalInTargetLang;
     }
 
-    bool isFinalInCpp() const
-    {
-        return m_attributes & FinalInCpp;
-    }
-
     bool isAbstract() const
     {
         return m_attributes & Abstract;