Treat record structs as records

Src/FluentAssertions/Common/TypeExtensions.cs

@@ -584,12 +584,29 @@ private static bool IsAnonymousType(this Type type)
     public static bool IsRecord(this Type type)
     {
         return TypeIsRecordCache.GetOrAdd(type, static t =>
-            t.GetMethod("<Clone>$") is not null &&
-            t.GetTypeInfo()
-                 .DeclaredProperties
-                 .FirstOrDefault(p => p.Name == "EqualityContract")?
-                 .GetMethod?
-                 .GetCustomAttribute(typeof(CompilerGeneratedAttribute)) is not null);
+        {
+            var isRecord = t.GetMethod("<Clone>$") is not null &&
+                           t.GetTypeInfo()
+                               .DeclaredProperties
+                               .FirstOrDefault(p => p.Name == "EqualityContract")?
+                               .GetMethod?
+                               .GetCustomAttribute(typeof(CompilerGeneratedAttribute)) is not null;
+
+            // As noted here: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/record-structs#open-questions
+            // recognizing record structs from metadata is an open point. The following check is based on common sense
+            // and heuristic testing, apparently giving good results but not supported by official documentation.
+            var isRecordStruct = t.BaseType == typeof(ValueType) &&
+                                 t.GetMethods()
+                                     .Where(m => m.Name == "op_Inequality")
+                                     .SelectMany(m => m.GetCustomAttributes(typeof(CompilerGeneratedAttribute)))
+                                     .Any() &&
+                                 t.GetMethods()
+                                     .Where(m => m.Name == "op_Equality")
+                                     .SelectMany(m => m.GetCustomAttributes(typeof(CompilerGeneratedAttribute)))
+                                     .Any();
+
+            return isRecord || isRecordStruct;
+        });
     }
 
     private static bool IsKeyValuePair(Type type)

Tests/FluentAssertions.Equivalency.Specs/RecordSpecs.cs

@@ -16,6 +16,16 @@ public void When_the_subject_is_a_record_it_should_compare_it_by_its_members()
         actual.Should().BeEquivalentTo(expected);
     }
 
+    [Fact]
+    public void When_the_subject_is_a_readonly_record_struct_it_should_compare_it_by_its_members()
+    {
+        var actual = new MyReadonlyRecordStruct("foo", new[] { "bar", "zip", "foo" });
+
+        var expected = new MyReadonlyRecordStruct("foo", new[] { "bar", "zip", "foo" });
+
+        actual.Should().BeEquivalentTo(expected);
+    }
+
     [Fact]
     public void When_the_subject_is_a_record_it_should_mention_that_in_the_configuration_output()
     {
@@ -90,4 +100,9 @@ private record MyRecord
 
         public string[] CollectionProperty { get; init; }
     }
+
+    private readonly record struct MyReadonlyRecordStruct(string StringField, string[] CollectionProperty)
+    {
+        public readonly string StringField = StringField;
+    }
 }

Tests/FluentAssertions.Specs/Types/TypeExtensionsSpecs.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Reflection;
 using FluentAssertions.Common;
@@ -124,6 +125,33 @@ public void When_getting_fake_implicit_conversion_operator_from_a_type_with_fake
         result.Should().NotBeNull();
     }
 
