Format records and anonymous types with their member values

Src/FluentAssertions/Common/TypeExtensions.cs

@@ -23,6 +23,7 @@ internal static class TypeExtensions
 
     private static readonly ConcurrentDictionary<Type, bool> HasValueSemanticsCache = new();
     private static readonly ConcurrentDictionary<Type, bool> TypeIsRecordCache = new();
+    private static readonly ConcurrentDictionary<Type, bool> TypeIsCompilerGeneratedCache = new();
 
     private static readonly ConcurrentDictionary<(Type Type, MemberVisibility Visibility), TypeMemberReflector>
         TypeMemberReflectorsCache = new();
@@ -424,11 +425,28 @@ public static bool HasValueSemantics(this Type type)
     {
         return HasValueSemanticsCache.GetOrAdd(type, static t =>
             t.OverridesEquals() &&
-            !t.IsAnonymousType() &&
+            !t.IsAnonymous() &&
             !t.IsTuple() &&
             !IsKeyValuePair(t));
     }
 
+    public static bool IsCompilerGenerated(this Type type)
+    {
+        return TypeIsCompilerGeneratedCache.GetOrAdd(type, static t =>
+            t.IsRecord() ||
+            t.IsAnonymous() ||
+            t.IsTuple());
+    }
+
+    /// <summary>
+    /// Check if the type has a human-readable name.
+    /// </summary>
+    /// <returns>false for compiler generated type names, otherwise true.</returns>
+    public static bool HasFriendlyName(this Type type)
+    {
+        return !type.IsAnonymous() && !type.IsTuple();
+    }
+
     private static bool IsTuple(this Type type)
     {
         if (!type.IsGenericType)
@@ -460,7 +478,7 @@ private static bool IsTuple(this Type type)
 #endif
     }
 
-    private static bool IsAnonymousType(this Type type)
+    private static bool IsAnonymous(this Type type)
     {
         bool nameContainsAnonymousType = type.FullName.Contains("AnonymousType", StringComparison.Ordinal);
 

Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidatorExtensions.cs

@@ -14,33 +14,30 @@ internal static class EnumerableEquivalencyValidatorExtensions
             .FailWith(", but found an empty collection.")
             .Then
             .ForCondition(subject.Count == 0 || expectation.Count > 0)
-            .FailWith(", but {0}{2}contains {1} item(s).",
+            .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s).",
                 subject,
-                subject.Count,
-                Environment.NewLine);
+                subject.Count);
     }
 
     public static Continuation AssertCollectionHasEnoughItems<T>(this IAssertionScope scope, ICollection<object> subject,
         ICollection<T> expectation)
     {
         return scope
             .ForCondition(subject.Count >= expectation.Count)
-            .FailWith(", but {0}{3}contains {1} item(s) less than{3}{2}.",
+            .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s) less than{Environment.NewLine}{{2}}.",
                 subject,
                 expectation.Count - subject.Count,
-                expectation,
-                Environment.NewLine);
+                expectation);
     }
 
     public static Continuation AssertCollectionHasNotTooManyItems<T>(this IAssertionScope scope, ICollection<object> subject,
         ICollection<T> expectation)
     {
         return scope
             .ForCondition(subject.Count <= expectation.Count)
-            .FailWith(", but {0}{3}contains {1} item(s) more than{3}{2}.",
+            .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s) more than{Environment.NewLine}{{2}}.",
                 subject,
                 subject.Count - expectation.Count,
-                expectation,
-                Environment.NewLine);
+                expectation);
     }
 }

Src/FluentAssertions/Formatting/DefaultValueFormatter.cs

@@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using FluentAssertions.Common;
 using FluentAssertions.Equivalency;
 
@@ -34,7 +35,7 @@ public void Format(object value, FormattedObjectGraph formattedGraph, Formatting
             return;
         }
 
-        if (HasDefaultToStringImplementation(value))
+        if (HasCompilerGeneratedToStringImplementation(value))
         {
             WriteTypeAndMemberValues(value, formattedGraph, formatChild);
         }
@@ -59,6 +60,13 @@ protected virtual MemberInfo[] GetMembers(Type type)
         return type.GetNonPrivateMembers(MemberVisibility.Public);
     }
 
