Add support for C# 12 inline array expressions

Author: siegfriedpammer

ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj

@@ -138,6 +138,7 @@
     <Compile Include="TestCases\ILPretty\MonoFixed.cs" />
     <Compile Include="TestCases\Pretty\Comparisons.cs" />
     <Compile Include="TestCases\Pretty\GloballyQualifiedTypeInStringInterpolation.cs" />
+    <Compile Include="TestCases\Pretty\InlineArrayTests.cs" />
     <Compile Include="TestCases\Pretty\Issue3406.cs" />
     <Compile Include="TestCases\Pretty\PointerArithmetic.cs" />
     <Compile Include="TestCases\Pretty\Issue3439.cs" />

ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs

@@ -749,6 +749,12 @@ public async Task PointerArithmetic([ValueSource(nameof(defaultOptions))] Compil
 			await RunForLibrary(cscOptions: cscOptions);
 		}
 
+		[Test]
+		public async Task InlineArrayTests([ValueSource(nameof(roslyn4OrNewerOptions))] CompilerOptions cscOptions)
+		{
+			await RunForLibrary(cscOptions: cscOptions);
+		}
+
 		async Task RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, Action<DecompilerSettings> configureDecompiler = null)
 		{
 			await Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CompilerOptions.Library, configureDecompiler);

ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineArrayTests.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
+{
+	public class InlineArrayTests
+	{
+		[InlineArray(16)]
+		public struct Byte16
+		{
+			private byte elem;
+		}
+
+		public byte Byte0()
+		{
+			return GetByte16()[0];
+		}
+
+		public byte Byte5()
+		{
+			return GetByte16()[5];
+		}
+
+		public byte ByteN()
+		{
+			return GetByte16()[GetIndex()];
+		}
+
+		public byte ByteN2()
+		{
+			return GetByte16()[GetIndex()];
+		}
+
+		public byte Byte0(Byte16 array, byte value)
+		{
+			return array[0] = value;
+		}
+
+		public byte Byte5(Byte16 array, byte value)
+		{
+			return array[5] = value;
+		}
+
+		public byte ByteN(Byte16 array, byte value)
+		{
+			return array[GetIndex()] = value;
+		}
+
+		public byte VariableSplitting(Byte16 array, byte value)
+		{
+			return array[GetIndex()] = (array[GetIndex() + 1] = value);
+		}
+
+		public void OverloadResolution()
+		{
+			Receiver(GetByte16());
+			Receiver((object)GetByte16());
+			Byte16 buffer = GetByte16();
+			Receiver((Span<byte>)buffer);
+			Byte16 buffer2 = GetByte16();
+			Receiver((ReadOnlySpan<byte>)buffer2);
+			Byte16 buffer3 = GetByte16();
+			ReceiverSpan((Span<byte>)buffer3);
+			Byte16 buffer4 = GetByte16();
+			ReceiverReadOnlySpan((ReadOnlySpan<byte>)buffer4);
+		}
+
+		public Byte16 GetByte16()
+		{
+			return default(Byte16);
+		}
+
+		public int GetIndex()
+		{
+			return 0;
+		}
+
+		public void Receiver(Span<byte> span)
+		{
+		}
+
+		public void Receiver(ReadOnlySpan<byte> span)
+		{
+		}
+
+		public void Receiver(Byte16 span)
+		{
+		}
+
+		public void Receiver(object span)
+		{
+		}
+
+		public void ReceiverSpan(Span<byte> span)
+		{
+		}
+
+		public void ReceiverReadOnlySpan(ReadOnlySpan<byte> span)
+		{
+		}
+	}
+}

ICSharpCode.Decompiler/CSharp/CallBuilder.cs

@@ -463,6 +463,23 @@ public ExpressionWithResolveResult Build(OpCode callOpCode, IMethod method,
 				return HandleImplicitConversion(method, argumentList.Arguments[0]);
 			}
 
