Issues with proposal of lowering safe buffer to a struct attributed with InlineArray

[hez2010]

The Problem

The proposal https://github.com/dotnet/csharplang/blob/main/proposals/inline-arrays.md uses an approach that lowers int[4] to a generated Buffer4<int>, but by using the tricky generated Buffer4<int> approach instead of introducing the real int[4] type from IL, you are significantly breaking the functionality of type system and ABI.

When developers expose a int[4] in an API, they expect

1. they can pass any data of a type that is compatible with int[4]
2. type can pass any data of int[4] to a parameter that has a compatible type, such as int[]
3. they can use reflection to instantiate an instance of type int[4] without need of knowing what the actual lowered type is in advance
4. they expect that typeof(int[4]) == typeof(int[4]) which is the fundamental of a type system.

Besides all above expectations cannot be meet, this proposal will also bring significant problems to the type system: the type I write is not the type I get.

Thinking about below two cases:

If we cannot use typeof(int[4])

We now can use typeof(int[]) to get the int[] type, but we cannot use typeof(int[4]) to get the int[4] type, instead we can only use typeof(Buffer4<int>) to get a type that being lowered in the assembly that contains this type. Isn't it weird?

Besides, if one Buffer4<int> from assembly A and another Buffer4<int> from assembly B, will typeof(A.Buffer4<int>) == typeof(B.Buffer4<int>) return true? Apparently it should because they are both the same type int[4], but base on the implementation details A.Buffer4<int> and B.Buffer4<int> are actually two different types, so it shouldn't. How will you resolve this issue?

If we can use typeof(int[4])

Assuming we have below code in assembly A:

public bool Foo(Type type)
{
    return type == typeof(int[4]);
}

Now in assembly B we call the method Foo defined in the assembly A:

• will Foo(typeof(int[4])) return true?
• will Foo(B.Buffer4<int>) return true?

This has the same issue with the previous case.

Despite the typeof(int[4]) issue

Assuming we have a method with signature void FooA(int[4] buffer) and a method with signature void FooB(int[4] buffer) defined in assembly A and B, respectively.

Will typeof(A.Program).GetMethod("FooA").GetParameters()[0].ParameterType == typeof(B.Program).GetMethod("FooB").GetParameters()[0].ParameterType return true? Apparently it should, but it can't because those two int[4] types are different.

Conclusion and Solution

We can definitely allow developers to define their own safe buffer types using InlineArray, but we must not allow the type T[const] to be lowered to another generated struct that attributed with InlineArray because once you allows it, you won't be able to fix this in future version of C# because tons of libraries will start to expose their safe buffer in public APIs, which will introduce significant problem to the type system.

Alternatively we can make the lowered struct type internal so it won't be able to cross the boundary of assembly.

The best solution is to introduce support for safe fixed buffer type in IL directly, so it can be safely used across assemblies.

[jnm2]

cc: @AlekseyTs, others?

[333fred]

This was brought up during LDM today. I'll have notes out later.

[AlekseyTs]

I cannot say that I am sympathetic to all the concerns brought up here, especially those stated as strong as: "you are significantly breaking the functionality of type system and ABI." However, LDM decided to not go with the proposed syntax for now.

[jnm2]

Notes are now out, addressing many of these points: https://github.com/dotnet/csharplang/blob/main/meetings/2023/LDM-2023-05-01.md#fixed-size-buffers