Fix OpenGenericInterceptors not working with FromAction/FromFunc

monkey0506 · monkey0506 · commit 1ae391e05dd4 · 2024-10-05T18:21:55.000-05:00
diff --git a/ClosedGenericInterceptor.cs b/ClosedGenericInterceptor.cs
@@ -47,7 +47,10 @@ private string GetSourceText()
                 _ = sb.Append(reference.InterceptorAttributeSourceText).Append($"{Constants.NewLineIndent2}");
             }
             var method = InterceptsMethod;
-            var typeParameters = GetTypeParameters(method.ContainingInterface.Arity, method.Arity);
+            var typeParameters = Constants.InterceptorTypeParameters[method.ContainingInterface.Arity];
+            typeParameters = typeParameters.Length != 0 ?
+                $"<{typeParameters}>" :
+                typeParameters;
             _ = sb.Append
             (
      $@"[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -84,16 +87,5 @@ public static {method.ContainingInterface.FullName} {method.Name}{typeParameters
             }
             return sb.ToString();
         }
-        internal static string GetTypeParameters(int interfaceArity, int methodArity)
-        {
-            if (interfaceArity == 0)
-            {
-                return string.Empty;
-            }
-            int arity = interfaceArity + methodArity;
-            return arity == 1 ?
-                "<X>" :
-                $"<{string.Join(", ", Enumerable.Range(1, arity).Select(x => $"X{x}"))}>";
-        }
     }
 }
diff --git a/Constants.Actions.cs b/Constants.Actions.cs
@@ -1,4 +1,6 @@
-﻿namespace Monkeymoto.NativeGenericDelegates
+﻿using System.Linq;
+
+namespace Monkeymoto.NativeGenericDelegates
 {
     internal static partial class Constants
     {
diff --git a/Constants.cs b/Constants.cs
@@ -153,6 +153,12 @@ internal static partial class Constants
         private const string TypeParameters_T1_T15 = $"{TypeParameters_T1_T14}, T15";
         private const string TypeParameters_T1_T16 = $"{TypeParameters_T1_T15}, T16";
 
+        public static readonly string[] InterceptorTypeParameters =
+        [
+            .. TypeParameters.Select(static x => x.Replace('T', 'X')),
+            $"{TypeParameters_T1_T16.Replace('T', 'X')}, X17"
+        ];
+
         private static readonly string[] QualifiedTypeParameters =
             [.. TypeParameters.Select(x => x.Replace("T", "in T"))];
     }
diff --git a/MethodDescriptor.cs b/MethodDescriptor.cs
@@ -13,6 +13,7 @@ internal sealed class MethodDescriptor : IEquatable<MethodDescriptor>
         public string FirstParameterName { get; }
         public string FirstParameterType { get; }
         public string FullName { get; }
+        public string InterceptorParameters { get; }
         public bool IsFromFunctionPointer { get; }
         public string Name { get; }
         public string Parameters { get; }
@@ -54,8 +55,9 @@ IMethodSymbol methodSymbol
             Arity = methodSymbol.Arity;
             ContainingInterface = containingInterface;
             FullName = GetFullName(methodSymbol);
+            InterceptorParameters = GetParameters(getInterceptorParameters: true);
             Name = methodSymbol.Name;
-            Parameters = GetParameters();
+            Parameters = GetParameters(getInterceptorParameters: false);
             hashCode = Hash.Combine(Arity, ContainingInterface, Name);
         }
 
@@ -65,16 +67,22 @@ public bool Equals(MethodDescriptor? other) =>
             (Name == other.Name);
         public override int GetHashCode() => hashCode;
 
-        private string GetParameters()
+        private string GetParameters(bool getInterceptorParameters)
         {
             var marshalReturnAsParam = !ContainingInterface.IsAction ?
                 $"MarshalAsAttribute marshalReturnAs,{Constants.NewLineIndent3}" :
                 string.Empty;
             var marshalParamsAsParam = ContainingInterface.InvokeParameterCount != 0 ?
                 $"MarshalAsAttribute[] marshalParamsAs,{Constants.NewLineIndent3}" :
                 string.Empty;
+            var firstParameterType = FirstParameterType;
+            if (getInterceptorParameters && !IsFromFunctionPointer && (ContainingInterface.Arity > 0))
+            {
+                var typeParameters = Constants.InterceptorTypeParameters[ContainingInterface.Arity];
+                firstParameterType = $"{ContainingInterface.Category}<{typeParameters}>";
+            }
             return
-                $"{FirstParameterType} {FirstParameterName},{Constants.NewLineIndent3}{marshalReturnAsParam}" +
+                $"{firstParameterType} {FirstParameterName},{Constants.NewLineIndent3}{marshalReturnAsParam}" +
                 $"{marshalParamsAsParam}CallingConvention callingConvention";
         }
     }
