Add support for C# 10 record structs.

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

@@ -1,126 +1,231 @@
 using System;
+using System.Runtime.InteropServices;
 
 namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
 {
-	public record Base(string A);
-
-	public record CopyCtor(string A)
+	internal class RecordClasses
 	{
-		protected CopyCtor(CopyCtor _)
+		public record Base(string A);
+
+		public record CopyCtor(string A)
 		{
+			protected CopyCtor(CopyCtor _)
+			{
+			}
 		}
-	}
 
-	public record Derived(int B) : Base(B.ToString());
+		public record Derived(int B) : Base(B.ToString());
 
-	public record Empty;
+		public record Empty;
 
-	public record Fields
-	{
-		public int A;
-		public double B = 1.0;
-		public object C;
-		public dynamic D;
-		public string S = "abc";
-	}
+		public record Fields
+		{
+			public int A;
+			public double B = 1.0;
+			public object C;
+			public dynamic D;
+			public string S = "abc";
+		}
 
-	public record Interface(int B) : IRecord;
+		public record Interface(int B) : IRecord;
 
-	public interface IRecord
-	{
-	}
+		public interface IRecord
+		{
+		}
 
-	public record Pair<A, B>
-	{
-		public A First { get; init; }
-		public B Second { get; init; }
-	}
+		public record Pair<A, B>
+		{
+			public A First { get; init; }
+			public B Second { get; init; }
+		}
 
-	public record PairWithPrimaryCtor<A, B>(A First, B Second);
+		public record PairWithPrimaryCtor<A, B>(A First, B Second);
 
-	public record PrimaryCtor(int A, string B);
-	public record PrimaryCtorWithAttribute([RecordTest("param")] [property: RecordTest("property")][field: RecordTest("field")] int a);
-	public record PrimaryCtorWithField(int A, string B)
-	{
-		public double C = 1.0;
-		public string D = A + B;
-	}
-	public record PrimaryCtorWithInParameter(in int A, in string B);
-	public record PrimaryCtorWithProperty(int A, string B)
-	{
-		public double C { get; init; } = 1.0;
-		public string D { get; } = A + B;
-	}
+		public record PrimaryCtor(int A, string B);
+		public record PrimaryCtorWithAttribute([RecordTest("param")] [property: RecordTest("property")][field: RecordTest("field")] int a);
+		public record PrimaryCtorWithField(int A, string B)
+		{
+			public double C = 1.0;
+			public string D = A + B;
+		}
+		public record PrimaryCtorWithInParameter(in int A, in string B);
+		public record PrimaryCtorWithProperty(int A, string B)
+		{
+			public double C { get; init; } = 1.0;
+			public string D { get; } = A + B;
+		}
 
-	public record 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 record 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()
+			{
+				B = 42;
+			}
+		}
 
-		public Properties()
+		[AttributeUsage(AttributeTargets.All)]
+		public class RecordTestAttribute : Attribute
 		{
-			B = 42;
+			public RecordTestAttribute(string name)
+			{
+			}
 		}
-	}
 
-	[AttributeUsage(AttributeTargets.All)]
-	public class RecordTestAttribute : Attribute
-	{
-		public RecordTestAttribute(string name)
+		public sealed record Sealed(string A);
+
+		public sealed record SealedDerived(int B) : Base(B.ToString());
+
+		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
+					}
+				};
+			}
 		}
-	}
 
-	public sealed record Sealed(string A);
+		public abstract record WithNestedRecords
+		{
+			public record A : WithNestedRecords
+			{
+				public override string AbstractProp => "A";
+			}
+
+			public record B : WithNestedRecords
+			{
+				public override string AbstractProp => "B";
+
+				public int? Value { get; set; }
+			}
 
-	public sealed record SealedDerived(int B) : Base(B.ToString());
+			public record DerivedGeneric<T> : Pair<T, T?> where T : struct
+			{
+				public bool Flag;
+			}
 
-	public class WithExpressionTests
+			public abstract string AbstractProp { get; }
+		}
+
+	}
+	internal class RecordStructs
 	{
-		public Fields Test(Fields input)
+		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
 		{
-			return input with {
-				A = 42,
-				B = 3.141,
-				C = input
-			};
+			public int A;
+			public double B;
+			public object C;
+			public dynamic D;
+			public string S;
 		}
-		public Fields Test2(Fields input)
+
+		public record struct Interface(int B) : IRecord;
+
+		public interface IRecord
 		{
-			return input with {
-				A = 42,
-				B = 3.141,
-				C = input with {
-					A = 43
-				}
-			};
 		}
-	}
 
-	public abstract record WithNestedRecords
-	{
-		public record A : WithNestedRecords
+		public record struct Pair<A, B>
 		{
-			public override string AbstractProp => "A";
+			public A First { get; init; }
+			public B Second { get; init; }
 		}
 
-		public record B : WithNestedRecords
+		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 override string AbstractProp => "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 int? Value { get; set; }
+		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;
+			}
 		}
 
