From 380d064ca0a1cbb66c1200942fcf1336d0e9dc64 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@protonmail.com>
Date: Fri, 19 Apr 2019 23:52:34 +0300
Subject: [PATCH] Generate valid C# for overloads with types nested in
 templates

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>
---
 .../Passes/CheckDuplicatedNamesPass.cs        | 22 ++++++++++++++-----
 tests/CSharp/CSharpTemplates.cpp              |  4 +++-
 tests/CSharp/CSharpTemplates.h                | 18 ++++++++++++++-
 3 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/src/Generator/Passes/CheckDuplicatedNamesPass.cs b/src/Generator/Passes/CheckDuplicatedNamesPass.cs
index 95f8eb93..a372373f 100644
--- a/src/Generator/Passes/CheckDuplicatedNamesPass.cs
+++ b/src/Generator/Passes/CheckDuplicatedNamesPass.cs
@@ -113,6 +113,9 @@ namespace CppSharp.Passes
                 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 @@ namespace CppSharp.Passes
 
             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)
diff --git a/tests/CSharp/CSharpTemplates.cpp b/tests/CSharp/CSharpTemplates.cpp
index a471e4fb..236c7b2c 100644
--- a/tests/CSharp/CSharpTemplates.cpp
+++ b/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)
 {
 }
 
diff --git a/tests/CSharp/CSharpTemplates.h b/tests/CSharp/CSharpTemplates.h
index b7296e72..4272435e 100644
--- a/tests/CSharp/CSharpTemplates.h
+++ b/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 @@ public:
                                            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;