diff --git a/OpenGenericInterceptors.cs b/OpenGenericInterceptors.cs
@@ -44,17 +44,14 @@ private string GetSourceText()
             {
                 Debug.Assert(attributes.ContainsKey(kv.Key));
                 var first = kv.Value.First();
-                var interfaceTypeParameters =
-                    ClosedGenericInterceptor.GetTypeParameters(first.Method.ContainingInterface.Arity, 0);
-                var interfaceName = $"{first.Method.ContainingInterface.Name}{interfaceTypeParameters}";
+                var typeParameters = Constants.InterceptorTypeParameters[first.Method.ContainingInterface.Arity];
+                typeParameters = typeParameters.Length != 0 ?
+                    $"<{typeParameters}>" :
+                    typeParameters;
+                var interfaceName = $"{first.Method.ContainingInterface.Name}{typeParameters}";
                 var methodHash = kv.Key.GetHashCode();
                 var methodName = first.Method.Name;
-                var parameters = first.Method.Parameters;
-                var typeParameters = ClosedGenericInterceptor.GetTypeParameters
-                (
-                    first.Method.ContainingInterface.Arity,
-                    first.Method.Arity
-                );
+                var parameters = first.Method.InterceptorParameters;
                 _ = sb.AppendLine().Append("    ").AppendLine
                 (
  $@"file static class NativeGenericDelegates_{(methodHash < 0 ? $"S{-methodHash}" : $"U{methodHash}")}
@@ -75,7 +72,8 @@ public static {interfaceName} {methodName}{typeParameters}
                 );
                 for (int i = 0; i < kv.Value.Count; ++i)
                 {
-                    var typeArguments = kv.Value[i].Method.ContainingInterface.TypeArguments;
+                    var method = kv.Value[i].Method;
+                    var typeArguments = method.ContainingInterface.TypeArguments;
                     if (typeArguments.Count == 1)
                     {
                         _ = sb.Append($"            if (typeof(X) == typeof({typeArguments[0]}))");
@@ -94,19 +92,23 @@ public static {interfaceName} {methodName}{typeParameters}
                         _ = sb.Append("            )");
                     }
                     _ = sb.Append(Constants.NewLineIndent3);
+                    var firstParam = method.FirstParameterName;
+                    if (!method.IsFromFunctionPointer)
+                    {
+                        firstParam = $"({method.ContainingInterface.Category}{method.ContainingInterface.TypeArgumentList})(object){firstParam}";
+                    }
                     if (kv.Value[i].Marshalling.StaticCallingConvention is not null)
                     {
                         _ = sb.AppendLine
                         (
          $@"{{
-                return ({interfaceName})(object)(new {kv.Value[i].ClassName}({kv.Value[i].Method.FirstParameterName}));
+                return ({interfaceName})(object)(new {kv.Value[i].ClassName}({firstParam}));
             }}"
                         );
                     }
                     else
                     {
                         var className = kv.Value[i].ClassName;
-                        var firstParam = kv.Value[i].Method.FirstParameterName;
                         _ = sb.AppendLine
                         (
          $@"{{

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,10 @@ private string GetSourceText()`
`47`	`47`	`_ = sb.Append(reference.InterceptorAttributeSourceText).Append($"{Constants.NewLineIndent2}");`
`48`	`48`	`}`
`49`	`49`	`var method = InterceptsMethod;`
`50`		`- var typeParameters = GetTypeParameters(method.ContainingInterface.Arity, method.Arity);`
	`50`	`+ var typeParameters = Constants.InterceptorTypeParameters[method.ContainingInterface.Arity];`
	`51`	`+ typeParameters = typeParameters.Length != 0 ?`
	`52`	`+ $"<{typeParameters}>" :`
	`53`	`+ typeParameters;`
`51`	`54`	`_ = sb.Append`
`52`	`55`	`(`
`53`	`56`	`$@"[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`@@ -84,16 +87,5 @@ public static {method.ContainingInterface.FullName} {method.Name}{typeParameters`
`84`	`87`	`}`
`85`	`88`	`return sb.ToString();`
`86`	`89`	`}`
`87`		`- internal static string GetTypeParameters(int interfaceArity, int methodArity)`
`88`		`- {`
`89`		`- if (interfaceArity == 0)`
`90`		`- {`
`91`		`- return string.Empty;`
`92`		`- }`
`93`		`- int arity = interfaceArity + methodArity;`
`94`		`- return arity == 1 ?`
`95`		`- "<X>" :`
`96`		`- $"<{string.Join(", ", Enumerable.Range(1, arity).Select(x => $"X{x}"))}>";`
`97`		`- }`
`98`	`90`	`}`
`99`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,6 @@`
`1`		`-namespace Monkeymoto.NativeGenericDelegates`
	`1`	`+using System.Linq;`
	`2`	`+`
	`3`	`+namespace Monkeymoto.NativeGenericDelegates`
`2`	`4`	`{`
`3`	`5`	`internal static partial class Constants`
`4`	`6`	`{`