+    [Theory]
+    [InlineData(typeof(MyRecord), true)]
+    [InlineData(typeof(MyRecordStruct), true)]
+    [InlineData(typeof(MyRecordStructWithOverriddenEquality), true)]
+    [InlineData(typeof(MyReadonlyRecordStruct), true)]
+    [InlineData(typeof(MyStruct), false)]
+    [InlineData(typeof(MyStructWithOverriddenEquality), false)]
+    [InlineData(typeof(MyClass), false)]
+    [InlineData(typeof(int), false)]
+    [InlineData(typeof(string), false)]
+    public void IsRecord_should_detect_records_correctly(Type type, bool expected)
+    {
+        type.IsRecord().Should().Be(expected);
+    }
+
+    [Fact]
+    public void When_checking_if_anonymous_type_is_record_it_should_return_false()
+    {
+        new { Value = 42 }.GetType().IsRecord().Should().BeFalse();
+    }
+
+    [Fact]
+    public void When_checking_if_class_with_multiple_equality_methods_is_record_it_should_return_false()
+    {
+        typeof(ImmutableArray<int>).IsRecord().Should().BeFalse();
+    }
+
     private static MethodInfo GetFakeConversionOperator(Type type, string name, BindingFlags bindingAttr, Type returnType)
     {
         MethodInfo[] methods = type.GetMethods(bindingAttr);
@@ -153,4 +181,42 @@ private TypeWithFakeConversionOperators(int value)
         public static byte op_Explicit(TypeWithFakeConversionOperators typeWithFakeConversionOperators) => (byte)typeWithFakeConversionOperators.value;
 #pragma warning restore SA1300, IDE1006
     }
+
+    private record MyRecord(int Value);
+
+    private record struct MyRecordStruct(int Value);
+
+    private record struct MyRecordStructWithOverriddenEquality(int Value)
+    {
+        public bool Equals(MyRecordStructWithOverriddenEquality other) => Value == other.Value;
+
+        public override int GetHashCode() => Value;
+    }
+
+    private readonly record struct MyReadonlyRecordStruct(int Value);
+
+    private struct MyStruct
+    {
+        public int Value { get; set; }
+    }
+
+    private struct MyStructWithOverriddenEquality : IEquatable<MyStructWithOverriddenEquality>
+    {
+        public int Value { get; set; }
+
+        public bool Equals(MyStructWithOverriddenEquality other) => Value == other.Value;
+
+        public override bool Equals(object obj) => obj is MyStructWithOverriddenEquality other && Equals(other);
+
+        public override int GetHashCode() => Value;
+
+        public static bool operator ==(MyStructWithOverriddenEquality left, MyStructWithOverriddenEquality right) => left.Equals(right);
+
+        public static bool operator !=(MyStructWithOverriddenEquality left, MyStructWithOverriddenEquality right) => !left.Equals(right);
+    }
+
+    private class MyClass
+    {
+        public int Value { get; set; }
+    }
 }

docs/_pages/objectgraphs.md

@@ -39,7 +39,7 @@ orderDto.Should().BeEquivalentTo(order, options =>
 
 ### Value Types
 
-To determine whether Fluent Assertions should recurs into an object's properties or fields, it needs to understand what types have value semantics and what types should be treated as reference types. The default behavior is to treat every type that overrides `Object.Equals` as an object that was designed to have value semantics. Anonymous types, records and tuples also override this method, but because the community proved us that they use them quite often in equivalency comparisons, we decided to always compare them by their members.
+To determine whether Fluent Assertions should recurs into an object's properties or fields, it needs to understand what types have value semantics and what types should be treated as reference types. The default behavior is to treat every type that overrides `Object.Equals` as an object that was designed to have value semantics. Anonymous types, records, record structs, readonly record structs and tuples also override this method, but because the community proved us that they use them quite often in equivalency comparisons, we decided to always compare them by their members.
 
 You can easily override this by using the `ComparingByValue<T>`, `ComparingByMembers<T>`, `ComparingRecordsByValue` and `ComparingRecordsByMembers` options for individual assertions:
 
@@ -48,7 +48,7 @@ subject.Should().BeEquivalentTo(expected,
    options => options.ComparingByValue<IPAddress>());
 ```
 
-For records, this works like this:
+For records, record structs and readonly record structs this works like this:
 
 ```csharp
 actual.Should().BeEquivalentTo(expected, options => options

docs/_pages/releases.md

@@ -25,6 +25,7 @@ sidebar:
 
 ### Enhancements
 * Included the time difference in the error message of `BeCloseTo` - [#2013](https://github.com/fluentassertions/fluentassertions/pull/2013)
+* Treated record structs and readonly record structs as records, thus comparing them by member by default - [#2009](https://github.com/fluentassertions/fluentassertions/pull/2009)
 
 ## 6.7.0