-		public record DerivedGeneric<T> : Pair<T, T?> where T : struct
+		[AttributeUsage(AttributeTargets.All)]
+		public class RecordTestAttribute : Attribute
 		{
-			public bool Flag;
+			public RecordTestAttribute(string name)
+			{
+			}
 		}
 
-		public abstract string AbstractProp { get; }
+		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,67 +61,68 @@ 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;
-			switch (stmt.Expression)
+			ConstructorInitializer ci = null;
+			if (constructorDeclaration.Body.Statements.FirstOrDefault() is ExpressionStatement stmt)
 			{
-				// Pattern for reference types:
-				// this..ctor(...);
-				case InvocationExpression invocation:
-					if (!(invocation.Target is MemberReferenceExpression mre) || mre.MemberName != ".ctor")
-						return;
-					if (!(invocation.GetSymbol() is IMethod ctor && ctor.IsConstructor))
-						return;
-					ci = new ConstructorInitializer();
-					var target = mre.Target;
-					// Ignore casts, those might be added if references are missing.
-					if (target is CastExpression cast)
-						target = cast.Expression;
-					if (target is ThisReferenceExpression or BaseReferenceExpression)
-					{
-						if (ctor.DeclaringTypeDefinition == currentCtor.DeclaringTypeDefinition)
+				switch (stmt.Expression)
+				{
+					// Pattern for reference types:
+					// this..ctor(...);
+					case InvocationExpression invocation:
+						if (!(invocation.Target is MemberReferenceExpression mre) || mre.MemberName != ".ctor")
+							return;
+						if (!(invocation.GetSymbol() is IMethod ctor && ctor.IsConstructor))
+							return;
+						ci = new ConstructorInitializer();
+						var target = mre.Target;
+						// Ignore casts, those might be added if references are missing.
+						if (target is CastExpression cast)
+							target = cast.Expression;
+						if (target is ThisReferenceExpression or BaseReferenceExpression)
+						{
+							if (ctor.DeclaringTypeDefinition == currentCtor.DeclaringTypeDefinition)
+								ci.ConstructorInitializerType = ConstructorInitializerType.This;
+							else
+								ci.ConstructorInitializerType = ConstructorInitializerType.Base;
+						}
+						else
+							return;
+						// Move arguments from invocation to initializer:
+						invocation.Arguments.MoveTo(ci.Arguments);
+						// Add the initializer: (unless it is the default 'base()')
+						if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0))
+							constructorDeclaration.Initializer = ci.CopyAnnotationsFrom(invocation);
+						// Remove the statement:
+						stmt.Remove();
+						break;
+					// Pattern for value types:
+					// this = new TSelf(...);
+					case AssignmentExpression assignment:
+						if (!(assignment.Right is ObjectCreateExpression oce && oce.GetSymbol() is IMethod ctor2 && ctor2.DeclaringTypeDefinition == currentCtor.DeclaringTypeDefinition))
+							return;
+						ci = new ConstructorInitializer();
+						if (assignment.Left is ThisReferenceExpression)
 							ci.ConstructorInitializerType = ConstructorInitializerType.This;
 						else
-							ci.ConstructorInitializerType = ConstructorInitializerType.Base;
-					}
-					else
-						return;
-					// Move arguments from invocation to initializer:
-					invocation.Arguments.MoveTo(ci.Arguments);
-					// Add the initializer: (unless it is the default 'base()')
-					if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0))
-						constructorDeclaration.Initializer = ci.CopyAnnotationsFrom(invocation);
-					// Remove the statement:
-					stmt.Remove();
-					break;
-				// Pattern for value types:
-				// this = new TSelf(...);
-				case AssignmentExpression assignment:
-					if (!(assignment.Right is ObjectCreateExpression oce && oce.GetSymbol() is IMethod ctor2 && ctor2.DeclaringTypeDefinition == currentCtor.DeclaringTypeDefinition))
-						return;
-					ci = new ConstructorInitializer();
-					if (assignment.Left is ThisReferenceExpression)
-						ci.ConstructorInitializerType = ConstructorInitializerType.This;
-					else
+							return;
+						// Move arguments from invocation to initializer:
+						oce.Arguments.MoveTo(ci.Arguments);
+						// Add the initializer: (unless it is the default 'base()')
+						if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0))
+							constructorDeclaration.Initializer = ci.CopyAnnotationsFrom(oce);
+						// Remove the statement:
+						stmt.Remove();
+						break;
+					default:
 						return;
-					// Move arguments from invocation to initializer:
-					oce.Arguments.MoveTo(ci.Arguments);
-					// Add the initializer: (unless it is the default 'base()')
-					if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0))
-						constructorDeclaration.Initializer = ci.CopyAnnotationsFrom(oce);
-					// Remove the statement:
-					stmt.Remove();
-					break;
-				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;