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,69 @@
+using System.Runtime.CompilerServices;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
+{
+	public class InlineArrayTests
+	{
+		[InlineArray(16)]
+		public struct Byte16
+		{
+			private byte elem;
+		}
+
+		[InlineArray(4)]
+		public struct Int128
+		{
+			private int 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 Byte16 GetByte16()
+		{
+			return default(Byte16);
+		}
+
+		public int GetIndex()
+		{
+			return 0;
+		}
+	}
+}

ICSharpCode.Decompiler/CSharp/Annotations.cs

@@ -159,6 +159,10 @@ public static ISymbol GetSymbol(this AstNode node)
 					return ldVirtDelegate.Method;
 				}
 			}
+			if (rr is InlineArrayResolveResult iarr)
+			{
+				return iarr.ArrayType.GetSymbol();
+			}
 			return rr?.GetSymbol();
 		}
 

ICSharpCode.Decompiler/CSharp/CallBuilder.cs

@@ -435,6 +435,29 @@ public ExpressionWithResolveResult Build(OpCode callOpCode, IMethod method,
 						argumentList.GetArgumentResolveResults(), isExpandedForm: argumentList.IsExpandedForm, isDelegateInvocation: true));
 			}
 
+			if (settings.InlineArrays && method.DeclaringType.FullName == "<PrivateImplementationDetails>")
+			{
+				var unwrappedTarget = argumentList.Arguments[0].Expression;
+				if (unwrappedTarget is DirectionExpression dirExpr)
+					unwrappedTarget = dirExpr.Expression;
+				switch (method.Name)
+				{
+					case "InlineArrayAsSpan":
+					case "InlineArrayAsReadOnlySpan":
+						var arrayResolveResult = unwrappedTarget.GetResolveResult();
+						unwrappedTarget.RemoveAnnotations<ResolveResult>();
+						return unwrappedTarget.Detach().WithRR(new InlineArrayResolveResult(arrayResolveResult, method.ReturnType));
+					case "InlineArrayFirstElementRef":
+					case "InlineArrayFirstElementRefReadOnly":
+						return new IndexerExpression(unwrappedTarget.Detach(), new PrimitiveExpression(0))
+							.WithRR(new ResolveResult(method.ReturnType.UnwrapByRef()));
+					case "InlineArrayElementRef":
+					case "InlineArrayElementRefReadOnly":
+						return new IndexerExpression(unwrappedTarget.Detach(), argumentList.Arguments[1])
+							.WithRR(new ResolveResult(method.ReturnType.UnwrapByRef()));
+				}
+			}
+
 			if (settings.StringInterpolation && IsInterpolatedStringCreation(method, argumentList))
 			{
 				var result = HandleStringInterpolation(method, argumentList);

ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs

@@ -142,11 +142,16 @@ 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;
 			}
+			if (resolveResult is InlineArrayResolveResult)
+			{
+				if (toType.Equals(resolveResult.Type))
+					return Conversion.InlineArrayConversion;
+			}
 			if (resolveResult.Type.Kind == TypeKind.Dynamic)
 				return Conversion.ImplicitDynamicConversion;
 			c = AnonymousFunctionConversion(resolveResult, toType);

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

@@ -153,6 +153,7 @@
     <Compile Include="Metadata\MetadataGenericContext.cs" />
     <Compile Include="Metadata\ReferenceLoadInfo.cs" />
     <Compile Include="Properties\DecompilerVersionInfo.cs" />
+    <Compile Include="Semantics\InlineArrayResolveResult.cs" />
     <Compile Include="TypeSystem\ITypeDefinitionOrUnknown.cs" />
     <Compile Include="Util\BitOperations.cs" />
     <Compile Include="Util\DelegateComparer.cs" />

ICSharpCode.Decompiler/Semantics/Conversion.cs

@@ -87,6 +87,11 @@ public static Conversion EnumerationConversion(bool isImplicit, bool isLifted)
 		/// </summary>
 		public static readonly Conversion ThrowExpressionConversion = new BuiltinConversion(true, 11);
 
+		/// <summary>
+		/// C# 12 inline array implicitly being converted to <see cref="System.Span{T}"/> or <see cref="System.ReadOnlySpan{T}"/>.
+		/// </summary>
+		public static readonly Conversion InlineArrayConversion = new BuiltinConversion(true, 12);
+
 		public static Conversion UserDefinedConversion(IMethod operatorMethod, bool isImplicit, Conversion conversionBeforeUserDefinedOperator, Conversion conversionAfterUserDefinedOperator, bool isLifted = false, bool isAmbiguous = false)
 		{
 			if (operatorMethod == null)

ICSharpCode.Decompiler/Semantics/InlineArrayResolveResult.cs

@@ -0,0 +1,36 @@
+// Copyright (c) 2025 Siegfried Pammer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System.Diagnostics;
+
+using ICSharpCode.Decompiler.TypeSystem;
+
+namespace ICSharpCode.Decompiler.Semantics
+{
+	public class InlineArrayResolveResult : ResolveResult
+	{
+		public InlineArrayResolveResult(ResolveResult arrayType, IType spanType)
+			: base(spanType)
+		{
+			Debug.Assert(spanType.IsKnownType(KnownTypeCode.SpanOfT) || spanType.IsKnownType(KnownTypeCode.ReadOnlySpanOfT));
+			ArrayType = arrayType;
+		}
+
+		public ResolveResult ArrayType { get; }
+	}
+}