shiboken6: Remove function attribute FinalInTargetLang

The attribute does not have any impact on the generated code; it merely
causes some warnings to be printed when fixing the class functions
for rare cases. AbstractMetaFunction::isModifiedFinal() determines
the generation of virtual functions instead.

The function query flags FinalInTargetLangFunctions and
VirtualInTargetLangFunctions can be removed as well. They were
both used in AbstractMetaClass::functionsInTargetLang() which
is used by the documentation generator only.

Task-number: PYSIDE-2602
Change-Id: Ib0f0de41008b655a84637ab28f1046aa3e098b76
Reviewed-by: Christian Tismer <tismer@stackless.com>
(cherry picked from commit 4a3d0e9bfd5d9bcfc5fc2f8b13b3d3c0b312c079)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

5 files changed, 5 insertions, 89 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 1944dc648..06db98ee7 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -386,7 +386,6 @@ bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem
 
     streamFunction->setArguments(arguments);
 
-    *streamFunction += AbstractMetaFunction::FinalInTargetLang;
     streamFunction->setAccess(Access::Public);
 
     AbstractMetaClassPtr funcClass;
@@ -1561,11 +1560,6 @@ void AbstractMetaBuilderPrivate::applyFunctionModifications(AbstractMetaFunction
             else if (mod.isPrivate())
                 funcRef.modifyAccess(Access::Private);
         }
-
-        if (mod.isFinal())
-            funcRef += AbstractMetaFunction::FinalInTargetLang;
-        else if (mod.isNonFinal())
-            funcRef -= AbstractMetaFunction::FinalInTargetLang;
     }
 }
 
@@ -2091,14 +2085,10 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio
             *metaFunction += AbstractMetaFunction::OverriddenCppMethod;
         if (functionItem->isFinal())
             *metaFunction += AbstractMetaFunction::FinalCppMethod;
-    } else {
-        *metaFunction += AbstractMetaFunction::FinalInTargetLang;
     }
 
-    if (functionItem->isStatic()) {
+    if (functionItem->isStatic())
         *metaFunction += AbstractMetaFunction::Static;
-        *metaFunction += AbstractMetaFunction::FinalInTargetLang;
-    }
 
     // Access rights
     metaFunction->setAccess(functionItem->accessPolicy());
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
index 27642ed01..ed939569e 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
@@ -120,7 +120,7 @@ AbstractMetaFunction::AbstractMetaFunction(const AddedFunctionPtr &addedFunc) :
         setAccess(Access::Public);
         break;
     }
-    AbstractMetaFunction::Attributes atts = AbstractMetaFunction::FinalInTargetLang;
+    AbstractMetaFunction::Attributes atts;
     if (addedFunc->isStatic())
         atts |= AbstractMetaFunction::Static;
     if (addedFunc->isClassMethod())
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
index 51f4a1ba7..334afe0e2 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
@@ -96,8 +96,6 @@ public:
         Static                      = 0x00000004,
         ClassMethod                 = 0x00000008,
 
-        FinalInTargetLang           = 0x00000010,
-
         GetterFunction              = 0x00000020,
         SetterFunction              = 0x00000040,
 
@@ -136,7 +134,6 @@ public:
     Flags flags() const;
     void setFlags(Flags f);
 
-    bool isFinalInTargetLang() const;
     bool isAbstract() const;
     bool isClassMethod() const;
     bool isStatic() const;
@@ -448,11 +445,6 @@ private:
     QScopedPointer<AbstractMetaFunctionPrivate> d;
 };
 
