Fsharp: Compiler generates instance method while creating Action from static member

[gsomix]

Consider following code:

open System
type C =
    static member M() = ()
    static member CreateAction() =
        new Action(C.M)

Compiler generates a closure object for C.M reference and changes static member in Action for instanced one. Please see decompiled C# code:

public static class _
{
    public class C
    {
        public static void M()
        {
        }

        public static Action CreateAction()
        {
            return new Action(new CreateAction@5().Invoke);
        }
    }

    internal sealed class CreateAction@5
    {
        internal void Invoke()
        {
        }
    }
}

While it doesn't capture anything generated code could use reference to static member itself. It is not clear if such behavior has any performance impact but it may affect use of .NET libraries.

E.g. ILGPU requires static methods for describing computational kernels and compiles it to GPU code via Action delegates. Please see example.

[NatElkins]

More context for ILGPU here:

https://github.com/m4rs-mt/ILGPU.Samples/issues/7
https://github.com/NatElkins/Scratchpad/pull/1

[cartermp]

@dsyme any thoughts on this?

[dsyme]

I'm sure this can be fixed.

[gsomix]

@cartermp Could you please add labels to the issue? I'm afraid that it might get lost from sight. Thanks!

[cartermp]

You betcha

[abelbraaksma]

@gsomix, @MoFtZ, your example is a void function returning void. Is the issue specific to that, or is it related to any number of arguments (but still returning void)?

And is the issue the same (does it also create an instance method reference as opposed to static) when creating a delegate type in F# from a void-returning function? It would be great if a fix covers both cases.

[gsomix]

@abelbraaksma Yes, it's same.

open System

type MyAction2 = delegate of int -> unit
type MyAction3 = delegate of int * int -> unit

type C =
    static member M2(x: int) = Console.WriteLine(x)
    static member M3(x: int, y: int) = Console.WriteLine("{0} {1}", x, y)

    static member CreateAction2() =
        new Action<int>(C.M2)

    static member CreateAction3() =
        new Action<int, int>(fun x y -> C.M3(x, y))

    static member CreateMyAction2() =
        new MyAction2(C.M2)

    static member CreateMyAction3() =
        new MyAction3(fun x y -> C.M3(x, y))

Note also it's not possible to create multi-arguments delegate without involving lambda function.

[TIHan]

Note also it's not possible to create multi-arguments delegate without involving lambda function.

Yea, that is kinda of unfortunate. You would think it could be tupled: (x, y) because of the signature int * int -> unit - I remember @KevinRansom and I looked at this before and it does feel a little confusing.

[gsomix]

Thank you! It works fine.