Fixed right-value references creating ambiguous overloads.

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

Author: ddobrev

src/AST/Type.cs

@@ -356,7 +356,7 @@ public override bool Equals(object obj)
             var type = obj as PointerType;
             if (type == null) return false;
 
-            return Pointee.Equals(type.Pointee)
+            return QualifiedPointee.Equals(type.QualifiedPointee)
                 && Modifier == type.Modifier;
         }
 

src/Generator/Passes/CheckAmbiguousFunctions.cs

@@ -76,7 +76,12 @@ private bool CheckDefaultParametersForAmbiguity(Function function, Function over
                 AST.Type funcType = GetFinalType(function.Parameters[i]);
                 AST.Type overloadType = GetFinalType(overload.Parameters[i]);
 
-                if (!funcType.Equals(overloadType))
+                AST.Type funcPointee = funcType.GetFinalPointee() ?? funcType;
+                AST.Type overloadPointee = overloadType.GetFinalPointee() ?? overloadType;
+
+                if (((funcPointee.IsPrimitiveType() || overloadPointee.IsPrimitiveType()) &&
+                      !funcType.Equals(overloadType)) ||
+                    !funcPointee.Equals(overloadPointee))
                     return false;
             }
 

tests/Common/Common.Tests.cs

@@ -27,7 +27,11 @@ public void TestCodeGeneration()
 
             using (var hasOverloadsWithDifferentPointerKindsToSameType =
                 new HasOverloadsWithDifferentPointerKindsToSameType())
+            {
                 hasOverloadsWithDifferentPointerKindsToSameType.Overload(foo, 0);
+                using (var foo2 = new Foo2())
+                    hasOverloadsWithDifferentPointerKindsToSameType.Overload(foo2, 0);
+            }
         }
         using (var overridesNonDirectVirtual = new OverridesNonDirectVirtual())
         {

tests/Common/Common.cpp

@@ -108,11 +108,11 @@ Bar::Bar()
 {
 }
 
-Bar::Bar(Foo foo)
+Bar::Bar(const Foo* foo)
 {
 }
 
-Bar::Bar(const Foo* foo)
+Bar::Bar(Foo foo)
 {
 }
 
@@ -853,6 +853,14 @@ void HasOverloadsWithDifferentPointerKindsToSameType::overload(Foo& rx, int from
 {
 }
 
+void HasOverloadsWithDifferentPointerKindsToSameType::overload(const Foo2& rx, int from)
+{
+}
+
+void HasOverloadsWithDifferentPointerKindsToSameType::overload(Foo2&& rx, int from)
+{
+}
+
 void HasOverloadsWithDifferentPointerKindsToSameType::dispose()
 {
 }

tests/Common/Common.h

@@ -125,8 +125,8 @@ struct DLL_API Bar
     };
 
     Bar();
-    Bar(Foo foo);
     explicit Bar(const Foo* foo);
+    Bar(Foo foo);
     Item RetItem1() const;
     int A;
     float B;
@@ -1310,6 +1310,8 @@ class DLL_API HasOverloadsWithDifferentPointerKindsToSameType
     void overload(const int& i);
     void overload(const Foo& rx, int from = -1);
     void overload(Foo& rx, int from = -1);
+    void overload(const Foo2& rx, int from = -1);
+    void overload(Foo2&& rx, int from = -1);
     void dispose();
 };