Filter out methods that do the same (at least in Python)

Author: usiems

generator/abstractmetabuilder.cpp

@@ -1166,6 +1166,48 @@ void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scope_item, AbstractM
             }
         }
     }
+    removeEquivalentFunctions(meta_class);
+}
+
+void AbstractMetaBuilder::removeEquivalentFunctions(AbstractMetaClass* parent)
+{
+    AbstractMetaFunctionList functions = parent->functions();
+    for (AbstractMetaFunction* fun : functions)
+    {
+        AbstractMetaArgumentList args = fun->arguments();
+        bool candidateToRemove = false;
+        for (AbstractMetaArgument* arg : args) {
+            const TypeEntry* argType = arg->type()->typeEntry();
+            if (argType && argType->equivalentType()) {
+                candidateToRemove = true;
+                break;
+            }
+        }
+        if (!candidateToRemove) {
+            continue;
+        }
+        // check if there are other functions with the same name and equivalent parameters
+        AbstractMetaFunctionList overloadedFunctions = parent->queryFunctionsByName(fun->name());
+        for (AbstractMetaFunction* overload : overloadedFunctions) {
+            if (overload != fun) {
+                AbstractMetaArgumentList overloadArgs = overload->arguments();
+                if (overloadArgs.size() == args.size()) {
+                    bool equivalentArgs = true;
+                    for (int i = 0; i < args.size() && equivalentArgs; i++) {
+                        const TypeEntry* argType = args[i]->type()->typeEntry();
+                        const TypeEntry* overloadArgType = overloadArgs[i]->type()->typeEntry();
+                        // This could have some more equivalency checks, but currently this seems to be sufficient
+                        equivalentArgs = (argType && overloadArgType &&
+                                          (argType == overloadArgType || argType->equivalentType() == overloadArgType));
+                    }
+                    if (equivalentArgs) {
+                        parent->removeFunction(fun);
+                        break;
+                    }
+                }
+            }
+        }
+    }
 }
 
 bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *meta_class)

generator/abstractmetabuilder.h

@@ -96,6 +96,10 @@ class AbstractMetaBuilder
     void traverseStreamOperator(FunctionModelItem function_item);
     void traverseCompareOperator(FunctionModelItem item);
     void traverseBinaryArithmeticOperator(FunctionModelItem item);
+    
+    //! remove functions/methods that are overloads with equivalent parameter types
+    //! when called from Python
+    void removeEquivalentFunctions(AbstractMetaClass* parent);
 
     AbstractMetaFunction *traverseFunction(FunctionModelItem function);
     AbstractMetaField *traverseField(VariableModelItem field, const AbstractMetaClass *cls);

generator/abstractmetalang.cpp

@@ -1103,6 +1103,11 @@ void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
     m_has_nonpublic |= !function->isPublic();
 }
 
+void AbstractMetaClass::removeFunction(AbstractMetaFunction* function)
+{
+  m_functions.removeOne(function);
+}
+
 bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
 {
     if (!other->isSignal())

generator/abstractmetalang.h

@@ -688,6 +688,7 @@ class AbstractMetaClass : public AbstractMetaAttributes
     AbstractMetaFunctionList functions() const { return m_functions; }
     void setFunctions(const AbstractMetaFunctionList &functions);
     void addFunction(AbstractMetaFunction *function);
+    void removeFunction(AbstractMetaFunction* function);
     bool hasFunction(const AbstractMetaFunction *f) const;
     bool hasFunction(const QString &str) const;
     bool hasSignal(const AbstractMetaFunction *f) const;

generator/typesystem.cpp

@@ -1509,22 +1509,27 @@ TypeDatabase *TypeDatabase::instance()
 
 TypeDatabase::TypeDatabase() : m_suppressWarnings(true)
 {
-    addType(new StringTypeEntry("QString"));
+    StringTypeEntry* mainStringType = new StringTypeEntry("QString");
+    addType(mainStringType);
 
     StringTypeEntry *e = new StringTypeEntry("QLatin1String");
     e->setPreferredConversion(false);
+    e->setEquivalentType(mainStringType);
     addType(e);
 
     e = new StringTypeEntry("QStringRef");
     e->setPreferredConversion(false);
+    e->setEquivalentType(mainStringType);
     addType(e);
 
     e = new StringTypeEntry("QStringView");
     e->setPreferredConversion(false);
+    e->setEquivalentType(mainStringType);
     addType(e);
 
     e = new StringTypeEntry("QAnyStringView");
     e->setPreferredConversion(false);
+    e->setEquivalentType(mainStringType);
     addType(e);
 
     e = new StringTypeEntry("QXmlStreamStringRef");

generator/typesystem.h

@@ -549,6 +549,8 @@ class TypeEntry
 
     virtual bool isNativeIdBased() const { return false; }
 
+    virtual TypeEntry* equivalentType() const { return nullptr; }
+
 private:
     QString m_name;
     Type m_type;
@@ -1013,8 +1015,14 @@ class ValueTypeEntry : public ComplexTypeEntry
 
     virtual bool isNativeIdBased() const { return true; }
 
+    virtual TypeEntry* equivalentType() const { return _equivalentType; }
+    void setEquivalentType(TypeEntry* typeEntry) { _equivalentType = typeEntry; }
+
 protected:
     ValueTypeEntry(const QString &name, Type t) : ComplexTypeEntry(name, t) { }
+
+private:
+  TypeEntry* _equivalentType{};
 };