From 79f0d41d5c22d2e5dca2e0661a7b34e2b677080a Mon Sep 17 00:00:00 2001
From: Elias Holzer <elias@vvvv.org>
Date: Tue, 13 May 2014 16:52:46 +0200
Subject: [PATCH 1/2] Added failing test for the CheckAmbiguousFunctionsPass.

Test shows that all methods get ignored instead of just the two const overloads.
---
 src/Generator.Tests/Passes/TestPasses.cs | 31 ++++++++++++++++++++++++
 tests/Native/Passes.h                    |  9 +++++++
 2 files changed, 40 insertions(+)

diff --git a/src/Generator.Tests/Passes/TestPasses.cs b/src/Generator.Tests/Passes/TestPasses.cs
index 121e311e..d185a32c 100644
--- a/src/Generator.Tests/Passes/TestPasses.cs
+++ b/src/Generator.Tests/Passes/TestPasses.cs
@@ -1,6 +1,7 @@
 using System.Linq;
 using CppSharp;
 using CppSharp.Passes;
+using CppSharp.AST;
 using NUnit.Framework;
 
 namespace CppSharp.Generator.Tests.Passes
@@ -158,5 +159,35 @@ namespace CppSharp.Generator.Tests.Passes
             Assert.IsFalse(AstContext.FindClass(className).First().Properties.Find(
                 m => m.Name == "ReadOnlyPropertyMethod").HasSetter);
         }
+
+        [Test]
+        public void TestCheckAmbiguousFunctionsPass()
+        {
+            passBuilder.AddPass(new CheckAmbiguousFunctions());
+            passBuilder.RunPasses(pass => pass.VisitLibrary(AstContext));
+            var @class = AstContext.FindClass("TestCheckAmbiguousFunctionsPass").FirstOrDefault();
+            Assert.IsNotNull(@class);
+            var overloads = @class.Methods.Where(m => m.Name == "Method");
+            var constMethod = overloads
+                .Where(m => m.IsConst && m.Parameters.Count == 0)
+                .FirstOrDefault();
+            var nonConstMethod = overloads
+                .Where(m => !m.IsConst && m.Parameters.Count == 0)
+                .FirstOrDefault();
+            Assert.IsNotNull(constMethod);
+            Assert.IsNotNull(nonConstMethod);
+            Assert.IsTrue(constMethod.GenerationKind == GenerationKind.None);
+            Assert.IsTrue(nonConstMethod.GenerationKind == GenerationKind.Generate);
+            var constMethodWithParam = overloads
+                .Where(m => m.IsConst && m.Parameters.Count == 1)
+                .FirstOrDefault();
+            var nonConstMethodWithParam = overloads
+                .Where(m => !m.IsConst && m.Parameters.Count == 1)
+                .FirstOrDefault();
+            Assert.IsNotNull(constMethodWithParam);
+            Assert.IsNotNull(nonConstMethodWithParam);
+            Assert.IsTrue(constMethodWithParam.GenerationKind == GenerationKind.None);
+            Assert.IsTrue(nonConstMethodWithParam.GenerationKind == GenerationKind.Generate);
+        }
     }
 }
diff --git a/tests/Native/Passes.h b/tests/Native/Passes.h
index 4d288b89..eba7caf1 100644
--- a/tests/Native/Passes.h
+++ b/tests/Native/Passes.h
@@ -52,3 +52,12 @@ enum
     UnnamedEnumB1,
     EnumUnnamedB2
 };
+
+struct TestCheckAmbiguousFunctionsPass
+{
+    // Tests removal of const method overloads
+    int Method();
+    int Method() const;
+    int Method(int x);
+    int Method(int x) const;
+};

From c8f266ef8563190ce834a155a3b82d331e806d83 Mon Sep 17 00:00:00 2001
From: Elias Holzer <elias@vvvv.org>
Date: Tue, 13 May 2014 16:54:43 +0200
Subject: [PATCH 2/2] Check for constness first in CheckAmbiguousFunctionPass
 before doing the check for default parameters.

Fixes test case from previous commit.
---
 src/Generator/Passes/CheckAmbiguousFunctions.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Generator/Passes/CheckAmbiguousFunctions.cs b/src/Generator/Passes/CheckAmbiguousFunctions.cs
index f0c67a89..5627dbaf 100644
--- a/src/Generator/Passes/CheckAmbiguousFunctions.cs
+++ b/src/Generator/Passes/CheckAmbiguousFunctions.cs
@@ -44,10 +44,10 @@ namespace CppSharp.Passes
 
                 if (!overload.IsGenerated) continue;
 
-                if (!CheckDefaultParameters(function, overload))
+                if (!CheckConstness(function, overload))
                     continue;
 
-                if (!CheckConstness(function, overload))
+                if (!CheckDefaultParameters(function, overload))
                     continue;
 
                 function.IsAmbiguous = true;