+    private static bool HasCompilerGeneratedToStringImplementation(object value)
+    {
+        Type type = value.GetType();
+
+        return HasDefaultToStringImplementation(value) || type.IsCompilerGenerated();
+    }
+
     private static bool HasDefaultToStringImplementation(object value)
     {
         string str = value.ToString();
@@ -69,10 +77,34 @@ private static bool HasDefaultToStringImplementation(object value)
     private void WriteTypeAndMemberValues(object obj, FormattedObjectGraph formattedGraph, FormatChild formatChild)
     {
         Type type = obj.GetType();
-        formattedGraph.AddLine(TypeDisplayName(type));
-        formattedGraph.AddLine("{");
+        WriteTypeName(formattedGraph, type);
+        WriteTypeValue(obj, formattedGraph, formatChild, type);
+    }
 
+    private void WriteTypeName(FormattedObjectGraph formattedGraph, Type type)
+    {
+        var typeName = type.HasFriendlyName() ? TypeDisplayName(type) : string.Empty;
+        formattedGraph.AddFragment(typeName);
+    }
+
+    private void WriteTypeValue(object obj, FormattedObjectGraph formattedGraph, FormatChild formatChild, Type type)
+    {
         MemberInfo[] members = GetMembers(type);
+        if (members.Length == 0)
+        {
+            formattedGraph.AddFragment("{ }");
+        }
+        else
+        {
+            formattedGraph.EnsureInitialNewLine();
+            formattedGraph.AddLine("{");
+            WriteMemberValues(obj, members, formattedGraph, formatChild);
+            formattedGraph.AddFragmentOnNewLine("}");
+        }
+    }
+
+    private static void WriteMemberValues(object obj, MemberInfo[] members, FormattedObjectGraph formattedGraph, FormatChild formatChild)
+    {
         using var iterator = new Iterator<MemberInfo>(members.OrderBy(mi => mi.Name, StringComparer.Ordinal));
 
         while (iterator.MoveNext())
@@ -84,8 +116,6 @@ private void WriteTypeAndMemberValues(object obj, FormattedObjectGraph formatted
                 formattedGraph.AddFragment(", ");
             }
         }
-
-        formattedGraph.AddFragmentOnNewLine("}");
     }
 
     /// <summary>

Src/FluentAssertions/Formatting/EnumerableValueFormatter.cs

@@ -29,18 +29,15 @@ public virtual bool CanHandle(object value)
 
     public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
     {
-        int startCount = formattedGraph.LineCount;
         IEnumerable<object> collection = ((IEnumerable)value).Cast<object>();
 
         using var iterator = new Iterator<object>(collection, MaxItems);
 
+        var iteratorGraph = formattedGraph.KeepOnSingleLineAsLongAsPossible();
+        FormattedObjectGraph.PossibleMultilineFragment separatingCommaGraph = null;
+
         while (iterator.MoveNext())
         {
-            if (iterator.IsFirst)
-            {
-                formattedGraph.AddFragment("{");
-            }
-
             if (!iterator.HasReachedMaxItems)
             {
                 formatChild(iterator.Index.ToString(CultureInfo.InvariantCulture), iterator.Current, formattedGraph);
@@ -49,34 +46,26 @@ public void Format(object value, FormattedObjectGraph formattedGraph, Formatting
             {
                 using IDisposable _ = formattedGraph.WithIndentation();
                 string moreItemsMessage = value is ICollection c ? $"…{c.Count - MaxItems} more…" : "…more…";
-                AddLineOrFragment(formattedGraph, startCount, moreItemsMessage);
+                iteratorGraph.AddLineOrFragment(moreItemsMessage);
             }
 
+            separatingCommaGraph?.InsertLineOrFragment(", ");
+            separatingCommaGraph = formattedGraph.KeepOnSingleLineAsLongAsPossible();
+
+            // We cannot know whether or not the enumerable will take up more than one line of
+            // output until we have formatted the first item. So we format the first item, then
+            // go back and insert the enumerable's opening brace in the correct place depending
+            // on whether that first item was all on one line or not.
             if (iterator.IsLast)
             {
-                AddLineOrFragment(formattedGraph, startCount, "}");
-            }
-            else
-            {
-                formattedGraph.AddFragment(", ");
+                iteratorGraph.AddStartingLineOrFragment("{");
+                iteratorGraph.AddLineOrFragment("}");
             }
         }
 
         if (iterator.IsEmpty)
         {
-            formattedGraph.AddFragment("{empty}");
-        }
-    }
-
-    private static void AddLineOrFragment(FormattedObjectGraph formattedGraph, int startCount, string fragment)
-    {
-        if (formattedGraph.LineCount > (startCount + 1))
-        {
-            formattedGraph.AddLine(fragment);
-        }
-        else
-        {
-            formattedGraph.AddFragment(fragment);
+            iteratorGraph.AddFragment("{empty}");
         }
     }
 }

Src/FluentAssertions/Formatting/FormattedObjectGraph.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -74,6 +74,29 @@ public void AddFragment(string fragment)
         lineBuilder.Append(fragment);
     }
 