+			if (settings.InlineArrays
+				&& method is { DeclaringType.FullName: "<PrivateImplementationDetails>", Name: "InlineArrayAsSpan" or "InlineArrayAsReadOnlySpan" }
+				&& argumentList.Length == 2)
+			{
+				argumentList.CheckNoNamedOrOptionalArguments();
+				var argument = argumentList.Arguments[0];
+				var targetType = method.ReturnType;
+				if (argument.Expression is DirectionExpression { FieldDirection: FieldDirection.In or FieldDirection.Ref, Expression: var lvalueExpr })
+				{
+					// `(TargetType)(in arg)` is invalid syntax.
+					// Also, `f(in arg)` is invalid when there's an implicit conversion involved.
+					argument = argument.UnwrapChild(lvalueExpr);
+				}
+				return new CastExpression(expressionBuilder.ConvertType(targetType), argument.Expression)
+					.WithRR(new ConversionResolveResult(targetType, argument.ResolveResult, Conversion.InlineArrayConversion));
+			}
+
 			if (settings.LiftNullables && method.Name == "GetValueOrDefault"
 				&& method.DeclaringType.IsKnownType(KnownTypeCode.NullableOfT)
 				&& method.DeclaringType.TypeArguments[0].IsKnownType(KnownTypeCode.Boolean)

ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs

@@ -3130,6 +3130,28 @@ protected internal override TranslatedExpression VisitLdElema(LdElema inst, Tran
 				.WithoutILInstruction().WithRR(new ByReferenceResolveResult(expr.ResolveResult, ReferenceKind.Ref));
 		}
 
+		protected internal override TranslatedExpression VisitLdElemaInlineArray(LdElemaInlineArray inst, TranslationContext context)
+		{
+			TranslatedExpression arrayExpr = TranslateTarget(
+				inst.Array,
+				nonVirtualInvocation: true,
+				memberStatic: false,
+				memberDeclaringType: inst.Type
+			);
+			var inlineArrayElementType = GetInlineArrayElementType(inst.Type.GetDefinition());
+			IndexerExpression indexerExpr = new IndexerExpression(
+					arrayExpr, inst.Indices.Select(i => TranslateArrayIndex(i).Expression)
+			);
+			TranslatedExpression expr = indexerExpr.WithILInstruction(inst).WithRR(new ResolveResult(inlineArrayElementType));
+			return new DirectionExpression(FieldDirection.Ref, expr)
+				.WithoutILInstruction().WithRR(new ByReferenceResolveResult(expr.ResolveResult, ReferenceKind.Ref));
+
+			IType GetInlineArrayElementType(ITypeDefinition arrayType)
+			{
+				return arrayType?.Fields.SingleOrDefault()?.Type ?? SpecialType.UnknownType;
+			}
+		}
+
 		TranslatedExpression TranslateArrayIndex(ILInstruction i)
 		{
 			var input = Translate(i);

ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs

@@ -142,7 +142,7 @@ private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType,
 				if (c != Conversion.None)
 					return c;
 			}
-			if (resolveResult is InterpolatedStringResolveResult isrr)
+			if (resolveResult is InterpolatedStringResolveResult)
 			{
 				if (toType.IsKnownType(KnownTypeCode.IFormattable) || toType.IsKnownType(KnownTypeCode.FormattableString))
 					return Conversion.ImplicitInterpolatedStringConversion;

ICSharpCode.Decompiler/DecompilerSettings.cs

@@ -164,12 +164,13 @@ public void SetLanguageVersion(CSharp.LanguageVersion languageVersion)
 			{
 				refReadOnlyParameters = false;
 				usePrimaryConstructorSyntaxForNonRecordTypes = false;
+				inlineArrays = false;
 			}
 		}
 
 		public CSharp.LanguageVersion GetMinimumRequiredVersion()
 		{
-			if (refReadOnlyParameters || usePrimaryConstructorSyntaxForNonRecordTypes)
+			if (refReadOnlyParameters || usePrimaryConstructorSyntaxForNonRecordTypes || inlineArrays)
 				return CSharp.LanguageVersion.CSharp12_0;
 			if (scopedRef || requiredMembers || numericIntPtr || utf8StringLiterals || unsignedRightShift || checkedOperators)
 				return CSharp.LanguageVersion.CSharp11_0;
@@ -2053,6 +2054,24 @@ public bool UsePrimaryConstructorSyntaxForNonRecordTypes {
 			}
 		}
 
+		bool inlineArrays = true;
+
+		/// <summary>
+		/// Gets/Sets whether C# 12.0 inline array uses should be transformed.
+		/// </summary>
+		[Category("C# 12.0 / VS 2022.8")]
+		[Description("DecompilerSettings.InlineArrays")]
+		public bool InlineArrays {
+			get { return inlineArrays; }
+			set {
+				if (inlineArrays != value)
+				{
+					inlineArrays = value;
+					OnPropertyChanged();
+				}
+			}
+		}
+
 		bool separateLocalVariableDeclarations = false;
 
 		/// <summary>

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -107,6 +107,7 @@
     <Compile Include="DecompilationProgress.cs" />
     <Compile Include="Disassembler\IEntityProcessor.cs" />
     <Compile Include="Disassembler\SortByNameProcessor.cs" />
+    <Compile Include="IL\Transforms\InlineArrayTransform.cs" />
     <Compile Include="IL\Transforms\RemoveUnconstrainedGenericReferenceTypeCheck.cs" />
     <Compile Include="Metadata\MetadataFile.cs" />
     <Compile Include="Metadata\ModuleReferenceMetadata.cs" />