diff --git a/src/Generator.Tests/AST/TestAST.cs b/src/Generator.Tests/AST/TestAST.cs
index 65a5548f..b62a51f4 100644
--- a/src/Generator.Tests/AST/TestAST.cs
+++ b/src/Generator.Tests/AST/TestAST.cs
@@ -256,5 +256,13 @@ namespace CppSharp.Generator.Tests.AST
             //Assert.AreEqual("const int& testConstRefSignature()", AstContext.FindClass("HasConstFunction").Single().FindMethod("testConstRefSignature").Signature);
             //Assert.AreEqual("const int& testStaticConstRefSignature()", AstContext.FindClass("HasConstFunction").Single().FindMethod("testStaticConstRefSignature").Signature);
         }
+
+        [Test]
+        public void TestAmbiguity()
+        {
+            new CheckAmbiguousFunctions { Driver = new Driver(new DriverOptions(), new TextDiagnosticPrinter()) }
+                .VisitLibrary(AstContext);
+            Assert.IsTrue(AstContext.FindClass("HasAmbiguousFunctions").Single().FindMethod("ambiguous").IsAmbiguous);            
+        }
     }
 }
diff --git a/src/Generator/Passes/CheckAmbiguousFunctions.cs b/src/Generator/Passes/CheckAmbiguousFunctions.cs
index e4958827..02272276 100644
--- a/src/Generator/Passes/CheckAmbiguousFunctions.cs
+++ b/src/Generator/Passes/CheckAmbiguousFunctions.cs
@@ -45,14 +45,12 @@ namespace CppSharp.Passes
 
                 if (!overload.IsGenerated) continue;
 
-                if (!CheckConstness(function, overload))
-                    continue;
-
-                if (!CheckDefaultParameters(function, overload))
-                    continue;
-
-                function.IsAmbiguous = true;
-                overload.IsAmbiguous = true;
+                if (CheckConstnessForAmbiguity(function, overload) ||
+                    CheckDefaultParametersForAmbiguity(function, overload))
+                {
+                    function.IsAmbiguous = true;
+                    overload.IsAmbiguous = true;
+                }
             }
 
             if (function.IsAmbiguous)
@@ -62,7 +60,7 @@ namespace CppSharp.Passes
             return true;
         }
 
-        static bool CheckDefaultParameters(Function function, Function overload)
+        private static bool CheckDefaultParametersForAmbiguity(Function function, Function overload)
         {
             var commonParameters = Math.Min(function.Parameters.Count, overload.Parameters.Count);
 
@@ -98,7 +96,7 @@ namespace CppSharp.Passes
             return true;
         }
 
-        static bool CheckConstness(Function function, Function overload)
+        private static bool CheckConstnessForAmbiguity(Function function, Function overload)
         {
             if (function is Method && overload is Method)
             {
@@ -110,17 +108,17 @@ namespace CppSharp.Passes
                 if (method1.IsConst && !method2.IsConst && sameParams)
                 {
                     method1.ExplicitlyIgnore();
-                    return false;
+                    return true;
                 }
 
                 if (method2.IsConst && !method1.IsConst && sameParams)
                 {
                     method2.ExplicitlyIgnore();
-                    return false;
+                    return true;
                 }
             }
 
-            return true;
+            return false;
         }
     }
 }
diff --git a/tests/Native/AST.h b/tests/Native/AST.h
index 16242979..dfc2159e 100644
--- a/tests/Native/AST.h
+++ b/tests/Native/AST.h
@@ -84,3 +84,10 @@ inline const TestTemplateClass2 operator+(const TestTemplateClass2& f1, const Te
 {
     return TestTemplateClass2();
 }
+
+class HasAmbiguousFunctions
+{
+public:
+    void ambiguous();
+    void ambiguous() const;
+};