Add NativeIntegerAttribute

[cston]

Background and Motivation

Allow annotating references to System.IntPtr and System.UIntPtr as native integers in metadata.
See spec.

Proposed API

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(
        AttributeTargets.Class |
        AttributeTargets.Event |
        AttributeTargets.Field |
        AttributeTargets.GenericParameter |
        AttributeTargets.Parameter |
        AttributeTargets.Property |
        AttributeTargets.ReturnValue,
        AllowMultiple = false,
        Inherited = false)]
    public sealed class NativeIntegerAttribute : Attribute
    {
        public NativeIntegerAttribute()
        {
            TransformFlags = new[] { true };
        }
        public NativeIntegerAttribute(bool[] flags)
        {
            TransformFlags = flags;
        }
        public IList<bool> TransformFlags { get; }
    }
}

Used by the C# compiler to represent type references to nint and nuint in metadata.

The C# compiler reserves the attribute for compiler use only.

If the attribute is not available in the compilation, the C# compiler will emit an internal attribute type with the same shape.

Usage Examples

Consider the following signature in C#:

static nint Sum(nint[] array)
{
}

In metadata:

[NativeInteger]
static System.IntPtr Sum(
    [NativeInteger(new[] { false, true })] System.IntPtr[] array)
{
}

[Dotnet-GitSync-Bot]

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[tannergooding]

CC. @terrajobst as an FYI

[terrajobst]

Video

• We didn't add NullableAttribute. We only added attributes that we expect users to reference explicitly by manually adding custom attributes. It seems this attribute would only be emitted and read by the compiler, so unless there is a reason, we'd not add it.
• Please reopen otherwise.

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(
        AttributeTargets.Class |
        AttributeTargets.Event |
        AttributeTargets.Field |
        AttributeTargets.GenericParameter |
        AttributeTargets.Parameter |
        AttributeTargets.Property |
        AttributeTargets.ReturnValue,
        AllowMultiple = false,
        Inherited = false)]
    public sealed class NativeIntegerAttribute : Attribute
    {
        public NativeIntegerAttribute()
        {
            TransformFlags = new[] { true };
        }
        public NativeIntegerAttribute(bool[] flags)
        {
            TransformFlags = flags;
        }
        public IList<bool> TransformFlags { get; }
    }
}

[jaredpar]

It seems this attribute would only be emitted and read by the compiler, so unless there is a reason, we'd not add it.

This logic seems to apply to DynamicAttribute and TupleElementNamesAttribute yet those are in the BCL.

We only added attributes that we expect users to reference explicitly by manually adding custom attributes

Why do we not consider the cases where users may wish to read the attributes from medatada? That is less important for this attribute but more important for the decision around NullableAttribute. Particularly because technologies like efcore do specifically read this attribute from metadata.