UnsafeAccessor does not work for generic constructors, .NET 9

[mgravell]

Description

This ticket suggests that this should work from 9.0 Preview 4, however this fails in 9.0 GA:

using System.Runtime.CompilerServices;

// this works fine
Console.WriteLine(Hack.CreateFoo());

// this doesn't work
Console.WriteLine(Hack.CreateBar<int>());

// this doesn't work
Bar<int> evil = (Bar<int>)RuntimeHelpers.GetUninitializedObject(typeof(Bar<int>));
Hack.HacketyHackHack(evil);
Console.WriteLine(evil);

static class Hack
{
    [UnsafeAccessor(UnsafeAccessorKind.Constructor)]
    internal static extern Foo CreateFoo();

    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = ".ctor")]
    internal extern static void HacketyHackHack<T>(Bar<T> obj);

    [UnsafeAccessor(UnsafeAccessorKind.Constructor)]
    internal static extern Bar<T> CreateBar<T>();
}
class Foo
{
    private readonly string s = ".ctor has run";
    public override string ToString() => s;
    private Foo() { }
}
class Bar<T>
{
    private readonly string s = ".ctor has run; " + typeof(T).Name;
    public override string ToString() => s;
    private Bar() { }
}

Reproduction Steps

as above

Expected behavior

it works

Actual behavior

Unhandled exception. System.InvalidProgramException: Generic type constraints do not match.
   at Hack.CreateBar[T]()
   at Program.<Main>$(String[] args) in C:\Users\marcg\source\repos\ConsoleApp4\ConsoleApp4\Program.cs:line 7

Regression?

No response

Known Workarounds

No response

Configuration

No response

Other information

No response

[vcsjones]

Where T is declared seems to matter. This works:

using System;
using System;
using System.Runtime.CompilerServices;

Hack<int>.CreateBar();

Bar<int> evil = (Bar<int>)RuntimeHelpers.GetUninitializedObject(typeof(Bar<int>));
Console.WriteLine(Hack<short>.CreateBar());
Hack<int>.HacketyHackHack(evil);
Console.WriteLine(evil);

static class Hack<T>
{

    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = ".ctor")]
    internal extern static void HacketyHackHack(Bar<T> obj);

    [UnsafeAccessor(UnsafeAccessorKind.Constructor)]
    internal static extern Bar<T> CreateBar();
}

class Bar<T>
{
    private readonly string s = ".ctor has run; " + typeof(T).Name;
    public override string ToString() => s;
    private Bar() { }
}

[mgravell]

Useful workaround @vcsjones ! (I haven't verified, but will do tomorrow)

[jkotas]

cc @AaronRobinsonMSFT

[AaronRobinsonMSFT]

Useful workaround @vcsjones ! (I haven't verified, but will do tomorrow)

@mgravell This isn't a "workaround", it is how the feature works. See the following comment in the Remarks section of the documentation.

Generic parameters are supported since .NET 9. Generic parameters must match the target in form and index (that is, type parameters must be type parameters and method parameters must be method parameters).

In your example the T for Bar<> is a type parameter, but in HacketyHackHack<T>(Bar<T> obj) and CreateBar<T>(), T is a method parameter. The approach demonstrated in the documentation and in #110054 (comment) makes the T a type parameter and therefore the look-up works.

Please let me know if the documentation could be updated to help clarify things.

[mgravell]

Ok, this is reader error. There's even examples. I personally didn't find the exception cear, but I can't say that it is incorrect. Thanks for the assist.

[teo-tsirpanis]

We can't add analyzers about it because of reference assemblies, but I wonder if a build tool that has a whole-program view like ilc or crossgen could warn that an unsafe accessor does not have a valid target.

[AaronRobinsonMSFT]

We can't add analyzers about it because of reference assemblies, but I wonder if a build tool that has a whole-program view like ilc or crossgen could warn that an unsafe accessor does not have a valid target.

Yes it can. It is what native AOT does for this scenario and should warn. Note that UnsafeAccessorAttribute is a very advanced scenario and wasn't designed to be consumed directly. It is in the same bucket as most uses of Unsafe APIs - a best effort on errors and we defer to documentation for guidance.

[jkotas]

It is what native AOT does for this scenario and should warn.

Native AOT compilation does not and should not warn when the UnsafeAccessorAttribute target is missing. UnsafeAccessorAttribute is faster version of regular reflection. Native AOT compilation does not warn when regular reflection is used to find non-existing target either.