+    /// <summary>
+    /// Adds a new line if there are no lines and no fragment that would cause a new line.
+    /// </summary>
+    internal void EnsureInitialNewLine()
+    {
+        if (LineCount == 0)
+        {
+            InsertInitialNewLine();
+        }
+    }
+
+    /// <summary>
+    /// Inserts an empty line as the first line unless it is already.
+    /// </summary>
+    private void InsertInitialNewLine()
+    {
+        if (lines.Count == 0 || !string.IsNullOrEmpty(lines[0]))
+        {
+            lines.Insert(0, string.Empty);
+            lineBuilderWhitespace = Whitespace;
+        }
+    }
+
     private void FlushCurrentLine()
     {
         if (lineBuilder.Length > 0)
@@ -128,5 +151,123 @@ public override string ToString()
         return string.Join(Environment.NewLine, lines.Concat(new[] { lineBuilder.ToString() }));
     }
 
-    private string Whitespace => new(' ', indentation * SpacesPerIndentation);
+    internal PossibleMultilineFragment KeepOnSingleLineAsLongAsPossible()
+    {
+        return new PossibleMultilineFragment(this);
+    }
+
+    private string Whitespace => MakeWhitespace(indentation);
+
+    private static string MakeWhitespace(int indent) => new(' ', indent * SpacesPerIndentation);
+
+    /// <summary>
+    /// Write fragments that may be on a single line or span multiple lines,
+    /// and this is not known until later parts of the fragment are written.
+    /// </summary>
+    internal record PossibleMultilineFragment
+    {
+        private readonly FormattedObjectGraph parentGraph;
+        private readonly int startingLineBuilderIndex;
+        private int startingLineCount;
+
+        public PossibleMultilineFragment(FormattedObjectGraph parentGraph)
+        {
+            this.parentGraph = parentGraph;
+            startingLineBuilderIndex = parentGraph.lineBuilder.Length;
+            startingLineCount = parentGraph.lines.Count;
+        }
+
+        /// <summary>
+        /// Write the fragment at the position the graph was in when this instance was created.
+        ///
+        /// <para>
+        /// If more lines have been added since this instance was created then write the
+        /// fragment on a new line, otherwise write it on the same line.
+        /// </para>
+        /// </summary>
+        internal void AddStartingLineOrFragment(string fragment)
+        {
+            if (FormatOnSingleLine)
+            {
+                parentGraph.lineBuilder.Insert(startingLineBuilderIndex, fragment);
+            }
+            else
+            {
+                parentGraph.InsertInitialNewLine();
+                parentGraph.lines.Insert(startingLineCount + 1, parentGraph.Whitespace + fragment);
+                InsertAtStartOfLine(startingLineCount + 2, MakeWhitespace(1));
+            }
+        }
+
+        private bool FormatOnSingleLine => parentGraph.lines.Count == startingLineCount;
+
+        private void InsertAtStartOfLine(int lineIndex, string insertion)
+        {
+            if (!parentGraph.lines[lineIndex].StartsWith(insertion, StringComparison.Ordinal))
+            {
+                parentGraph.lines[lineIndex] = parentGraph.lines[lineIndex].Insert(0, insertion);
+            }
+        }
+
+        public void InsertLineOrFragment(string fragment)
+        {
+            if (FormatOnSingleLine)
+            {
+                parentGraph.lineBuilder.Insert(startingLineBuilderIndex, fragment);
+            }
+            else
+            {
+                parentGraph.lines[startingLineCount] = parentGraph.lines[startingLineCount]
+                    .Insert(startingLineBuilderIndex, InsertNewLineIntoFragment(fragment));
+            }
+        }
+
+        private string InsertNewLineIntoFragment(string fragment)
+        {
+            if (StartingLineHasBeenAddedTo())
+            {
+                return fragment + Environment.NewLine + MakeWhitespace(parentGraph.indentation + 1);
+            }
+
+            return fragment;
+        }
+
+        private bool StartingLineHasBeenAddedTo() => parentGraph.lines[startingLineCount].Length > startingLineBuilderIndex;
+
+        /// <summary>
+        /// If more lines have been added since this instance was created then write the
+        /// fragment on a new line, otherwise write it on the same line.
+        /// </summary>
+        internal void AddLineOrFragment(string fragment)
+        {
+            if (FormatOnSingleLine)
+            {
+                parentGraph.AddFragment(fragment);
+            }
+            else
+            {
+                parentGraph.AddFragmentOnNewLine(fragment);
+            }
+        }
+
+        /// <summary>
+        /// Write the fragment.  If more lines have been added since this instance was
+        /// created then also flush the line and indent the next line.
+        /// </summary>
+        internal void AddEndingLineOrFragment(string fragment)
+        {
+            if (FormatOnSingleLine)
+            {
+                parentGraph.AddFragment(fragment);
+            }
+            else
+            {
+                parentGraph.AddFragment(fragment);
+                parentGraph.FlushCurrentLine();
+                parentGraph.lineBuilderWhitespace += MakeWhitespace(1);
+            }
+        }
+
+        internal void AddFragment(string fragment) => parentGraph.AddFragment(fragment);
+    }
 }