-inline bool AbstractMetaFunction::isFinalInTargetLang() const
-{
-    return attributes().testFlag(FinalInTargetLang);
-}
-
 inline bool AbstractMetaFunction::isAbstract() const
 {
     return attributes().testFlag(Abstract);
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index 3d28eb039..fab6298ab 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -187,14 +187,7 @@ AbstractMetaFunctionCList AbstractMetaClass::functionsInTargetLang() const
     AbstractMetaFunctionCList returned = queryFunctions(FunctionQueryOption::AnyConstructor
                                                         | default_flags | public_flags);
 
-    // Final functions
-    returned += queryFunctions(FunctionQueryOption::FinalInTargetLangFunctions
-                               | FunctionQueryOption::NonStaticFunctions
-                               | default_flags | public_flags);
-
-    // Virtual functions
-    returned += queryFunctions(FunctionQueryOption::VirtualInTargetLangFunctions
-                               | FunctionQueryOption::NonStaticFunctions
+    returned += queryFunctions(FunctionQueryOption::NonStaticFunctions
                                | default_flags | public_flags);
 
     // Static functions
@@ -815,8 +808,7 @@ void AbstractMetaClassPrivate::addConstructor(AbstractMetaFunction::FunctionType
     auto *f = createFunction(q->name(), t, access, arguments, AbstractMetaType::createVoid(), q);
     if (access != Access::Private)
          m_hasNonPrivateConstructor = true;
-    f->setAttributes(AbstractMetaFunction::FinalInTargetLang
-                     | AbstractMetaFunction::AddedMethod);
+    f->setAttributes(AbstractMetaFunction::AddedMethod);
     addFunction(AbstractMetaFunctionCPtr(f));
 }
 
@@ -1169,9 +1161,6 @@ bool AbstractMetaClass::queryFunction(const AbstractMetaFunction *f, FunctionQue
     if (query.testFlag(FunctionQueryOption::Visible) && f->isPrivate())
         return false;
 
-    if (query.testFlag(FunctionQueryOption::VirtualInTargetLangFunctions) && f->isFinalInTargetLang())
-        return false;
-
     if (query.testFlag(FunctionQueryOption::Invisible) && !f->isPrivate())
         return false;
 
@@ -1184,9 +1173,6 @@ bool AbstractMetaClass::queryFunction(const AbstractMetaFunction *f, FunctionQue
     if (query.testFlag(FunctionQueryOption::ClassImplements) && f->ownerClass() != f->implementingClass())
         return false;
 
-    if (query.testFlag(FunctionQueryOption::FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
-        return false;
-
     if (query.testFlag(FunctionQueryOption::VirtualInCppFunctions) && !f->isVirtual())
         return false;
 
@@ -1527,24 +1513,6 @@ void AbstractMetaClass::fixFunctions(const AbstractMetaClassPtr &klass)
                             && !attributes.testFlag(AbstractMetaFunction::FinalCppMethod)) {
                             *f += AbstractMetaFunction::OverriddenCppMethod;
                         }
-                        // Same function, propegate virtual...
-                        if (!(cmp & AbstractMetaFunction::EqualAttributes)) {
-                            if (!f->isEmptyFunction()) {
-                                if (!sf->isFinalInTargetLang() && f->isFinalInTargetLang()) {
-                                    *f -= AbstractMetaFunction::FinalInTargetLang;
-                                }
-#if 0
-                                if (!f->isFinalInTargetLang() && f->isPrivate()) {
-                                    f->setFunctionType(AbstractMetaFunction::EmptyFunction);
-                                    f->setVisibility(AbstractMetaAttributes::Protected);
-                                    *f += AbstractMetaAttributes::FinalInTargetLang;
-                                    qCWarning(lcShiboken, "private virtual function '%s' in '%s'",
-                                              qPrintable(f->signature()),
-                                              qPrintable(f->implementingClass()->name()));
-                                }
-#endif
-                            }
-                        }
 
                         if (f->access() != sf->access()) {
                             qCWarning(lcShiboken, "%s",
@@ -1560,44 +1528,12 @@ void AbstractMetaClass::fixFunctions(const AbstractMetaClassPtr &klass)
                             // Private overrides of abstract functions have to go into the class or
                             // the subclasses will not compile as non-abstract classes.
                             // But they don't need to be implemented, since they can never be called.
-                            if (f->isPrivate()) {
+                            if (f->isPrivate())
                                 f->setFunctionType(AbstractMetaFunction::EmptyFunction);
-                                *f += AbstractMetaFunction::FinalInTargetLang;
-                            }
                         }
 
                         // Set the class which first declares this function, afawk
                         f->setDeclaringClass(sf->declaringClass());
-
-                        if (sf->isFinalInTargetLang() && !sf->isPrivate() && !f->isPrivate() && !sf->isStatic() && !f->isStatic()) {
-                            // Shadowed funcion, need to make base class
-                            // function non-virtual
-                            if (f->implementingClass() != sf->implementingClass()
-                                && inheritsFrom(f->implementingClass(), sf->implementingClass())) {
-
-                                // Check whether the superclass method has been redefined to non-final
-
-                                bool hasNonFinalModifier = false;
-                                bool isBaseImplPrivate = false;
-                                const FunctionModificationList &mods = sf->modifications(sf->implementingClass());
-                                for (const FunctionModification &mod : mods) {
-                                    if (mod.isNonFinal()) {
-                                        hasNonFinalModifier = true;
-                                        break;
-                                    }
-                                    if (mod.isPrivate()) {
-                                        isBaseImplPrivate = true;
-                                        break;
-                                    }
-                                }
-
-                                if (!hasNonFinalModifier && !isBaseImplPrivate) {
-                                    qCWarning(lcShiboken, "%s",
-                                              qPrintable(msgShadowingFunction(sf.get(), f.get())));
-                                }
-                            }
-                        }
-
                     }
 
                     if (cmp & AbstractMetaFunction::EqualDefaultValueOverload) {
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h b/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h
index 2bdfdb54d..9186750a4 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang_enums.h
@@ -11,7 +11,6 @@ enum class FunctionQueryOption {
     Constructors                 = 0x0000002, // Constructors except copy/move
     CopyConstructor              = 0x0000004, // Only copy constructors
     //Destructors                  = 0x0000002, // Only destructors. Not included in class.
-    FinalInTargetLangFunctions   = 0x0000008, // Only functions that are non-virtual in TargetLang
     ClassImplements              = 0x0000020, // Only functions implemented by the current class
     StaticFunctions              = 0x0000080, // Only static functions
     Signals                      = 0x0000100, // Only signals
@@ -22,7 +21,6 @@ enum class FunctionQueryOption {
     Empty                        = 0x0008000, // Empty overrides of abstract functions
     Invisible                    = 0x0010000, // Only private functions
     VirtualInCppFunctions        = 0x0020000, // Only functions that are virtual in C++
-    VirtualInTargetLangFunctions = 0x0080000, // Only functions which are virtual in TargetLang
     NotRemoved                   = 0x0400000, // Only functions that have not been removed
     OperatorOverloads            = 0x2000000, // Only functions that are operator overloads
     GenerateExceptionHandling    = 0x4000000,