Added "delayed" generation of delegate signatures (follow-up)

[xanathar]

This is a reopening of #53, rebased on top of the latest main branch.

I apologize for not replying to the request of an example, sorry.

I'll show an example in this PR; I'm not 100% sure this is the best way to fix the issue, but we can start from this for a discussion.

---

Description

Just as before, with this patch if a delegate is found during the construction of a method, its declaration is still emitted, after all the other types have been.

This is implemented through an HashSet of forward declarations that is used as now for delegates, but can be expanded to include other item types in the future.

---

Example

Take this example Rust source:

#[no_mangle]
pub extern "C" fn set_callback(alloc_callback: extern "C" fn(size: usize, data: *const u16) -> *mut u8) {
    println!("Your callback is {alloc_callback:p}");
}

This CORRECTLY generates the following C# code:

namespace ExampleNamespace
{
    internal static unsafe partial class NativeMethods
    {
        const string __DllName = "example.dll";

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate byte* set_callback_alloc_callback_delegate(System.UIntPtr size, ushort* data);

        [DllImport(__DllName, EntryPoint = "set_callback", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void set_callback(set_callback_alloc_callback_delegate alloc_callback);
    }
}

So far so good. Now, that Rust declaration is nasty and would probably get refactored as:

type MyCallback = extern "C" fn(size: usize, data: *const u16) -> *mut u8;

#[no_mangle]
pub extern "C" fn set_callback(alloc_callback: MyCallback) {
    println!("Your callback is {alloc_callback:p}");
}

which produces

namespace ExampleNamespace
{
    internal static unsafe partial class NativeMethods
    {
        const string __DllName = "example.dll";

        [DllImport(__DllName, EntryPoint = "set_callback", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void set_callback(set_callback_alloc_callback_delegate alloc_callback);
    }
}

which is obviously bad because set_callback_alloc_callback_delegate's definition is nowhere to be found.

The proposed fix produces this version instead:

namespace ExampleNamespace
{
    internal static unsafe partial class NativeMethods
    {
        const string __DllName = "example.dll";

        [DllImport(__DllName, EntryPoint = "set_callback", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void set_callback(set_callback_alloc_callback_delegate alloc_callback);

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate byte* set_callback_alloc_callback_delegate(System.UIntPtr size, ushort* data);
    }
}

---

Differences from the version in PR #53

The code is verbatim the same with these small differences:

• in Added "delayed" generation of delegate signatures. #53 the delegate declaration was being generated at the namespace level (as it does for other types like structs and enums), now I moved it to be at the class level to follow what it would do for the first Rust code in the example above
• added public visibility modifier, given that the declaration is now inside the class and would default to private instead of internal
• added the [UnmanagedFunctionPointer(CallingConvention.Cdecl)] boilerplate

[neuecc]

sorry for delayed response and thank you for clarification.
Certainly, it seems useful.
I have a CONFLICT due to a merge of another branch, can you please fix it?
If so, we would like to check it out and incorporate it into the release process as soon as possible.

[xanathar]

Rebased, should have no conflicts.

[neuecc]

Hmm, I tried it with the current main branch, but

type MyCallback = extern "C" fn(size: usize, data: *const u16) -> *mut u8;

#[no_mangle]
pub extern "C" fn set_callback(alloc_callback: MyCallback) {
    println!("Your callback is {alloc_callback:p}");
}

This seems to be expanded to:

[DllImport(__DllName, EntryPoint = "set_callback", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
internal static extern void set_callback(delegate* unmanaged[Cdecl]<nuint, ushort*, byte*> alloc_callback);

[xanathar]

That's not how it expanded in my tests.
I wonder if it could be configuration or some other difference.

I will recheck, but I'm currently away from "decent computing devices" for a couple of weeks.

[xanathar]

I wonder if it could be configuration or some other difference.

It is configuration.

Namely, it works with csharp_use_function_pointer(true) but not with csharp_use_function_pointer(false). I'll check if it can be made to work in the second case without all this infrastructure.

[github-actions]

This PR is stale because it has been open 180 days with no activity. Remove stale label or comment or this will be closed in 30 days.