Part 1 of support for C# 12 InlineArray

[siegfriedpammer]

No description provided.

[siegfriedpammer]

@ds5678 this PR covers the basics of InlineArrays... before we can continue with params collections, we will have to add minimal support for collection expressions:

• Only use collection expression syntax, if the array type is an inline array type (target-typed to span) or a single-element span

Would you be interested in taking this on?

See some experiments here: https://sharplab.io/#v2:CYLg1APgAgTAjAWAFBQAwAIpwHQCUCuAdgC4CWAtgKbYDCA9uQA6kA2lATgMocBupAxpQDOAbmRQAzJhjoa6AN7J0y9AG0AkoRalClAILt2AQwCeACgAsASgC6SlZPRDi7fP2LoAsic4u3xe2VFJBVQ9EZ2Uh4jYkp0HQ8AfTEQlQBfJUDMKSwMAAUjY3IhTkYjQk1tXQNjcysFLNCoAHZMOFRsACk6HTMAIgAadEHhoxG+gCNx/j6rFNCMkKzHXPRS8voWNndSOgrCUjIjbQAvDjN64LCHVtyunsJ+oZHVPrHnqeeZmzmsxdDllJvL5XO50AAxOh0C5ZK7XdAAegRmFaqjgQxgQwkQwsNhE6AA7nR8CxgIQAOQeInsADWQwmlH4RnwQjiOiqcUKtSE6EKcUIdA8fX4dC2jLIewAtJQAB4RYRCXaEdAiwjOUFkCZsPqNFTAvxgrmmdAAXnQwEoADNmSxiPN4UaTKpUDZTeg4Pbro60a6zTBPWFvTBfegJAHQt6JCGLOGbrzDKYA4s0kA

using System;
using System.Runtime.CompilerServices;
public class C {
    [InlineArray(4)]
    public struct MyStruct
    {
        private int _;
    }
 
    public string ParamsSpanInlineArray() {
        return string.Join(", ", "a", "b", "c");
    }
 
    public string SpanCollectionInitializer() {
        return string.Join(", ", ["a", "b", "c"]);
    }
    
    public MyStruct Foo()
    {
        // return [1, 2, 3, 4]; wouldn't work, because inline arrays are not "collection-expression constructible"
        MyStruct array = default;
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;
        return array;
    }
}

[ds5678]

Would you be interested in taking this on?

Sure, I can work on this.

[dgrunwald]

argumentList.Arguments might be empty here.

[dgrunwald]

This doesn't make sense. A ResolveResult describes the semantics of a C# expression we have generated. If the C# expression doesn't change, it doesn't make sense to swap out the associated ResolveResult?

[dgrunwald]

Note that our conversion logic needs to consider all possible conversions (for overload resolution), not just the conversion actually picked in the IL program (that wouldn't allow us to detect if we're about to emit C# that would pick the wrong overload).

So InterpolatedStringResolveResult makes sense (it's associated with a special syntactic form of an argument expression); but InlineArrayResolveResult doesn't (there's no syntactic difference between an argument expression that is converted to span, and one that is passed as-is without conversion).

[siegfriedpammer]

How should we then represent the implicit conversion from an arbitrary struct type with the InlineArrayAttribute to (ReadOnly)Span<T>?

Given

[InlineArray(4)] struct MyArray { private int elem; }

MyArray GetArray() => default;

int GetIndex() => 0;

int item = GetArray()[GetIndex()];

the last expression is compiled down to (pseudo code, with some extra inlining):

int num = <PrivateImplementationDetails>.InlineArrayAsReadOnlySpan<MyArray, int>(GetArray(), 4)[GetIndex()];

what the transform does is: extract the first argument of InlineArrayAsReadOnlySpan swap the ResolveResult in order to account for the implicit conversion to ReadOnlySpan<int> and replace the call to InlineArrayAsReadOnlySpan with the first argument.

without the extra ResolveResult, we would get int num = ((ReadOnlySpan<int>)GetArray())[GetIndex()];.

[dgrunwald]

Your case is a bit of a red herring: the return value of GetArray() cannot be converted to ReadOnlySpan<int> (neither with an explicit cast nor with an implicit conversion), because this conversion only allows lvalues.
We need to treat that particular call combination (conversion to span followed by indexing) as a special case, maybe even introducing a special ILAst instruction for this combination.
For thinking about the conversion modelling, the indexing special case is actively misleading. There's it's more useful to consider Foo(some_array), where Foo has multiple overloads (some of which involve the conversion).

[dgrunwald]

In particular for conversion modeling you also you need to think about cases where the IL does not perform the conversion to span, but the C# code might unless we add explicit casts.
For example: in this example the explicit cast to (object) is required because the overload would otherwise be ambiguous. If our conversion machinery does not consider the span conversion to be possible, OR would think that the cast is not required, and we generate invalid code. Thus our conversion machinery needs to support span conversions in general, not just for a special resolve result.