Generate struct wrapper around function pointer to make a native delegate typedef (#1545)

* Add struct wrapper around function pointer

* Only generate the delegate when specifically asked. Otherwise leave as function pointer.

Author: jevansaks

src/Microsoft.Windows.CsWin32/Generator.Delegate.cs

@@ -151,4 +151,61 @@ private FunctionPointerParameterSyntax TranslateDelegateToFunctionPointer(TypeHa
 
         return FunctionPointerParameter(parameterTypeInfo.ToTypeSyntax(this.functionPointerTypeSettings, GeneratingElement.FunctionPointer, customAttributeHandles?.QualifyWith(this)).GetUnmarshaledType());
     }
+
+    // Generates an unsafe readonly struct that wraps the native function pointer for a delegate type definition.
+    // Structure:
+    // unsafe readonly struct <Name> { public readonly delegate* unmanaged<...> Value; public <Name>(delegate* unmanaged<...> value) => Value = value; public bool IsNull => Value is null; implicit conversions }
+    private StructDeclarationSyntax DeclareTypeDefStructForNativeFunctionPointer(TypeDefinition typeDef, Context context)
+    {
+        // Delegates are generally managed types, except when using source generators when they never are.
+        bool isManagedType = !this.UseSourceGenerators;
+        string name = this.GetMangledIdentifier(this.Reader.GetString(typeDef.Name), context.AllowMarshaling, isManagedType);
+
+        FunctionPointerTypeSyntax fpType = this.FunctionPointer(typeDef);
+
+        // public readonly delegate* unmanaged<...> Value;
+        FieldDeclarationSyntax valueField = FieldDeclaration(
+            VariableDeclaration(fpType.WithTrailingTrivia(TriviaList(Space)))
+                .AddVariables(VariableDeclarator(Identifier("Value"))))
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword), TokenWithSpace(SyntaxKind.ReadOnlyKeyword));
+
+        // public <Name>(delegate* unmanaged<...> value) => Value = value;
+        ConstructorDeclarationSyntax ctor = ConstructorDeclaration(Identifier(name))
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword))
+            .AddParameterListParameters(Parameter(Identifier("value")).WithType(fpType))
+            .WithExpressionBody(ArrowExpressionClause(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, IdentifierName("Value"), IdentifierName("value"))))
+            .WithSemicolonToken(SemicolonWithLineFeed);
+
+        // public static <Name> Null => default;
+        PropertyDeclarationSyntax nullProperty = PropertyDeclaration(IdentifierName(name).WithTrailingTrivia(Space), Identifier("Null"))
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword), TokenWithSpace(SyntaxKind.StaticKeyword))
+            .WithExpressionBody(ArrowExpressionClause(LiteralExpression(SyntaxKind.DefaultLiteralExpression)))
+            .WithSemicolonToken(SemicolonWithLineFeed);
+
+        // public bool IsNull => Value is null;
+        PropertyDeclarationSyntax isNullProperty = PropertyDeclaration(PredefinedType(TokenWithSpace(SyntaxKind.BoolKeyword)), Identifier("IsNull"))
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword))
+            .WithExpressionBody(ArrowExpressionClause(IsPatternExpression(IdentifierName("Value"), ConstantPattern(LiteralExpression(SyntaxKind.NullLiteralExpression)))))
+            .WithSemicolonToken(SemicolonWithLineFeed);
+
+        // public static implicit operator <Name>(delegate* unmanaged<...> value) => new(value);
+        ConversionOperatorDeclarationSyntax implicitFromPointer = ConversionOperatorDeclaration(Token(SyntaxKind.ImplicitKeyword), IdentifierName(name))
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword), TokenWithSpace(SyntaxKind.StaticKeyword))
+            .AddParameterListParameters(Parameter(Identifier("value")).WithType(fpType))
+            .WithExpressionBody(ArrowExpressionClause(ObjectCreationExpression(IdentifierName(name)).AddArgumentListArguments(Argument(IdentifierName("value")))))
+            .WithSemicolonToken(SemicolonWithLineFeed);
+
+        // public static implicit operator delegate* unmanaged<...>(<Name> value) => value.Value;
+        ConversionOperatorDeclarationSyntax implicitToPointer = ConversionOperatorDeclaration(Token(SyntaxKind.ImplicitKeyword), fpType)
+            .AddModifiers(TokenWithSpace(SyntaxKind.PublicKeyword), TokenWithSpace(SyntaxKind.StaticKeyword))
+            .AddParameterListParameters(Parameter(Identifier("value")).WithType(IdentifierName(name).WithTrailingTrivia(Space)))
+            .WithExpressionBody(ArrowExpressionClause(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName("value"), IdentifierName("Value"))))
+            .WithSemicolonToken(SemicolonWithLineFeed);
+
+        StructDeclarationSyntax result = StructDeclaration(Identifier(name))
+            .AddModifiers(TokenWithSpace(this.Visibility), TokenWithSpace(SyntaxKind.UnsafeKeyword), TokenWithSpace(SyntaxKind.ReadOnlyKeyword))
+            .AddMembers(valueField, ctor, nullProperty, isNullProperty, implicitFromPointer, implicitToPointer);
+
+        return result;
+    }
 }

