Merge pull request #12 from samblackburn/delegate-signatures

Support for delegates with different method signatures

Author: samblackburn

NetDoc/Call.cs

@@ -10,13 +10,20 @@ namespace NetDoc
     public class Call
     {
         private readonly MemberReference m_Operand;
+        private readonly MethodReference? m_Delegate;
         private IEnumerable<string> ReferencedDlls { get; }
 
         public Call(Instruction instruction, IEnumerable<string> referencedDlls)
         {
             ReferencedDlls = referencedDlls;
             m_Operand = (MemberReference) instruction.Operand;
-            if (instruction.OpCode == OpCodes.Ldfld || instruction.OpCode == OpCodes.Stfld)
+            if (instruction.OpCode == OpCodes.Newobj &&
+                MethodReference?.Parameters.Select(x => x.ParameterType.Name).SequenceEqual([nameof(Object), nameof(IntPtr)]) == true &&
+                instruction.Previous.OpCode == OpCodes.Ldftn)
+            {
+                m_Delegate = (MethodReference)instruction.Previous.Operand;
+            }
+            else if (instruction.OpCode == OpCodes.Ldfld || instruction.OpCode == OpCodes.Stfld)
             {
                 IsStatic = false;
             }
@@ -85,10 +92,13 @@ private string BuildInvocation()
 
             if (m_Operand.Name == ".ctor")
             {
-                if (parameterDefs.Select(x => x.Name).SequenceEqual(["object", "method"]))
+                if (m_Delegate != null)
                 {
-                    // not sure how to infer the delegate signature
-                    return AssignToRandomVariable(MethodReference.DeclaringType, "_ => default");
+                    var args = string.Join(", ", m_Delegate.Parameters.Select((p, i) => $"{GetTypeName(p.ParameterType)} arg{i}"));
+                    var expression = m_Delegate.ReturnType.FullName == "System.Void"
+                        ? "{}"
+                        : CallToFactory(m_Delegate.ReturnType);
+                    return AssignToRandomVariable(MethodReference.DeclaringType, $"({args}) => {expression}");
                 }
 
                 return AssignToRandomVariable(MethodReference.DeclaringType, $"new {TypeWithGenerics}({parameters})");

Tests/DelegatesTests.cs

@@ -10,23 +10,31 @@ internal class DelegatesTests : TestMethods
     public void DelegateWithOneArgument()
     {
         var referenced = "public delegate bool MyDelegate(int i);";
-        var referencing = Class("MyDelegate MakeDelegate() => i => i > 3;", "ReferencingClass");
+        var referencing = Class("MyDelegate MakeDelegate() => Foo; bool Foo(int i) => i > 3;", "ReferencingClass");
         ContractAssertionShouldCompile(referencing, referenced);
     }
 
-    [Test, Ignore("Not sure how to infer the delegate's signature")]
+    [Test]
     public void DelegateWithTwoArguments()
     {
         var referenced = "public delegate bool MyDelegate(int i, int j);";
         var referencing = Class("MyDelegate MakeDelegate() => (i, j) => i > j;", "ReferencingClass");
         ContractAssertionShouldCompile(referencing, referenced);
     }
 
-    [Test, Ignore("Not sure how to infer the delegate's signature")]
+    [Test]
     public void VoidDelegate()
     {
         var referenced = "public delegate void MyDelegate(int i);";
         var referencing = Class("MyDelegate MakeDelegate() => i => {};", "ReferencingClass");
         ContractAssertionShouldCompile(referencing, referenced);
     }
+    
+    [Test]
+    public void ReusedDelegate()
+    {
+        var referenced = "public delegate bool MyDelegate(int i);";
+        var referencing = Class("MyDelegate[] MakeDelegates() => new MyDelegate[] {Foo, Foo}; bool Foo(int i) => i > 3;", "ReferencingClass");
+        ContractAssertionShouldCompile(referencing, referenced);
+    }
 }

Tests/TestFramework/ClrAssemblyCompiler.cs

@@ -47,8 +47,8 @@ private static string GetReferenceAssemblyPath(NetFrameworkVersion frameworkVers
             var packageDir = new DirectoryInfo(Path.Combine(PackagesFolder, "microsoft.netframework.referenceassemblies." + moniker));
             Assert.That(packageDir.Exists, $"Directory {packageDir.FullName} does not exist");
             var versions = packageDir.GetDirectories();
-            Assert.That(versions.Length, Is.EqualTo(1), $"Directory {packageDir.FullName} does not contain exactly one version");
-            var referenceDir = new DirectoryInfo(Path.Combine(versions.Single().FullName, "build", ".NETFramework", version));
+            Assert.That(versions.Length, Is.GreaterThanOrEqualTo(1), $"Directory {packageDir.FullName} does not contain exactly one version");
+            var referenceDir = new DirectoryInfo(Path.Combine(versions.First().FullName, "build", ".NETFramework", version));
             Assert.That(referenceDir.Exists, $"Directory {referenceDir.FullName} does not exist");
 
             return referenceDir.FullName;