Fixed the generated C# for templates with > 1 ctor taking a pointer to a class.

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

Author: ddobrev

src/Generator/Driver.cs

@@ -234,9 +234,9 @@ public void SetupPasses(ILibrary library)
             TranslationUnitPasses.AddPass(new CheckStaticClass());
             TranslationUnitPasses.AddPass(new MoveOperatorToClassPass());
             TranslationUnitPasses.AddPass(new MoveFunctionToClassPass());
+            TranslationUnitPasses.AddPass(new CheckAmbiguousFunctions());
             TranslationUnitPasses.AddPass(new ConstructorToConversionOperatorPass());
             TranslationUnitPasses.AddPass(new MarshalPrimitivePointersAsRefTypePass());
-            TranslationUnitPasses.AddPass(new CheckAmbiguousFunctions());
             TranslationUnitPasses.AddPass(new CheckOperatorsOverloadsPass());
             TranslationUnitPasses.AddPass(new CheckVirtualOverrideReturnCovariance());
             TranslationUnitPasses.AddPass(new CleanCommentsPass());

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -2598,6 +2598,7 @@ private void GenerateOperator(Method method, QualifiedType returnType)
                 {
                     // To avoid ambiguity when having the multiple inheritance pass enabled
                     var paramType = method.Parameters[0].Type.SkipPointerRefs().Desugar();
+                    paramType = (paramType.GetPointee() ?? paramType).Desugar();
                     Class paramClass;
                     Class @interface = null;
                     if (paramType.TryGetClass(out paramClass))
@@ -3175,8 +3176,10 @@ public string GetFunctionNativeIdentifier(Function function,
             var internalParams = function.GatherInternalParams(
                 Context.ParserOptions.IsItaniumLikeAbi);
             var overloads = function.Namespace.GetOverloads(function)
-                .Where(f => !f.Ignore && (isForDelegate || internalParams.SequenceEqual(
-                    f.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi),
+                .Where(f => (!f.Ignore ||
+                    (f.OriginalFunction != null && !f.OriginalFunction.Ignore)) &&
+                    (isForDelegate || internalParams.SequenceEqual(
+                        f.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi),
                     new MarshallingParamComparer()))).ToList();
             var index = -1;
             if (overloads.Count > 1)

src/Generator/Passes/CheckDuplicatedNamesPass.cs

@@ -2,24 +2,24 @@
 using System.Globalization;
 using System.Linq;
 using CppSharp.AST;
-using CppSharp.Generators;
+using CppSharp.AST.Extensions;
 
 namespace CppSharp.Passes
 {
     class DeclarationName
     {
-        private readonly Dictionary<string, int> methodSignatures;
+        private readonly Dictionary<Function, int> functions;
         private int Count;
 
         public DeclarationName()
         {
-            methodSignatures = new Dictionary<string, int>();
+            functions = new Dictionary<Function, int>();
         }
 
         public bool UpdateName(Declaration decl)
         {
             var function = decl as Function;
-            if (function != null && !(function.Namespace is ClassTemplateSpecialization))
+            if (function != null)
             {
                 return UpdateName(function);
             }
@@ -50,19 +50,22 @@ private bool UpdateName(Function function)
                 (method.OperatorKind == CXXOperatorKind.Conversion ||
                  method.OperatorKind == CXXOperatorKind.ExplicitConversion))
                 @params = @params.Concat(new[] { method.ConversionType.ToString() });
-            var signature = string.Format("{0}({1})", function.Name, string.Join( ", ", @params));
+            var signature = $"{function.Name}({string.Join(", ", @params)})";
             signature = FixSignatureForConversions(function, signature);
 
             if (Count == 0)
                 Count++;
 
-            if (!methodSignatures.ContainsKey(signature))
+            var duplicate = functions.Keys.FirstOrDefault(f =>
+                f.Parameters.SequenceEqual(function.Parameters, ParameterTypeComparer.Instance));
+
+            if (duplicate == null)
             {
-                methodSignatures.Add(signature, 0);
+                functions.Add(function, 0);
                 return false;
             }
 
-            var methodCount = ++methodSignatures[signature];
+            var methodCount = ++functions[duplicate];
 
             if (Count < methodCount + 1)
                 Count = methodCount + 1;
@@ -96,6 +99,34 @@ public static string FixSignatureForConversions(Function function, string signat
             }
             return signature;
         }
+
+        private class ParameterTypeComparer : IEqualityComparer<Parameter>
+        {
+            public static readonly ParameterTypeComparer Instance = new ParameterTypeComparer();
+
+            private ParameterTypeComparer()
+            {
+            }
+
+            public bool Equals(Parameter x, Parameter y)
+            {
+                Type left = x.Type.Desugar(resolveTemplateSubstitution: false);
+                Type right = y.Type.Desugar(resolveTemplateSubstitution: false);
+                if (left.Equals(right))
+                    return true;
+
+                // TODO: some target languages might maek a difference between values and pointers
+                Type leftPointee = left.GetPointee();
+                Type rightPointee = right.GetPointee();
+                return (leftPointee != null && leftPointee.Desugar(false).Equals(right)) ||
+                    (rightPointee != null && rightPointee.Desugar(false).Equals(left));
+            }
+
+            public int GetHashCode(Parameter obj)
+            {
+                return obj.Type.GetHashCode();
+            }
+        }
     }
 
     public class CheckDuplicatedNamesPass : TranslationUnitPass
@@ -180,15 +211,6 @@ public override bool VisitClassDecl(Class @class)
             return false;
         }
 
-        private static IEnumerable<Field> GetAllFields(Class @class, List<Field> fields = null)
-        {
-            fields = fields ?? new List<Field>();
-            foreach (var @base in @class.Bases.Where(b => b.IsClass && b.Class != @class))
-                GetAllFields(@base.Class, fields);
-            fields.AddRange(@class.Fields);
-            return fields;
-        }
-
         private void CheckDuplicate(Declaration decl)
         {
             if (decl.IsDependent || !decl.IsGenerated)

tests/CSharp/CSharp.Tests.cs

@@ -84,6 +84,16 @@ public void TestUncompilableCode()
         {
         }
 
+        using (var t1 = new T1())
+        using (new IndependentFields<int>(t1))
+        {
+        }
+
+        using (var t2 = new T2())
+        using (new IndependentFields<int>(t2))
+        {
+        }
+
 #pragma warning restore 0168
 #pragma warning restore 0219
     }

tests/CSharp/CSharpTemplates.h

@@ -32,6 +32,8 @@ class DLL_API IndependentFields : public T1
     IndependentFields();
     IndependentFields(const IndependentFields<T>& other);
     IndependentFields(const T& t);
+    IndependentFields(T1* t1);
+    IndependentFields(T2* t2);
     IndependentFields(int i);
     ~IndependentFields();
     explicit IndependentFields(const std::map<T, T> &other);
@@ -66,6 +68,16 @@ IndependentFields<T>::IndependentFields(const T& t) : independent(1)
 {
 }
 
+template <typename T>
+IndependentFields<T>::IndependentFields(T1* t1) : independent(1)
+{
+}
+
+template <typename T>
+IndependentFields<T>::IndependentFields(T2* t2) : independent(1)
+{
+}
+
 template <typename T>
 IndependentFields<T>::IndependentFields(int i)
 {