Add support for C# 10 record structs.

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

@@ -1,7 +1,10 @@
 using System;
+using System.Runtime.InteropServices;
 
 namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
 {
+	internal class RecordClasses
+	{
 		public record Base(string A);
 
 		public record CopyCtor(string A)
@@ -122,6 +125,108 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
 
 			public abstract string AbstractProp { get; }
 		}
+
+	}
+	internal class RecordStructs
+	{
+		public record struct Base(string A);
+
+		public record CopyCtor(string A)
+		{
+			protected CopyCtor(CopyCtor _)
+			{
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential, Size = 1)]
+		public record struct Empty;
+
+		public record struct Fields
+		{
+			public int A;
+			public double B;
+			public object C;
+			public dynamic D;
+			public string S;
+		}
+
+		public record struct Interface(int B) : IRecord;
+
+		public interface IRecord
+		{
+		}
+
+		public record struct Pair<A, B>
+		{
+			public A First { get; init; }
+			public B Second { get; init; }
+		}
+
+		public record struct PairWithPrimaryCtor<A, B>(A First, B Second);
+
+		public record struct PrimaryCtor(int A, string B);
+		public record struct PrimaryCtorWithAttribute([RecordTest("param")] [property: RecordTest("property")][field: RecordTest("field")] int a);
+		public record struct PrimaryCtorWithField(int A, string B)
+		{
+			public double C = 1.0;
+			public string D = A + B;
+		}
+		public record struct PrimaryCtorWithInParameter(in int A, in string B);
+		public record struct PrimaryCtorWithProperty(int A, string B)
+		{
+			public double C { get; init; } = 1.0;
+			public string D { get; } = A + B;
+		}
+
+		public record struct Properties
+		{
+			public int A { get; set; }
+			public int B { get; }
+			public int C => 43;
+			public object O { get; set; }
+			public string S { get; set; }
+			public dynamic D { get; set; }
+
+			public Properties()
+			{
+				A = 41;
+				B = 42;
+				O = null;
+				S = "Hello";
+				D = null;
+			}
+		}
+
+		[AttributeUsage(AttributeTargets.All)]
+		public class RecordTestAttribute : Attribute
+		{
+			public RecordTestAttribute(string name)
+			{
+			}
+		}
+
+		public class WithExpressionTests
+		{
+			public Fields Test(Fields input)
+			{
+				return input with {
+					A = 42,
+					B = 3.141,
+					C = input
+				};
+			}
+			public Fields Test2(Fields input)
+			{
+				return input with {
+					A = 42,
+					B = 3.141,
+					C = input with {
+						A = 43
+					}
+				};
+			}
+		}
+	}
 }
 namespace System.Runtime.CompilerServices
 {

ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs

@@ -505,6 +505,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			typeSystemAstBuilder.UseNullableSpecifierForValueTypes = settings.LiftNullables;
 			typeSystemAstBuilder.SupportInitAccessors = settings.InitAccessors;
 			typeSystemAstBuilder.SupportRecordClasses = settings.RecordClasses;
+			typeSystemAstBuilder.SupportRecordStructs = settings.RecordStructs;
 			return typeSystemAstBuilder;
 		}
 
@@ -1264,7 +1265,11 @@ namespace ICSharpCode.Decompiler.CSharp
 					// e.g. DelegateDeclaration
 					return entityDecl;
 				}
-				bool isRecord = settings.RecordClasses && typeDef.IsRecord;
+				bool isRecord = typeDef.Kind switch {
+					TypeKind.Class => settings.RecordClasses && typeDef.IsRecord,
+					TypeKind.Struct => settings.RecordStructs && typeDef.IsRecord,
+					_ => false,
+				};
 				RecordDecompiler recordDecompiler = isRecord ? new RecordDecompiler(typeSystem, typeDef, settings, CancellationToken) : null;
 				if (recordDecompiler != null)
 					decompileRun.RecordDecompilers.Add(typeDef, recordDecompiler);
@@ -1311,7 +1316,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				IEnumerable<IMember> allOrderedMembers = RequiresNativeOrdering(typeDef) ? GetMembersWithNativeOrdering(typeDef) :
 					fieldsAndProperties.Concat(typeDef.Events).Concat(typeDef.Methods);
 
