Generate valid C# for overloads with types nested in templates

Signed-off-by: Dimitar Dobrev <[email protected]>

Author: ddobrev

src/Generator/Passes/CheckDuplicatedNamesPass.cs

@@ -113,6 +113,9 @@ public bool Equals(Parameter x, Parameter y)
                 if (left.Equals(right))
                     return true;
 
+                if (CheckForSpecializations(left, right))
+                    return true;
+
                 // TODO: some target languages might make a difference between values and pointers
                 Type leftPointee = left.GetPointee();
                 Type rightPointee = right.GetPointee();
@@ -131,14 +134,23 @@ public bool Equals(Parameter x, Parameter y)
 
             private static bool CheckForSpecializations(Type leftPointee, Type rightPointee)
             {
-                ClassTemplateSpecialization leftSpecialization;
-                ClassTemplateSpecialization rightSpecialization;
-                return leftPointee.TryGetDeclaration(out leftSpecialization) &&
-                    rightPointee.TryGetDeclaration(out rightSpecialization) &&
+                Class leftClass;
+                Class rightClass;
+                if (!leftPointee.TryGetDeclaration(out leftClass) ||
+                    !rightPointee.TryGetDeclaration(out rightClass))
+                    return false;
+
+                var leftSpecialization = leftClass as ClassTemplateSpecialization ??
+                    leftClass.Namespace as ClassTemplateSpecialization;
+                var rightSpecialization = rightClass as ClassTemplateSpecialization ??
+                    rightClass.Namespace as ClassTemplateSpecialization;
+
+                return leftSpecialization != null && rightSpecialization != null &&
                     leftSpecialization.TemplatedDecl.TemplatedDecl.Equals(
                         rightSpecialization.TemplatedDecl.TemplatedDecl) &&
                     leftSpecialization.Arguments.SequenceEqual(
-                        rightSpecialization.Arguments, TemplateArgumentComparer.Instance);
+                        rightSpecialization.Arguments, TemplateArgumentComparer.Instance) &&
+                    leftClass.OriginalName == rightClass.OriginalName;
             }
 
             public int GetHashCode(Parameter obj)

tests/CSharp/CSharpTemplates.cpp

@@ -122,7 +122,9 @@ void TemplateSpecializer::completeSpecializationInParameter(TwoTemplateArgs<int
                                                             TwoTemplateArgs<int *, int> p2,
                                                             TwoTemplateArgs<int *, float> p3,
                                                             TwoTemplateArgs<const char *, int> p4,
-                                                            TwoTemplateArgs<QString, int> p5)
+                                                            TwoTemplateArgs<QString, int> p5,
+                                                            TwoTemplateArgs<const char *, int>::iterator p6,
+                                                            TwoTemplateArgs<QString, int>::iterator p7)
 {
 }
 

tests/CSharp/CSharpTemplates.h

@@ -273,12 +273,24 @@ template <typename K, typename V>
 class TwoTemplateArgs
 {
 public:
+    class iterator
+    {
+    public:
+        iterator() {}
+        ~iterator() {}
+    };
+    void takeDependentPtrToFirstTemplateArg(iterator i, const K& k);
     void takeDependentPtrToSecondTemplateArg(const V& v);
 private:
     K key;
     V value;
 };
 
+template <typename K, typename V>
+void TwoTemplateArgs<K, V>::takeDependentPtrToFirstTemplateArg(iterator i, const K& k)
+{
+}
+
 template <typename K, typename V>
 void TwoTemplateArgs<K, V>::takeDependentPtrToSecondTemplateArg(const V& v)
 {
@@ -547,7 +559,9 @@ class DLL_API TemplateSpecializer
                                            TwoTemplateArgs<int*, int> p2,
                                            TwoTemplateArgs<int*, float> p3,
                                            TwoTemplateArgs<const char*, int> p4,
-                                           TwoTemplateArgs<QString, int> p5);
+                                           TwoTemplateArgs<QString, int> p5,
+                                           TwoTemplateArgs<const char*, int>::iterator p6,
+                                           TwoTemplateArgs<QString, int>::iterator p7);
     VirtualTemplate<void> returnSpecializedWithVoid();
 private:
     IndependentFields<int> independentFields;
@@ -754,6 +768,8 @@ template class DLL_API TemplateWithIndexer<float>;
 template class DLL_API TemplateWithIndexer<const char*>;
 template class DLL_API TemplateDerivedFromRegularDynamic<RegularDynamic>;
 template class DLL_API HasCtorWithMappedToEnum<TestFlag>;
+template class DLL_API TwoTemplateArgs<const char*, int>;
+template class DLL_API TwoTemplateArgs<QString, int>;
 
 class TestForwardedClassInAnotherUnit;