diff --git a/src/Generator/Passes/CheckAmbiguousFunctions.cs b/src/Generator/Passes/CheckAmbiguousFunctions.cs
index de7557ce..009c7f4a 100644
--- a/src/Generator/Passes/CheckAmbiguousFunctions.cs
+++ b/src/Generator/Passes/CheckAmbiguousFunctions.cs
@@ -130,7 +130,7 @@ namespace CppSharp.Passes
             Function function, Function overload)
         {
             var functionParams = function.Parameters.Where(
-                p => p.Kind == ParameterKind.Regular && p.Type.IsAddress()).ToList();
+                p => p.Kind == ParameterKind.Regular).ToList();
             // It's difficult to handle this case for more than one parameter
             // For example, if we have:
             //     void f(float&, const int&);
@@ -141,14 +141,20 @@ namespace CppSharp.Passes
             if (functionParams.Count != 1)
                 return false;
             var overloadParams = overload.Parameters.Where(
-                p => p.Kind == ParameterKind.Regular && p.Type.IsAddress()).ToList();
+                p => p.Kind == ParameterKind.Regular).ToList();
             if (overloadParams.Count != 1)
                 return false;
 
             var parameterFunction = functionParams[0];
             var parameterOverload = overloadParams[0];
 
-            if (!parameterFunction.Type.GetPointee().Equals(parameterOverload.Type.GetPointee()))
+            var pointerParamFunction = parameterFunction.Type.Desugar() as PointerType;
+            var pointerParamOverload = parameterOverload.Type.Desugar() as PointerType;
+
+            if (pointerParamFunction == null || pointerParamOverload == null)
+                return false;
+
+            if (!pointerParamFunction.GetPointee().Equals(pointerParamOverload.GetPointee()))
                 return false;
 
             if (parameterFunction.IsConst && !parameterOverload.IsConst)
@@ -163,9 +169,6 @@ namespace CppSharp.Passes
                 return true;
             }
 
-            var pointerParamFunction = (PointerType) parameterFunction.Type;
-            var pointerParamOverload = (PointerType) parameterOverload.Type;
-
             if (pointerParamFunction.Modifier == PointerType.TypeModifier.RVReference &&
                 pointerParamOverload.Modifier != PointerType.TypeModifier.RVReference)
             {
diff --git a/tests/Common/Common.Tests.cs b/tests/Common/Common.Tests.cs
index 0a5bbc19..3ed285cb 100644
--- a/tests/Common/Common.Tests.cs
+++ b/tests/Common/Common.Tests.cs
@@ -195,6 +195,11 @@ public class CommonTests : GeneratorTestFixture
         var def = new DefaultParameters();
         def.Foo(1, 2);
         def.Bar();
+        using (Foo foo = new Foo())
+        {
+            common.hasPointerParam(foo, 0);
+            common.hasPointerParam(foo);
+        }
     }
 
     [Test]
diff --git a/tests/Common/Common.cpp b/tests/Common/Common.cpp
index 0861a2c2..a21fae10 100644
--- a/tests/Common/Common.cpp
+++ b/tests/Common/Common.cpp
@@ -647,3 +647,11 @@ void HasOverloadsWithDifferentPointerKindsToSameType::overload(int&& i)
 void HasOverloadsWithDifferentPointerKindsToSameType::overload(const int& i)
 {
 }
+
+void hasPointerParam(Foo* foo, int i)
+{
+}
+
+void hasPointerParam(const Foo& foo)
+{
+}
diff --git a/tests/Common/Common.h b/tests/Common/Common.h
index 818425e0..28887da0 100644
--- a/tests/Common/Common.h
+++ b/tests/Common/Common.h
@@ -1213,3 +1213,6 @@ public:
     void overload(int&& i);
     void overload(const int& i);
 };
+
+DLL_API void hasPointerParam(Foo* foo, int i);
+DLL_API void hasPointerParam(const Foo& foo);