-				var allOrderedEntities = typeDef.NestedTypes.Concat<IEntity>(allOrderedMembers);
+				var allOrderedEntities = typeDef.NestedTypes.Concat<IEntity>(allOrderedMembers).ToArray();
 
 				// Decompile members that are not compiler-generated.
 				foreach (var entity in allOrderedEntities)

ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs

@@ -232,6 +232,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			astBuilder.UseNullableSpecifierForValueTypes = (ConversionFlags & ConversionFlags.UseNullableSpecifierForValueTypes) != 0;
 			astBuilder.SupportInitAccessors = (ConversionFlags & ConversionFlags.SupportInitAccessors) != 0;
 			astBuilder.SupportRecordClasses = (ConversionFlags & ConversionFlags.SupportRecordClasses) != 0;
+			astBuilder.SupportRecordStructs = (ConversionFlags & ConversionFlags.SupportRecordStructs) != 0;
 			return astBuilder;
 		}
 

ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpOutputVisitor.cs

@@ -1579,6 +1579,11 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 					WriteKeyword(Roles.RecordKeyword);
 					braceStyle = policy.ClassBraceStyle;
 					break;
+				case ClassType.RecordStruct:
+					WriteKeyword(Roles.RecordStructKeyword);
+					WriteKeyword(Roles.StructKeyword);
+					braceStyle = policy.StructBraceStyle;
+					break;
 				default:
 					WriteKeyword(Roles.ClassKeyword);
 					braceStyle = policy.ClassBraceStyle;
@@ -1602,7 +1607,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			{
 				constraint.AcceptVisitor(this);
 			}
-			if (typeDeclaration.ClassType == ClassType.RecordClass && typeDeclaration.Members.Count == 0)
+			if (typeDeclaration.ClassType is (ClassType.RecordClass or ClassType.RecordStruct) && typeDeclaration.Members.Count == 0)
 			{
 				Semicolon();
 			}

ICSharpCode.Decompiler/CSharp/RecordDecompiler.cs

@@ -721,6 +721,9 @@ namespace ICSharpCode.Decompiler.CSharp
 				return false;
 			if (!body.Instructions[0].MatchReturn(out var returnValue))
 				return false;
+			// special case for empty record struct; always returns true;
+			if (returnValue.MatchLdcI4(1))
+				return true;
 			var variables = body.Ancestors.OfType<ILFunction>().Single().Variables;
 			var other = variables.Single(v => v.Kind == VariableKind.Parameter && v.Index == 0);
 			Debug.Assert(IsRecordType(other.Type));
@@ -908,6 +911,9 @@ namespace ICSharpCode.Decompiler.CSharp
 				return false;
 			if (!body.Instructions[0].MatchReturn(out var returnValue))
 				return false;
+			// special case for empty record struct; always returns false;
+			if (returnValue.MatchLdcI4(0))
+				return true;
 			var hashedMembers = new List<IMember>();
 			bool foundBaseClassHash = false;
 			if (!Visit(returnValue))

ICSharpCode.Decompiler/CSharp/Syntax/GeneralScope/TypeDeclaration.cs

@@ -35,9 +35,13 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		Interface,
 		Enum,
 		/// <summary>
-		/// C# 9 'record'
+		/// C# 9 'record class'
 		/// </summary>
 		RecordClass,
+		/// <summary>
+		/// C# 10 'record struct'
+		/// </summary>
+		RecordStruct,
 	}
 
 	/// <summary>
@@ -62,6 +66,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 					case ClassType.Class:
 						return GetChildByRole(Roles.ClassKeyword);
 					case ClassType.Struct:
+					case ClassType.RecordStruct:
 						return GetChildByRole(Roles.StructKeyword);
 					case ClassType.Interface:
 						return GetChildByRole(Roles.InterfaceKeyword);

ICSharpCode.Decompiler/CSharp/Syntax/Roles.cs

@@ -89,6 +89,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public static readonly TokenRole StructKeyword = new TokenRole("struct");
 		public static readonly TokenRole ClassKeyword = new TokenRole("class");
 		public static readonly TokenRole RecordKeyword = new TokenRole("record");
+		public static readonly TokenRole RecordStructKeyword = new TokenRole("record");
 
 	}
 }

ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs

@@ -219,6 +219,11 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		/// Controls whether C# 9 "record" class types are supported.
 		/// </summary>
 		public bool SupportRecordClasses { get; set; }
