Fix regression that caused overload sorting to not respect argument type renames.

4 files changed, 31 insertions, 9 deletions

diff --git a/generator/overloaddata.cpp b/generator/overloaddata.cpp
index 926f5d988..42b04fdf8 100644
--- a/generator/overloaddata.cpp
+++ b/generator/overloaddata.cpp
@@ -53,6 +53,11 @@ static QString getTypeName(const AbstractMetaType* type)
     return typeName;
 }
 
+static QString getTypeName(const OverloadData* ov)
+{
+    return ov->hasArgumentTypeReplace() ? ov->argumentTypeReplaced() : getTypeName(ov->argType());
+}
+
 static bool typesAreEqual(const AbstractMetaType* typeA, const AbstractMetaType* typeB)
 {
 
@@ -93,7 +98,7 @@ struct OverloadSortData
 
     void mapType(OverloadData* overloadData)
     {
-        QString typeName = getTypeName(overloadData->argType());
+        QString typeName = getTypeName(overloadData);
         map[typeName] = counter;
         reverseMap[counter] = overloadData;
         counter++;
@@ -173,13 +178,16 @@ void OverloadData::sortNextOverloads()
     // with graph sorting using integers.
     foreach(OverloadData* ov, m_nextOverloadData) {
         sortData.mapType(ov);
-        if (!checkPyObject && getTypeName(ov->argType()).contains("PyObject")) {
+
+        const QString typeName(getTypeName(ov));
+
+        if (!checkPyObject && typeName.contains("PyObject")) {
             checkPyObject = true;
             pyobjectIndex = sortData.lastProcessedItemId();
-        } else if (!checkQVariant && getTypeName(ov->argType()) == "QVariant") {
+        } else if (!checkQVariant && typeName == "QVariant") {
             checkQVariant = true;
             qvariantIndex = sortData.lastProcessedItemId();
-        } else if (!checkQString && getTypeName(ov->argType()) == "QString") {
+        } else if (!checkQString && typeName == "QString") {
             checkQString = true;
             qstringIndex = sortData.lastProcessedItemId();
         }
@@ -229,8 +237,7 @@ void OverloadData::sortNextOverloads()
 
     foreach(OverloadData* ov, m_nextOverloadData) {
         const AbstractMetaType* targetType = ov->argType();
-        const TypeEntry* targetTypeEntry = getAliasedTypeEntry(targetType->typeEntry());
-        QString targetTypeEntryName = getTypeName(targetType);
+        const QString targetTypeEntryName(getTypeName(ov));
 
         // Process implicit conversions
         foreach(AbstractMetaFunction* function, m_generator->implicitConversions(targetType)) {
@@ -293,7 +300,7 @@ void OverloadData::sortNextOverloads()
                 graph.addEdge(sortData.map[targetTypeEntryName], qstringIndex);
         }
 
-        if (targetTypeEntry->isEnum()) {
+        if (targetType->isEnum()) {
             // Enum values must precede primitive types.
             for (int i = 0; i < numPrimitives; ++i) {
                 if (hasPrimitive[i])
@@ -307,9 +314,7 @@ void OverloadData::sortNextOverloads()
         if (!targetType->isEnum())
             continue;
 
-        const TypeEntry* targetTypeEntry = getAliasedTypeEntry(targetType->typeEntry());
         QString targetTypeEntryName = getTypeName(targetType);
-
         // Enum values must precede types implicitly convertible from "int" or "unsigned int".
         foreach (const QString& implicitFromInt, classesWithIntegerImplicitConversion)
             graph.addEdge(sortData.map[targetTypeEntryName], sortData.map[implicitFromInt]);
diff --git a/tests/libsample/overloadsort.h b/tests/libsample/overloadsort.h
index c95c35728..b3a95bc09 100644
--- a/tests/libsample/overloadsort.h
+++ b/tests/libsample/overloadsort.h
@@ -71,6 +71,11 @@ public:
     inline const char *overloadDeep(int x, ImplicitBase &y) {
         return "ImplicitBase";
     }
+
+
+    inline const char* pyObjOverload(int, int) { return "int,int"; }
+    inline const char* pyObjOverload(unsigned char*, int) { return "PyObject,int"; }
+
 };
 
 #endif // OVERLOADSORT_H
diff --git a/tests/samplebinding/overload_sorting_test.py b/tests/samplebinding/overload_sorting_test.py
index 9d4b1cbeb..0cb86642a 100644
--- a/tests/samplebinding/overload_sorting_test.py
+++ b/tests/samplebinding/overload_sorting_test.py
@@ -60,6 +60,10 @@ class SimpleOverloadSorting(unittest.TestCase):
         '''Passing an implicit convertible object to an overload'''
         self.assert_(self.obj.implicit_overload(ImplicitTarget()))
 
+    def testPyObjectSort(self):
+        self.assertEqual(self.obj.pyObjOverload(1, 2), "int,int")
+        self.assertEqual(self.obj.pyObjOverload(object(), 2), "PyObject,int")
+
 
 class DeepOverloadSorting(unittest.TestCase):
 
diff --git a/tests/samplebinding/typesystem_sample.xml b/tests/samplebinding/typesystem_sample.xml
index 2667c16d5..636916057 100644
--- a/tests/samplebinding/typesystem_sample.xml
+++ b/tests/samplebinding/typesystem_sample.xml
@@ -992,6 +992,14 @@
                 return PyString_FromString("PyObject");
             </inject-code>
         </add-function>
+        <modify-function signature="pyObjOverload(unsigned char*, int)">
+            <modify-argument index="1">
+                <replace-type modified-type="PyObject" />
+            </modify-argument>
+            <inject-code>
+                unsigned char* %1 = 0;
+            </inject-code>
+        </modify-function>
     </value-type>
     <value-type name="ImplicitTarget"/>