src/Microsoft.Windows.CsWin32/Generator.cs

@@ -1483,8 +1483,9 @@ private IReadOnlyList<ISymbol> FindTypeSymbolsIfAlreadyAvailable(string fullyQua
             {
                 typeDeclaration =
                     this.IsUntypedDelegate(typeDef) ? this.DeclareUntypedDelegate(typeDef) :
-                    (this.options.AllowMarshaling && !this.useSourceGenerators) ? this.DeclareDelegate(typeDef) :
-                    null;
+                        context.AllowMarshaling ?
+                            (this.useSourceGenerators ? this.DeclareTypeDefStructForNativeFunctionPointer(typeDef, context) : this.DeclareDelegate(typeDef)) :
+                    this.DeclareTypeDefStructForNativeFunctionPointer(typeDef, context);
             }
             else
             {

src/Microsoft.Windows.CsWin32/HandleTypeHandleInfo.cs

@@ -178,6 +178,10 @@ internal override TypeSyntaxAndMarshaling ToTypeSyntax(TypeSyntaxSettings inputs
         }
         else if ((!inputs.AllowMarshaling || useComSourceGenerators) && isDelegate && inputs.Generator is object && !Generator.IsUntypedDelegate(delegateDefinition.Generator.Reader, delegateDefinition.Definition))
         {
+            // We would like to offer function pointers wrapped in structs (similar to the managed marshalling experience) but that
+            // makes them worse to work with. See https://github.com/dotnet/roslyn/issues/81234 and https://github.com/microsoft/CsWin32/issues/1542.
+            // If that ever gets better in C#, we can revisit this. If devs request the delegate by name (e.g. WNDPROC) then we will
+            // generate the struct and it does implicitly cast down to the function pointer.
             return new TypeSyntaxAndMarshaling(inputs.Generator.FunctionPointer(delegateDefinition));
         }
         else

test/CsWin32Generator.Tests/CsWin32GeneratorTests.cs

@@ -169,6 +169,15 @@ public async Task PointerReturnValueIsPreserved()
         Assert.Contains("winmdroot.Security.WinTrust.CRYPT_PROVIDER_DATA*", methodReturnTypes);
     }
 
+    [Fact]
+    public async Task DelegatesGetStructsGenerated()
+    {
+        this.nativeMethods.Add("TIMERPROC");
+        await this.InvokeGeneratorAndCompileFromFact();
+
+        var timerProcType = Assert.Single(this.FindGeneratedType("TIMERPROC"));
+    }
+
     public static IList<object[]> TestSignatureData => [
         ["IMFMediaKeySession", "get_KeySystem", "winmdroot.Foundation.BSTR* keySystem"],
         ["AddPrinterW", "AddPrinter", "string pName, uint Level, Span<byte> pPrinter"],