+
+		/// <summary>
+		/// Controls whether C# 10 "record" struct types are supported.
+		/// </summary>
+		public bool SupportRecordStructs { get; set; }
 		#endregion
 
 		#region Convert Type
@@ -1775,6 +1780,10 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 							modifiers |= Modifiers.Ref;
 						}
 					}
+					if (SupportRecordStructs && typeDefinition.IsRecord)
+					{
+						classType = ClassType.RecordStruct;
+					}
 					break;
 				case TypeKind.Enum:
 					classType = ClassType.Enum;

ICSharpCode.Decompiler/CSharp/Transforms/TransformFieldAndConstructorInitializers.cs

@@ -61,10 +61,10 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 
 		public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
 		{
-			if (!(constructorDeclaration.Body.Statements.FirstOrDefault() is ExpressionStatement stmt))
-				return;
 			var currentCtor = (IMethod)constructorDeclaration.GetSymbol();
-			ConstructorInitializer ci;
+			ConstructorInitializer ci = null;
+			if (constructorDeclaration.Body.Statements.FirstOrDefault() is ExpressionStatement stmt)
+			{
 				switch (stmt.Expression)
 				{
 					// Pattern for reference types:
@@ -117,11 +117,12 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 					default:
 						return;
 				}
+			}
 			if (context.DecompileRun.RecordDecompilers.TryGetValue(currentCtor.DeclaringTypeDefinition, out var record)
-				&& currentCtor.Equals(record.PrimaryConstructor)
-				&& ci.ConstructorInitializerType == ConstructorInitializerType.Base)
+				&& currentCtor.Equals(record.PrimaryConstructor))
 			{
 				if (record.IsInheritedRecord &&
+					ci?.ConstructorInitializerType == ConstructorInitializerType.Base &&
 					constructorDeclaration.Parent is TypeDeclaration { BaseTypes: { Count: >= 1 } } typeDecl)
 				{
 					var baseType = typeDecl.BaseTypes.First();
@@ -172,7 +173,8 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 			if (instanceCtorsNotChainingWithThis.Length > 0)
 			{
 				var ctorMethodDef = instanceCtorsNotChainingWithThis[0].GetSymbol() as IMethod;
-				if (ctorMethodDef != null && ctorMethodDef.DeclaringType.IsReferenceType == false)
+				ITypeDefinition declaringTypeDefinition = ctorMethodDef?.DeclaringTypeDefinition;
+				if (ctorMethodDef != null && declaringTypeDefinition?.IsReferenceType == false && !declaringTypeDefinition.IsRecord)
 					return;
 
 				bool ctorIsUnsafe = instanceCtorsNotChainingWithThis.All(c => c.HasModifier(Modifiers.Unsafe));
@@ -180,13 +182,14 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 				if (!context.DecompileRun.RecordDecompilers.TryGetValue(ctorMethodDef.DeclaringTypeDefinition, out var record))
 					record = null;
 
-				//Filter out copy constructor of records
+				// Filter out copy constructor of records
 				if (record != null)
 					instanceCtorsNotChainingWithThis = instanceCtorsNotChainingWithThis.Where(ctor => !record.IsCopyConstructor(ctor.GetSymbol() as IMethod)).ToArray();
 
 				// Recognize field or property initializers:
 				// Translate first statement in all ctors (if all ctors have the same statement) into an initializer.
 				bool allSame;
+				bool isPrimaryCtor = declaringTypeDefinition.IsReferenceType == true && declaringTypeDefinition.IsRecord;
 				do
 				{
 					Match m = fieldInitializerPattern.Match(instanceCtorsNotChainingWithThis[0].Body.FirstOrDefault());
@@ -211,11 +214,12 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 						// remove record ctor parameter assignments
 						if (!IsPropertyDeclaredByPrimaryCtor(fieldOrPropertyOrEvent as IProperty, record))
 							break;
+						isPrimaryCtor = true;
 					}
 					else
 					{
 						// cannot transform if member is not found
-						if (fieldOrPropertyOrEventDecl == null)
+						if (fieldOrPropertyOrEventDecl == null || !isPrimaryCtor)
 							break;
 					}
 

ICSharpCode.Decompiler/DecompilerSettings.cs

@@ -145,6 +145,7 @@ namespace ICSharpCode.Decompiler
 			if (languageVersion < CSharp.LanguageVersion.CSharp10_0)
 			{
 				fileScopedNamespaces = false;
+				recordStructs = false;
 			}
 			if (languageVersion < CSharp.LanguageVersion.CSharp11_0)
 			{
@@ -156,7 +157,7 @@ namespace ICSharpCode.Decompiler
 		{
 			if (parameterNullCheck)
 				return CSharp.LanguageVersion.CSharp11_0;
-			if (fileScopedNamespaces)
+			if (fileScopedNamespaces || recordStructs)
 				return CSharp.LanguageVersion.CSharp10_0;
 			if (nativeIntegers || initAccessors || functionPointers || forEachWithGetEnumeratorExtension
 				|| recordClasses || withExpressions || usePrimaryConstructorSyntax || covariantReturns)
@@ -262,6 +263,24 @@ namespace ICSharpCode.Decompiler
 			}
 		}
 
+		bool recordStructs = true;
+
+		/// <summary>
+		/// Use C# 10 <c>record</c> structs.
+		/// </summary>
+		[Category("C# 10.0 / VS 2022")]
+		[Description("DecompilerSettings.RecordStructs")]
+		public bool RecordStructs {
+			get { return recordStructs; }
+			set {
+				if (recordStructs != value)
+				{
+					recordStructs = value;
+					OnPropertyChanged();
+				}
+			}
+		}
+
 		bool withExpressions = true;
 
 		/// <summary>

ICSharpCode.Decompiler/IL/Transforms/TransformCollectionAndObjectInitializers.cs

@@ -105,6 +105,13 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 					initInst = ci.Arguments.Single();
 					break;
 				default:
+					var typeDef = v.Type.GetDefinition();
+					if (context.Settings.WithExpressions && typeDef?.IsReferenceType == false && typeDef.IsRecord)
+					{
+						instType = v.Type;
+						blockKind = BlockKind.WithInitializer;
+						break;
+					}
 					return false;
 			}
 			int initializerItemsCount = 0;

ICSharpCode.Decompiler/Output/IAmbience.cs

@@ -105,6 +105,10 @@ namespace ICSharpCode.Decompiler.Output
 		/// Support <c>record</c> classes.
 		/// </summary>
 		SupportRecordClasses = 0x20000,
+		/// <summary>
+		/// Support <c>record</c> structs.
+		/// </summary>
+		SupportRecordStructs = 0x40000,
 
 		StandardConversionFlags = ShowParameterNames |
 			ShowAccessibility |

ICSharpCode.Decompiler/TypeSystem/ITypeDefinition.cs

@@ -88,7 +88,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		Nullability NullableContext { get; }
 
 		/// <summary>
-		/// Gets whether the type has the necessary members to be considered a C# 9 record type.
+		/// Gets whether the type has the necessary members to be considered a C# 9 record or C# 10 record struct type.
 		/// </summary>
 		bool IsRecord { get; }
 	}

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeDefinition.cs

@@ -758,13 +758,13 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 
 		private bool ComputeIsRecord()
 		{
-			if (Kind != TypeKind.Class)
+			if (Kind != TypeKind.Class && Kind != TypeKind.Struct)
 				return false;
 			var metadata = module.metadata;
 			var typeDef = metadata.GetTypeDefinition(handle);
 			bool opEquality = false;
 			bool opInequality = false;
-			bool clone = false;
+			bool clone = Kind == TypeKind.Struct;
 			foreach (var methodHandle in typeDef.GetMethods())
 			{
 				var method = metadata.GetMethodDefinition(methodHandle);

ILSpy/Languages/CSharpHighlightingTokenWriter.cs

@@ -231,9 +231,11 @@ namespace ICSharpCode.ILSpy
 				case "class":
 				case "interface":
 				case "delegate":
-				case "record":
 					color = referenceTypeKeywordsColor;
 					break;
+				case "record":
+					color = role == Roles.RecordKeyword ? referenceTypeKeywordsColor : valueTypeKeywordsColor;
+					break;
 				case "select":
 				case "group":
 				case "by":

ILSpy/Languages/CSharpLanguage.cs

@@ -735,6 +735,10 @@ namespace ICSharpCode.ILSpy
 			{
 				flags |= ConversionFlags.SupportRecordClasses;
 			}
+			if (settings.RecordStructs)
+			{
+				flags |= ConversionFlags.SupportRecordStructs;
+			}
 			if (settings.InitAccessors)
 			{
 				flags |= ConversionFlags.SupportInitAccessors;