Fixing a null ref exception related to function pointers and interfaces (#2354)

Author: tannergooding

src/linker/Linker/TypeMapInfo.cs

@@ -369,6 +369,9 @@ static bool TypeMatch (TypeSpecification a, TypeSpecification b)
 			if (a is IModifierType mta)
 				return TypeMatch (mta, (IModifierType) b);
 
+			if (a is FunctionPointerType fpta)
+				return TypeMatch (fpta, (FunctionPointerType) b);
+
 			return TypeMatch (a.ElementType, b.ElementType);
 		}
 
@@ -407,6 +410,39 @@ static bool TypeMatch (GenericParameter a, GenericParameter b)
 			return true;
 		}
 
+		static bool TypeMatch (FunctionPointerType a, FunctionPointerType b)
+		{
+			if (a.HasParameters != b.HasParameters)
+				return false;
+
+			if (a.CallingConvention != b.CallingConvention)
+				return false;
+
+			// we need to track what the generic parameter represent - as we cannot allow it to
+			// differ between the return type or any parameter
+			if (a.ReturnType is not TypeReference aReturnType ||
+				b.ReturnType is not TypeReference bReturnType ||
+				!TypeMatch (aReturnType, bReturnType))
+				return false;
+
+			if (!a.HasParameters)
+				return true;
+
+			var ap = a.Parameters;
+			var bp = b.Parameters;
+			if (ap.Count != bp.Count)
+				return false;
+
+			for (int i = 0; i < ap.Count; i++) {
+				if (a.Parameters[i].ParameterType is not TypeReference aParameterType ||
+					b.Parameters[i].ParameterType is not TypeReference bParameterType ||
+					!TypeMatch (aParameterType, bParameterType))
+					return false;
+			}
+
+			return true;
+		}
+
 		static bool TypeMatch (TypeReference a, TypeReference b)
 		{
 			if (a is TypeSpecification || b is TypeSpecification) {

test/Mono.Linker.Tests.Cases/FunctionPointers/CanCompileInterfaceWithFunctionPointerParameter.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+
+namespace Mono.Linker.Tests.Cases.FunctionPointers
+{
+	[SetupCompileArgument ("/unsafe")]
+	unsafe class CanCompileInterfaceWithFunctionPointerParameter
+	{
+		public static void Main ()
+		{
+			new CanCompileInterfaceWithFunctionPointerParameter.B ().Method (null);
+		}
+
+		[KeptMember (".ctor()")]
+		class B : I
+		{
+			public void Unused (delegate* unmanaged<void> fnptr)
+			{
+			}
+
+			[Kept]
+			public void Method (delegate* unmanaged<void> fnptr)
+			{
+			}
+		}
+
+		interface I
+		{
+			void Unused (delegate* unmanaged<void> fnptr);
+
+			void Method (delegate* unmanaged<void> fnptr);
+		}
+	}
+}

test/Mono.Linker.Tests.Cases/FunctionPointers/CanCompileMethodWithFunctionPointerParameter.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+
+namespace Mono.Linker.Tests.Cases.FunctionPointers
+{
+	[SetupCompileArgument ("/unsafe")]
+	unsafe class CanCompileMethodWithFunctionPointerParameter
+	{
+		public static void Main ()
+		{
+			new CanCompileMethodWithFunctionPointerParameter.B ().Method (null);
+		}
+
+		[KeptMember (".ctor()")]
+		class B
+		{
+			public void Unused (delegate* unmanaged<void> fnptr)
+			{
+			}
+
+			[Kept]
+			public void Method (delegate* unmanaged<void> fnptr)
+			{
+			}
+		}
+	}
+}

test/Mono.Linker.Tests/TestCases/TestDatabase.cs

@@ -86,6 +86,11 @@ public static IEnumerable<TestCaseData> FeatureSettingsTests ()
 			return NUnitCasesBySuiteName ("FeatureSettings");
 		}
 
+		public static IEnumerable<TestCaseData> FunctionPointersTests ()
+		{
+			return NUnitCasesBySuiteName ("FunctionPointers");
+		}
+
 		public static IEnumerable<TestCaseData> GenericsTests ()
 		{
 			return NUnitCasesBySuiteName ("Generics");

test/Mono.Linker.Tests/TestCases/TestSuites.cs

@@ -103,6 +103,12 @@ public void FeatureSettingsTests (TestCase testCase)
 			Run (testCase);
 		}
 
+		[TestCaseSource (typeof (TestDatabase), nameof (TestDatabase.FunctionPointersTests))]
+		public void FunctionPointerTests (TestCase testCase)
+		{
+			Run (testCase);
+		}
+
 		[TestCaseSource (typeof (TestDatabase), nameof (TestDatabase.GenericsTests))]
 		public void GenericsTests (TestCase testCase)
 		{