diff --git a/.editorconfig b/.editorconfig
index f4874fecc7..0ea4ede3a9 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -199,6 +199,11 @@ dotnet_diagnostic.SA1116.severity = none
 dotnet_diagnostic.SA1117.severity = none
 # SA1200: Using directive should appear within a namespace declaration
 dotnet_diagnostic.SA1200.severity = none
+
+# Purpose: Use string. Empty for empty strings
+# Reason: There's no performance difference. See https://medium.com/@dk.kravtsov/string-empty-vs-in-c-70c64971161f 
+dotnet_diagnostic.SA1122.severity = none
+
 # SA1124: Do not use regions
 dotnet_diagnostic.SA1124.severity = none
 # SA1201: A property should not follow a method
diff --git a/Build/Build.cs b/Build/Build.cs
index 1859443ae5..a3f1c2695b 100644
--- a/Build/Build.cs
+++ b/Build/Build.cs
@@ -1,10 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Net.Http;
-using System.Runtime.InteropServices;
 using LibGit2Sharp;
-using Microsoft.Build.Tasks;
 using Nuke.Common;
 using Nuke.Common.CI.GitHubActions;
 using Nuke.Common.Execution;
diff --git a/Build/_build.csproj b/Build/_build.csproj
index e3711ab625..91b5c3e46d 100644
--- a/Build/_build.csproj
+++ b/Build/_build.csproj
@@ -7,6 +7,7 @@
     <NukeRootDirectory>..\</NukeRootDirectory>
     <NukeScriptDirectory>..\</NukeScriptDirectory>
     <NukeVersion>8.1.0</NukeVersion>
+    <NukeTelemetryVersion>1</NukeTelemetryVersion>
   </PropertyGroup>
   <PropertyGroup Condition="$([MSBuild]::IsOSPlatform('Windows'))">
     <DefineConstants>OS_WINDOWS</DefineConstants>
diff --git a/FluentAssertions.sln.DotSettings b/FluentAssertions.sln.DotSettings
index e58cf3d554..785299fbe3 100644
--- a/FluentAssertions.sln.DotSettings
+++ b/FluentAssertions.sln.DotSettings
@@ -1,4 +1,4 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeEditing/Intellisense/CodeCompletion/AutoCompleteBasicCompletion/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeEditing/Intellisense/LookupWindow/ShowSignatures/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeEditing/TypingAssist/FormatBlockOnRBrace/@EntryValue">False</s:Boolean>
@@ -143,7 +143,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-
+	
 	<s:String x:Key="/Default/Environment/Editor/MatchingBraceHighlighting/Style/@EntryValue">OUTLINE</s:String>
 	<s:String x:Key="/Default/Environment/Hierarchy/PsiConfigurationSettingsKey/LocationType/@EntryValue">SOLUTION_FOLDER</s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EFeature_002EServices_002EDaemon_002ESettings_002EMigration_002ESwaWarningsModeSettingsMigrate/@EntryIndexedValue">True</s:Boolean>
@@ -161,17 +161,17 @@
 	<s:Int64 x:Key="/Default/Environment/UnitTesting/ParallelProcessesCount/@EntryValue">4</s:Int64>
 	<s:Boolean x:Key="/Default/Environment/UnitTesting/ShadowCopy/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/@KeyIndexDefined">True</s:Boolean>
-	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Field/=behavior/@KeyIndexDefined">True</s:Boolean>
-	<s:Int64 x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Field/=behavior/Order/@EntryValue">1</s:Int64>
-	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Field/=scenario/@KeyIndexDefined">True</s:Boolean>
-	<s:Int64 x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Field/=scenario/Order/@EntryValue">0</s:Int64>
+	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Field/=behavior/@KeyIndexDefined">False</s:Boolean>
+	
+	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Field/=scenario/@KeyIndexDefined">False</s:Boolean>
+	
 	<s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Shortcut/@EntryValue">aaa</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Description/@EntryValue">Arrange-Act-Assert</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=012E3B0572DEF2448B0B5D9AA88E6210/Text/@EntryValue">[Fact]
 public void $END$()
 {
     // Arrange
-
+    
 
     // Act
 
diff --git a/Src/FluentAssertions/AndWhichConstraint.cs b/Src/FluentAssertions/AndWhichConstraint.cs
index a30126ba2f..b15aaaf5c8 100644
--- a/Src/FluentAssertions/AndWhichConstraint.cs
+++ b/Src/FluentAssertions/AndWhichConstraint.cs
@@ -2,45 +2,84 @@
 using System.Collections.Generic;
 using System.Linq;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 using FluentAssertions.Formatting;
 
 namespace FluentAssertions;
 
 /// <summary>
-/// Constraint which can be returned from an assertion which matches a condition and which will allow
-/// further matches to be performed on the matched condition as well as the parent constraint.
+/// Provides a <see cref="Which"/> property that can be used in chained assertions where the prior assertions returns a
+/// single object that the assertion continues on.
 /// </summary>
-/// <typeparam name="TParentConstraint">The type of the original constraint that was matched</typeparam>
-/// <typeparam name="TMatchedElement">The type of the matched object which the parent constraint matched</typeparam>
-public class AndWhichConstraint<TParentConstraint, TMatchedElement> : AndConstraint<TParentConstraint>
+public class AndWhichConstraint<TParent, TSubject> : AndConstraint<TParent>
 {
-    private readonly Lazy<TMatchedElement> matchedConstraint;
+    private readonly AssertionChain assertionChain;
+    private readonly string pathPostfix;
+    private readonly Lazy<TSubject> getSubject;
 
-    public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint)
-        : base(parentConstraint)
+    /// <summary>
+    /// Creates an object that allows continuing an assertion executed through <paramref name="parent"/> and
+    /// which resulted in a single <paramref name="subject"/>.
+    /// </summary>
+    public AndWhichConstraint(TParent parent, TSubject subject)
+        : base(parent)
+    {
+        getSubject = new Lazy<TSubject>(() => subject);
+    }
+
+    /// <summary>
+    /// Creates an object that allows continuing an assertion executed through <paramref name="parent"/> and
+    /// which resulted in a single <paramref name="subject"/> on an existing <paramref name="assertionChain"/>, but where
+    /// the previous caller identifier is post-fixed with <paramref name="pathPostfix"/>.
+    /// </summary>
+    public AndWhichConstraint(TParent parent, TSubject subject, AssertionChain assertionChain, string pathPostfix = "")
+        : base(parent)
     {
-        this.matchedConstraint =
-            new Lazy<TMatchedElement>(() => matchedConstraint);
+        getSubject = new Lazy<TSubject>(() => subject);
+
+        this.assertionChain = assertionChain;
+        this.pathPostfix = pathPostfix;
     }
 
-    public AndWhichConstraint(TParentConstraint parentConstraint, IEnumerable<TMatchedElement> matchedConstraint)
-        : base(parentConstraint)
+    /// <summary>
+    /// Creates an object that allows continuing an assertion executed through <paramref name="parent"/> and
+    /// which resulted in a potential collection of objects through <paramref name="subjects"/>.
+    /// </summary>
+    /// <remarks>
+    /// If <paramref name="subjects"/> contains more than one object, a clear exception is thrown.
+    /// </remarks>
+    public AndWhichConstraint(TParent parent, IEnumerable<TSubject> subjects)
+        : base(parent)
     {
-        this.matchedConstraint =
-            new Lazy<TMatchedElement>(
-                () => SingleOrDefault(matchedConstraint));
+        getSubject = new Lazy<TSubject>(() => SingleOrDefault(subjects));
     }
 
-    private static TMatchedElement SingleOrDefault(
-        IEnumerable<TMatchedElement> matchedConstraint)
+    /// <summary>
+    /// Creates an object that allows continuing an assertion executed through <paramref name="parent"/> and
+    /// which resulted in a potential collection of objects through <paramref name="subjects"/> on an
+    /// existing <paramref name="assertionChain"/>, but where
+    /// the previous caller identifier is post-fixed with <paramref name="pathPostfix"/>.
+    /// </summary>
+    /// <remarks>
+    /// If <paramref name="subjects"/> contains more than one object, a clear exception is thrown.
+    /// </remarks>
+    public AndWhichConstraint(TParent parent, IEnumerable<TSubject> subjects, AssertionChain assertionChain, string pathPostfix)
+        : base(parent)
     {
-        TMatchedElement[] matchedElements = matchedConstraint.ToArray();
+        getSubject = new Lazy<TSubject>(() => SingleOrDefault(subjects));
+
+        this.assertionChain = assertionChain;
+        this.pathPostfix = pathPostfix;
+    }
+
+    private static TSubject SingleOrDefault(IEnumerable<TSubject> subjects)
+    {
+        TSubject[] matchedElements = subjects.ToArray();
 
         if (matchedElements.Length > 1)
         {
             string foundObjects = string.Join(Environment.NewLine,
-                matchedElements.Select(
-                    ele => "\t" + Formatter.ToString(ele)));
+                matchedElements.Select(ele => "\t" + Formatter.ToString(ele)));
 
             string message = "More than one object found.  FluentAssertions cannot determine which object is meant."
                 + $"  Found objects:{Environment.NewLine}{foundObjects}";
@@ -54,13 +93,24 @@ private static TMatchedElement SingleOrDefault(
     /// <summary>
     /// Returns the single result of a prior assertion that is used to select a nested or collection item.
     /// </summary>
-    public TMatchedElement Which => matchedConstraint.Value;
+    /// <remarks>
+    /// Just a convenience property that returns the same value as <see cref="Which"/>.
+    /// </remarks>
+    public TSubject Subject => Which;
 
     /// <summary>
     /// Returns the single result of a prior assertion that is used to select a nested or collection item.
     /// </summary>
-    /// <remarks>
-    /// Just a convenience property that returns the same value as <see cref="Which"/>.
-    /// </remarks>
-    public TMatchedElement Subject => Which;
+    public TSubject Which
+    {
+        get
+        {
+            if (pathPostfix is not null and not "")
+            {
+                assertionChain.WithCallerPostfix(pathPostfix).ReuseOnce();
+            }
+
+            return getSubject.Value;
+        }
+    }
 }
diff --git a/Src/FluentAssertions/AssertionExtensions.cs b/Src/FluentAssertions/AssertionExtensions.cs
index 0c69d58c41..47630b6d65 100644
--- a/Src/FluentAssertions/AssertionExtensions.cs
+++ b/Src/FluentAssertions/AssertionExtensions.cs
@@ -11,6 +11,7 @@
 using System.Xml.Linq;
 using FluentAssertions.Collections;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 using FluentAssertions.Numeric;
 using FluentAssertions.Primitives;
 using FluentAssertions.Specialized;
@@ -149,7 +150,6 @@ public static ExecutionTime ExecutionTime(this Action action, StartTimer createT
     /// <summary>
     /// Provides methods for asserting the execution time of an async action.
     /// </summary>
-    /// <param name="action">An async action to measure the execution time of.</param>
     /// <returns>
     /// Returns an object for asserting that the execution time matches certain conditions.
     /// </returns>
@@ -167,7 +167,7 @@ public static ExecutionTime ExecutionTime(this Func<Task> action)
     [Pure]
     public static ExecutionTimeAssertions Should(this ExecutionTime executionTime)
     {
-        return new ExecutionTimeAssertions(executionTime);
+        return new ExecutionTimeAssertions(executionTime, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -177,7 +177,7 @@ public static ExecutionTimeAssertions Should(this ExecutionTime executionTime)
     [Pure]
     public static AssemblyAssertions Should([NotNull] this Assembly assembly)
     {
-        return new AssemblyAssertions(assembly);
+        return new AssemblyAssertions(assembly, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -187,7 +187,7 @@ public static AssemblyAssertions Should([NotNull] this Assembly assembly)
     [Pure]
     public static XDocumentAssertions Should([NotNull] this XDocument actualValue)
     {
-        return new XDocumentAssertions(actualValue);
+        return new XDocumentAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -197,7 +197,7 @@ public static XDocumentAssertions Should([NotNull] this XDocument actualValue)
     [Pure]
     public static XElementAssertions Should([NotNull] this XElement actualValue)
     {
-        return new XElementAssertions(actualValue);
+        return new XElementAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -207,7 +207,7 @@ public static XElementAssertions Should([NotNull] this XElement actualValue)
     [Pure]
     public static XAttributeAssertions Should([NotNull] this XAttribute actualValue)
     {
-        return new XAttributeAssertions(actualValue);
+        return new XAttributeAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -217,9 +217,11 @@ public static XAttributeAssertions Should([NotNull] this XAttribute actualValue)
     [Pure]
     public static StreamAssertions Should([NotNull] this Stream actualValue)
     {
-        return new StreamAssertions(actualValue);
+        return new StreamAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
+#if NET6_0_OR_GREATER || NETSTANDARD2_1
+
     /// <summary>
     /// Returns an <see cref="BufferedStreamAssertions"/> object that can be used to assert the
     /// current <see cref="BufferedStream"/>.
@@ -227,9 +229,11 @@ public static StreamAssertions Should([NotNull] this Stream actualValue)
     [Pure]
     public static BufferedStreamAssertions Should([NotNull] this BufferedStream actualValue)
     {
-        return new BufferedStreamAssertions(actualValue);
+        return new BufferedStreamAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
+#endif
+
     /// <summary>
     /// Forces enumerating a collection. Should be used to assert that a method that uses the
     /// <see langword="yield"/> keyword throws a particular exception.
@@ -284,7 +288,7 @@ private static void ForceEnumeration<T>(T subject, Func<T, IEnumerable> enumerab
     [Pure]
     public static ObjectAssertions Should([NotNull] this object actualValue)
     {
-        return new ObjectAssertions(actualValue);
+        return new ObjectAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -294,7 +298,7 @@ public static ObjectAssertions Should([NotNull] this object actualValue)
     [Pure]
     public static BooleanAssertions Should(this bool actualValue)
     {
-        return new BooleanAssertions(actualValue);
+        return new BooleanAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -304,7 +308,7 @@ public static BooleanAssertions Should(this bool actualValue)
     [Pure]
     public static NullableBooleanAssertions Should(this bool? actualValue)
     {
-        return new NullableBooleanAssertions(actualValue);
+        return new NullableBooleanAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -314,7 +318,7 @@ public static NullableBooleanAssertions Should(this bool? actualValue)
     [Pure]
     public static HttpResponseMessageAssertions Should([NotNull] this HttpResponseMessage actualValue)
     {
-        return new HttpResponseMessageAssertions(actualValue);
+        return new HttpResponseMessageAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -324,7 +328,7 @@ public static HttpResponseMessageAssertions Should([NotNull] this HttpResponseMe
     [Pure]
     public static GuidAssertions Should(this Guid actualValue)
     {
-        return new GuidAssertions(actualValue);
+        return new GuidAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -334,7 +338,7 @@ public static GuidAssertions Should(this Guid actualValue)
     [Pure]
     public static NullableGuidAssertions Should(this Guid? actualValue)
     {
-        return new NullableGuidAssertions(actualValue);
+        return new NullableGuidAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -344,7 +348,7 @@ public static NullableGuidAssertions Should(this Guid? actualValue)
     [Pure]
     public static GenericCollectionAssertions<T> Should<T>([NotNull] this IEnumerable<T> actualValue)
     {
-        return new GenericCollectionAssertions<T>(actualValue);
+        return new GenericCollectionAssertions<T>(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -354,7 +358,7 @@ public static GenericCollectionAssertions<T> Should<T>([NotNull] this IEnumerabl
     [Pure]
     public static StringCollectionAssertions Should([NotNull] this IEnumerable<string> @this)
     {
-        return new StringCollectionAssertions(@this);
+        return new StringCollectionAssertions(@this, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -365,7 +369,7 @@ public static StringCollectionAssertions Should([NotNull] this IEnumerable<strin
     public static GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValue> Should<TKey, TValue>(
         [NotNull] this IDictionary<TKey, TValue> actualValue)
     {
-        return new GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValue>(actualValue);
+        return new GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValue>(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -376,7 +380,8 @@ public static GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValu
     public static GenericDictionaryAssertions<IEnumerable<KeyValuePair<TKey, TValue>>, TKey, TValue> Should<TKey, TValue>(
         [NotNull] this IEnumerable<KeyValuePair<TKey, TValue>> actualValue)
     {
-        return new GenericDictionaryAssertions<IEnumerable<KeyValuePair<TKey, TValue>>, TKey, TValue>(actualValue);
+        return new GenericDictionaryAssertions<IEnumerable<KeyValuePair<TKey, TValue>>, TKey, TValue>(actualValue,
+            AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -388,7 +393,7 @@ public static GenericDictionaryAssertions<TCollection, TKey, TValue> Should<TCol
         [NotNull] this TCollection actualValue)
         where TCollection : IEnumerable<KeyValuePair<TKey, TValue>>
     {
-        return new GenericDictionaryAssertions<TCollection, TKey, TValue>(actualValue);
+        return new GenericDictionaryAssertions<TCollection, TKey, TValue>(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -398,7 +403,7 @@ public static GenericDictionaryAssertions<TCollection, TKey, TValue> Should<TCol
     [Pure]
     public static DateTimeAssertions Should(this DateTime actualValue)
     {
-        return new DateTimeAssertions(actualValue);
+        return new DateTimeAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -408,7 +413,7 @@ public static DateTimeAssertions Should(this DateTime actualValue)
     [Pure]
     public static DateTimeOffsetAssertions Should(this DateTimeOffset actualValue)
     {
-        return new DateTimeOffsetAssertions(actualValue);
+        return new DateTimeOffsetAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -418,7 +423,7 @@ public static DateTimeOffsetAssertions Should(this DateTimeOffset actualValue)
     [Pure]
     public static NullableDateTimeAssertions Should(this DateTime? actualValue)
     {
-        return new NullableDateTimeAssertions(actualValue);
+        return new NullableDateTimeAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -428,7 +433,7 @@ public static NullableDateTimeAssertions Should(this DateTime? actualValue)
     [Pure]
     public static NullableDateTimeOffsetAssertions Should(this DateTimeOffset? actualValue)
     {
-        return new NullableDateTimeOffsetAssertions(actualValue);
+        return new NullableDateTimeOffsetAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
 #if NET6_0_OR_GREATER
@@ -439,7 +444,7 @@ public static NullableDateTimeOffsetAssertions Should(this DateTimeOffset? actua
     [Pure]
     public static DateOnlyAssertions Should(this DateOnly actualValue)
     {
-        return new DateOnlyAssertions(actualValue);
+        return new DateOnlyAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -449,7 +454,7 @@ public static DateOnlyAssertions Should(this DateOnly actualValue)
     [Pure]
     public static NullableDateOnlyAssertions Should(this DateOnly? actualValue)
     {
-        return new NullableDateOnlyAssertions(actualValue);
+        return new NullableDateOnlyAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -459,7 +464,7 @@ public static NullableDateOnlyAssertions Should(this DateOnly? actualValue)
     [Pure]
     public static TimeOnlyAssertions Should(this TimeOnly actualValue)
     {
-        return new TimeOnlyAssertions(actualValue);
+        return new TimeOnlyAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -469,7 +474,7 @@ public static TimeOnlyAssertions Should(this TimeOnly actualValue)
     [Pure]
     public static NullableTimeOnlyAssertions Should(this TimeOnly? actualValue)
     {
-        return new NullableTimeOnlyAssertions(actualValue);
+        return new NullableTimeOnlyAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
 #endif
@@ -481,7 +486,7 @@ public static NullableTimeOnlyAssertions Should(this TimeOnly? actualValue)
     [Pure]
     public static ComparableTypeAssertions<T> Should<T>([NotNull] this IComparable<T> comparableValue)
     {
-        return new ComparableTypeAssertions<T>(comparableValue);
+        return new ComparableTypeAssertions<T>(comparableValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -491,7 +496,7 @@ public static ComparableTypeAssertions<T> Should<T>([NotNull] this IComparable<T
     [Pure]
     public static NumericAssertions<int> Should(this int actualValue)
     {
-        return new Int32Assertions(actualValue);
+        return new Int32Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -501,7 +506,7 @@ public static NumericAssertions<int> Should(this int actualValue)
     [Pure]
     public static NullableNumericAssertions<int> Should(this int? actualValue)
     {
-        return new NullableInt32Assertions(actualValue);
+        return new NullableInt32Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -511,7 +516,7 @@ public static NullableNumericAssertions<int> Should(this int? actualValue)
     [Pure]
     public static NumericAssertions<uint> Should(this uint actualValue)
     {
-        return new UInt32Assertions(actualValue);
+        return new UInt32Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -521,7 +526,7 @@ public static NumericAssertions<uint> Should(this uint actualValue)
     [Pure]
     public static NullableNumericAssertions<uint> Should(this uint? actualValue)
     {
-        return new NullableUInt32Assertions(actualValue);
+        return new NullableUInt32Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -531,7 +536,7 @@ public static NullableNumericAssertions<uint> Should(this uint? actualValue)
     [Pure]
     public static NumericAssertions<decimal> Should(this decimal actualValue)
     {
-        return new DecimalAssertions(actualValue);
+        return new DecimalAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -541,7 +546,7 @@ public static NumericAssertions<decimal> Should(this decimal actualValue)
     [Pure]
     public static NullableNumericAssertions<decimal> Should(this decimal? actualValue)
     {
-        return new NullableDecimalAssertions(actualValue);
+        return new NullableDecimalAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -551,7 +556,7 @@ public static NullableNumericAssertions<decimal> Should(this decimal? actualValu
     [Pure]
     public static NumericAssertions<byte> Should(this byte actualValue)
     {
-        return new ByteAssertions(actualValue);
+        return new ByteAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -561,7 +566,7 @@ public static NumericAssertions<byte> Should(this byte actualValue)
     [Pure]
     public static NullableNumericAssertions<byte> Should(this byte? actualValue)
     {
-        return new NullableByteAssertions(actualValue);
+        return new NullableByteAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -571,7 +576,7 @@ public static NullableNumericAssertions<byte> Should(this byte? actualValue)
     [Pure]
     public static NumericAssertions<sbyte> Should(this sbyte actualValue)
     {
-        return new SByteAssertions(actualValue);
+        return new SByteAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -581,7 +586,7 @@ public static NumericAssertions<sbyte> Should(this sbyte actualValue)
     [Pure]
     public static NullableNumericAssertions<sbyte> Should(this sbyte? actualValue)
     {
-        return new NullableSByteAssertions(actualValue);
+        return new NullableSByteAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -591,7 +596,7 @@ public static NullableNumericAssertions<sbyte> Should(this sbyte? actualValue)
     [Pure]
     public static NumericAssertions<short> Should(this short actualValue)
     {
-        return new Int16Assertions(actualValue);
+        return new Int16Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -601,7 +606,7 @@ public static NumericAssertions<short> Should(this short actualValue)
     [Pure]
     public static NullableNumericAssertions<short> Should(this short? actualValue)
     {
-        return new NullableInt16Assertions(actualValue);
+        return new NullableInt16Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -611,7 +616,7 @@ public static NullableNumericAssertions<short> Should(this short? actualValue)
     [Pure]
     public static NumericAssertions<ushort> Should(this ushort actualValue)
     {
-        return new UInt16Assertions(actualValue);
+        return new UInt16Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -621,7 +626,7 @@ public static NumericAssertions<ushort> Should(this ushort actualValue)
     [Pure]
     public static NullableNumericAssertions<ushort> Should(this ushort? actualValue)
     {
-        return new NullableUInt16Assertions(actualValue);
+        return new NullableUInt16Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -631,7 +636,7 @@ public static NullableNumericAssertions<ushort> Should(this ushort? actualValue)
     [Pure]
     public static NumericAssertions<long> Should(this long actualValue)
     {
-        return new Int64Assertions(actualValue);
+        return new Int64Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -641,7 +646,7 @@ public static NumericAssertions<long> Should(this long actualValue)
     [Pure]
     public static NullableNumericAssertions<long> Should(this long? actualValue)
     {
-        return new NullableInt64Assertions(actualValue);
+        return new NullableInt64Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -651,7 +656,7 @@ public static NullableNumericAssertions<long> Should(this long? actualValue)
     [Pure]
     public static NumericAssertions<ulong> Should(this ulong actualValue)
     {
-        return new UInt64Assertions(actualValue);
+        return new UInt64Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -661,7 +666,7 @@ public static NumericAssertions<ulong> Should(this ulong actualValue)
     [Pure]
     public static NullableNumericAssertions<ulong> Should(this ulong? actualValue)
     {
-        return new NullableUInt64Assertions(actualValue);
+        return new NullableUInt64Assertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -671,7 +676,7 @@ public static NullableNumericAssertions<ulong> Should(this ulong? actualValue)
     [Pure]
     public static NumericAssertions<float> Should(this float actualValue)
     {
-        return new SingleAssertions(actualValue);
+        return new SingleAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -681,7 +686,7 @@ public static NumericAssertions<float> Should(this float actualValue)
     [Pure]
     public static NullableNumericAssertions<float> Should(this float? actualValue)
     {
-        return new NullableSingleAssertions(actualValue);
+        return new NullableSingleAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -691,7 +696,7 @@ public static NullableNumericAssertions<float> Should(this float? actualValue)
     [Pure]
     public static NumericAssertions<double> Should(this double actualValue)
     {
-        return new DoubleAssertions(actualValue);
+        return new DoubleAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -701,7 +706,7 @@ public static NumericAssertions<double> Should(this double actualValue)
     [Pure]
     public static NullableNumericAssertions<double> Should(this double? actualValue)
     {
-        return new NullableDoubleAssertions(actualValue);
+        return new NullableDoubleAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -711,7 +716,7 @@ public static NullableNumericAssertions<double> Should(this double? actualValue)
     [Pure]
     public static StringAssertions Should([NotNull] this string actualValue)
     {
-        return new StringAssertions(actualValue);
+        return new StringAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -721,7 +726,7 @@ public static StringAssertions Should([NotNull] this string actualValue)
     [Pure]
     public static SimpleTimeSpanAssertions Should(this TimeSpan actualValue)
     {
-        return new SimpleTimeSpanAssertions(actualValue);
+        return new SimpleTimeSpanAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -731,7 +736,7 @@ public static SimpleTimeSpanAssertions Should(this TimeSpan actualValue)
     [Pure]
     public static NullableSimpleTimeSpanAssertions Should(this TimeSpan? actualValue)
     {
-        return new NullableSimpleTimeSpanAssertions(actualValue);
+        return new NullableSimpleTimeSpanAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -741,7 +746,7 @@ public static NullableSimpleTimeSpanAssertions Should(this TimeSpan? actualValue
     [Pure]
     public static TypeAssertions Should([NotNull] this Type subject)
     {
-        return new TypeAssertions(subject);
+        return new TypeAssertions(subject, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -754,7 +759,7 @@ public static TypeSelectorAssertions Should(this TypeSelector typeSelector)
     {
         Guard.ThrowIfArgumentIsNull(typeSelector);
 
-        return new TypeSelectorAssertions(typeSelector.ToArray());
+        return new TypeSelectorAssertions(AssertionChain.GetOrCreate(),  typeSelector.ToArray());
     }
 
     /// <summary>
@@ -765,7 +770,7 @@ public static TypeSelectorAssertions Should(this TypeSelector typeSelector)
     [Pure]
     public static ConstructorInfoAssertions Should([NotNull] this ConstructorInfo constructorInfo)
     {
-        return new ConstructorInfoAssertions(constructorInfo);
+        return new ConstructorInfoAssertions(constructorInfo, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -775,7 +780,7 @@ public static ConstructorInfoAssertions Should([NotNull] this ConstructorInfo co
     [Pure]
     public static MethodInfoAssertions Should([NotNull] this MethodInfo methodInfo)
     {
-        return new MethodInfoAssertions(methodInfo);
+        return new MethodInfoAssertions(methodInfo, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -789,7 +794,7 @@ public static MethodInfoSelectorAssertions Should(this MethodInfoSelector method
     {
         Guard.ThrowIfArgumentIsNull(methodSelector);
 
-        return new MethodInfoSelectorAssertions(methodSelector.ToArray());
+        return new MethodInfoSelectorAssertions(AssertionChain.GetOrCreate(), methodSelector.ToArray());
     }
 
     /// <summary>
@@ -800,7 +805,7 @@ public static MethodInfoSelectorAssertions Should(this MethodInfoSelector method
     [Pure]
     public static PropertyInfoAssertions Should([NotNull] this PropertyInfo propertyInfo)
     {
-        return new PropertyInfoAssertions(propertyInfo);
+        return new PropertyInfoAssertions(propertyInfo, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -814,7 +819,7 @@ public static PropertyInfoSelectorAssertions Should(this PropertyInfoSelector pr
     {
         Guard.ThrowIfArgumentIsNull(propertyInfoSelector);
 
-        return new PropertyInfoSelectorAssertions(propertyInfoSelector.ToArray());
+        return new PropertyInfoSelectorAssertions(AssertionChain.GetOrCreate(), propertyInfoSelector.ToArray());
     }
 
     /// <summary>
@@ -824,7 +829,7 @@ public static PropertyInfoSelectorAssertions Should(this PropertyInfoSelector pr
     [Pure]
     public static ActionAssertions Should([NotNull] this Action action)
     {
-        return new ActionAssertions(action, Extractor);
+        return new ActionAssertions(action, Extractor, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -834,7 +839,7 @@ public static ActionAssertions Should([NotNull] this Action action)
     [Pure]
     public static NonGenericAsyncFunctionAssertions Should([NotNull] this Func<Task> action)
     {
-        return new NonGenericAsyncFunctionAssertions(action, Extractor);
+        return new NonGenericAsyncFunctionAssertions(action, Extractor, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -844,7 +849,7 @@ public static NonGenericAsyncFunctionAssertions Should([NotNull] this Func<Task>
     [Pure]
     public static GenericAsyncFunctionAssertions<T> Should<T>([NotNull] this Func<Task<T>> action)
     {
-        return new GenericAsyncFunctionAssertions<T>(action, Extractor);
+        return new GenericAsyncFunctionAssertions<T>(action, Extractor, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -854,7 +859,7 @@ public static GenericAsyncFunctionAssertions<T> Should<T>([NotNull] this Func<Ta
     [Pure]
     public static FunctionAssertions<T> Should<T>([NotNull] this Func<T> func)
     {
-        return new FunctionAssertions<T>(func, Extractor);
+        return new FunctionAssertions<T>(func, Extractor, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -864,7 +869,7 @@ public static FunctionAssertions<T> Should<T>([NotNull] this Func<T> func)
     [Pure]
     public static TaskCompletionSourceAssertions<T> Should<T>(this TaskCompletionSource<T> tcs)
     {
-        return new TaskCompletionSourceAssertions<T>(tcs);
+        return new TaskCompletionSourceAssertions<T>(tcs, AssertionChain.GetOrCreate());
     }
 
 #if !NETSTANDARD2_0
@@ -906,7 +911,7 @@ public static IMonitor<T> Monitor<T>(this T eventSource, Action<EventMonitorOpti
     [Pure]
     public static TaskCompletionSourceAssertions Should(this TaskCompletionSource tcs)
     {
-        return new TaskCompletionSourceAssertions(tcs);
+        return new TaskCompletionSourceAssertions(tcs, AssertionChain.GetOrCreate());
     }
 
 #endif
diff --git a/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs b/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs
index 3c33ae9a28..56f02c6ea5 100644
--- a/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs
+++ b/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs
@@ -17,8 +17,8 @@ namespace FluentAssertions.Collections;
 [DebuggerNonUserCode]
 public class GenericCollectionAssertions<T> : GenericCollectionAssertions<IEnumerable<T>, T, GenericCollectionAssertions<T>>
 {
-    public GenericCollectionAssertions(IEnumerable<T> actualValue)
-        : base(actualValue)
+    public GenericCollectionAssertions(IEnumerable<T> actualValue, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
     }
 }
@@ -28,22 +28,26 @@ public class GenericCollectionAssertions<TCollection, T>
     : GenericCollectionAssertions<TCollection, T, GenericCollectionAssertions<TCollection, T>>
     where TCollection : IEnumerable<T>
 {
-    public GenericCollectionAssertions(TCollection actualValue)
-        : base(actualValue)
+    public GenericCollectionAssertions(TCollection actualValue, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
     }
 }
 
 #pragma warning disable CS0659, S1206 // Ignore not overriding Object.GetHashCode()
 #pragma warning disable CA1065 // Ignore throwing NotSupportedException from Equals
+
 [DebuggerNonUserCode]
 public class GenericCollectionAssertions<TCollection, T, TAssertions> : ReferenceTypeAssertions<TCollection, TAssertions>
     where TCollection : IEnumerable<T>
     where TAssertions : GenericCollectionAssertions<TCollection, T, TAssertions>
 {
-    public GenericCollectionAssertions(TCollection actualValue)
-        : base(actualValue)
+    private readonly AssertionChain assertionChain;
+
+    public GenericCollectionAssertions(TCollection actualValue, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -63,9 +67,10 @@ public GenericCollectionAssertions(TCollection actualValue)
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeAssignableTo<TExpectation>(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type to be {0}{reason}, but found {context:the collection} is <null>.",
@@ -73,18 +78,16 @@ public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeAssignabl
 
         IEnumerable<TExpectation> matches = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected type to be {0}{reason}, ", typeof(TExpectation).FullName)
-                .ForCondition(Subject!.All(x => x is not null))
-                .FailWith("but found a null element.")
-                .Then
-                .ForCondition(Subject.All(x => typeof(TExpectation).IsAssignableFrom(GetType(x))))
-                .FailWith("but found {0}.", () => $"[{string.Join(", ", Subject.Select(x => GetType(x).FullName))}]")
-                .Then
-                .ClearExpectation();
+                .WithExpectation("Expected type to be {0}{reason}, ", typeof(TExpectation).FullName, chain => chain
+                    .ForCondition(Subject!.All(x => x is not null))
+                    .FailWith("but found a null element.")
+                    .Then
+                    .ForCondition(Subject.All(x => typeof(TExpectation).IsAssignableFrom(GetType(x))))
+                    .FailWith("but found {0}.", () => $"[{string.Join(", ", Subject.Select(x => GetType(x).FullName))}]"));
 
             matches = Subject.OfType<TExpectation>();
         }
@@ -109,20 +112,18 @@ public AndConstraint<TAssertions> AllBeAssignableTo(Type expectedType,
     {
         Guard.ThrowIfArgumentIsNull(expectedType);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected type to be {0}{reason}, ", expectedType.FullName)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found {context:collection} is <null>.")
-            .Then
-            .ForCondition(subject => subject.All(x => x is not null))
-            .FailWith("but found a null element.")
-            .Then
-            .ForCondition(subject => subject.All(x => expectedType.IsAssignableFrom(GetType(x))))
-            .FailWith("but found {0}.", subject => $"[{string.Join(", ", subject.Select(x => GetType(x).FullName))}]")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected type to be {0}{reason}, ", expectedType.FullName, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found {context:collection} is <null>.")
+                .Then
+                .ForCondition(subject => subject.All(x => x is not null))
+                .FailWith("but found a null element.")
+                .Then
+                .ForCondition(subject => subject.All(x => expectedType.IsAssignableFrom(GetType(x))))
+                .FailWith("but found {0}.", subject => $"[{string.Join(", ", subject.Select(x => GetType(x).FullName))}]"));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -180,7 +181,8 @@ public AndConstraint<TAssertions> AllBeEquivalentTo<TExpectation>(TExpectation e
     /// <exception cref="ArgumentNullException"><paramref name="config"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> AllBeEquivalentTo<TExpectation>(TExpectation expectation,
         Func<EquivalencyOptions<TExpectation>, EquivalencyOptions<TExpectation>> config,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(config);
 
@@ -210,9 +212,10 @@ public AndConstraint<TAssertions> AllBeEquivalentTo<TExpectation>(TExpectation e
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeOfType<TExpectation>(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type to be {0}{reason}, but found {context:collection} is <null>.",
@@ -220,18 +223,16 @@ public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeOfType<TE
 
         IEnumerable<TExpectation> matches = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected type to be {0}{reason}, ", typeof(TExpectation).FullName)
-                .ForCondition(Subject!.All(x => x is not null))
-                .FailWith("but found a null element.")
-                .Then
-                .ForCondition(Subject.All(x => typeof(TExpectation) == GetType(x)))
-                .FailWith("but found {0}.", () => $"[{string.Join(", ", Subject.Select(x => GetType(x).FullName))}]")
-                .Then
-                .ClearExpectation();
+                .WithExpectation("Expected type to be {0}{reason}, ", typeof(TExpectation).FullName, chain => chain
+                    .ForCondition(Subject!.All(x => x is not null))
+                    .FailWith("but found a null element.")
+                    .Then
+                    .ForCondition(Subject.All(x => typeof(TExpectation) == GetType(x)))
+                    .FailWith("but found {0}.", () => $"[{string.Join(", ", Subject.Select(x => GetType(x).FullName))}]"));
 
             matches = Subject.OfType<TExpectation>();
         }
@@ -251,25 +252,23 @@ public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeOfType<TE
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expectedType"/> is <see langword="null"/>.</exception>
-    public AndConstraint<TAssertions> AllBeOfType(Type expectedType,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> AllBeOfType(Type expectedType, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expectedType);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected type to be {0}{reason}, ", expectedType.FullName)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found {context:collection} is <null>.")
-            .Then
-            .ForCondition(subject => subject.All(x => x is not null))
-            .FailWith("but found a null element.")
-            .Then
-            .ForCondition(subject => subject.All(x => expectedType == GetType(x)))
-            .FailWith("but found {0}.", subject => $"[{string.Join(", ", subject.Select(x => GetType(x).FullName))}]")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected type to be {0}{reason}, ", expectedType.FullName, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found {context:collection} is <null>.")
+                .Then
+                .ForCondition(subject => subject.All(x => x is not null))
+                .FailWith("but found a null element.")
+                .Then
+                .ForCondition(subject => subject.All(x => expectedType == GetType(x)))
+                .FailWith("but found {0}.", subject => $"[{string.Join(", ", subject.Select(x => GetType(x).FullName))}]"));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -287,17 +286,16 @@ public AndConstraint<TAssertions> AllBeOfType(Type expectedType,
     public AndConstraint<TAssertions> BeEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         var singleItemArray = Subject?.Take(1).ToArray();
-        Execute.Assertion
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to be empty{reason}, ")
-            .Given(() => singleItemArray)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .ForCondition(subject => subject.Length == 0)
-            .FailWith("but found at least one item {0}.", singleItemArray)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to be empty{reason}, ", chain => chain
+                .Given(() => singleItemArray)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .ForCondition(subject => subject.Length == 0)
+                .FailWith("but found at least one item {0}.", singleItemArray));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -355,7 +353,8 @@ public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(IEnumerable<TExpe
     /// <exception cref="ArgumentNullException"><paramref name="config"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(IEnumerable<TExpectation> expectation,
         Func<EquivalencyOptions<TExpectation>, EquivalencyOptions<TExpectation>> config,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(config);
 
@@ -363,7 +362,8 @@ public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(IEnumerable<TExpe
             config(AssertionOptions.CloneDefaults<TExpectation>()).AsCollection();
 
         var context =
-            new EquivalencyValidationContext(Node.From<IEnumerable<TExpectation>>(() => AssertionScope.Current.CallerIdentity),
+            new EquivalencyValidationContext(
+                Node.From<IEnumerable<TExpectation>>(() => CallerIdentifier.DetermineCallerIdentity()),
                 options)
             {
                 Reason = new Reason(because, becauseArgs),
@@ -425,8 +425,7 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder<TSelect
     /// </remarks>
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(
-        IComparer<T> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        IComparer<T> comparer, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -457,7 +456,8 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder<TSelector>(
         Expression<Func<T, TSelector>> propertyExpression, IComparer<TSelector> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -479,8 +479,7 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder<TSelect
     /// <remarks>
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
-    public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(string because = "", params object[] becauseArgs)
     {
         return BeInAscendingOrder(GetComparer<T>(), because, becauseArgs);
     }
@@ -503,7 +502,8 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(Func<T, T, int> comparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return BeInOrder(Comparer<T>.Create((x, y) => comparison(x, y)), SortOrder.Ascending, because, becauseArgs);
     }
@@ -526,8 +526,8 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInAscendingOrder(Func<T,
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder<TSelector>(
-        Expression<Func<T, TSelector>> propertyExpression,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Expression<Func<T, TSelector>> propertyExpression, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return BeInDescendingOrder(propertyExpression, GetComparer<TSelector>(), because, becauseArgs);
     }
@@ -551,8 +551,7 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder<TSelec
     /// </remarks>
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(
-        IComparer<T> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        IComparer<T> comparer, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -583,7 +582,8 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder<TSelector>(
         Expression<Func<T, TSelector>> propertyExpression, IComparer<TSelector> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -605,8 +605,7 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder<TSelec
     /// <remarks>
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
-    public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(string because = "", params object[] becauseArgs)
     {
         return BeInDescendingOrder(GetComparer<T>(), because, becauseArgs);
     }
@@ -629,7 +628,8 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(Func<T, T, int> comparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return BeInOrder(Comparer<T>.Create((x, y) => comparison(x, y)), SortOrder.Descending, because, becauseArgs);
     }
@@ -644,12 +644,12 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(Func<T
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> BeNullOrEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> BeNullOrEmpty(string because = "", params object[] becauseArgs)
     {
         var singleItemArray = Subject?.Take(1).ToArray();
         var nullOrEmpty = singleItemArray is null || singleItemArray.Length == 0;
 
-        Execute.Assertion.ForCondition(nullOrEmpty)
+        assertionChain.ForCondition(nullOrEmpty)
             .BecauseOf(because, becauseArgs)
             .FailWith(
                 "Expected {context:collection} to be null or empty{reason}, but found at least one item {0}.",
@@ -671,23 +671,22 @@ public AndConstraint<TAssertions> BeNullOrEmpty([StringSyntax("CompositeFormat")
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expectedSuperset"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> BeSubsetOf(IEnumerable<T> expectedSuperset,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expectedSuperset, nameof(expectedSuperset),
             "Cannot verify a subset against a <null> collection.");
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to be a subset of {0}{reason}, ", expectedSuperset)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(subject => subject.Except(expectedSuperset))
-            .ForCondition(excessItems => !excessItems.Any())
-            .FailWith("but items {0} are not part of the superset.", excessItems => excessItems)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to be a subset of {0}{reason}, ", expectedSuperset, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .Given(subject => subject.Except(expectedSuperset))
+                .ForCondition(excessItems => !excessItems.Any())
+                .FailWith("but items {0} are not part of the superset.", excessItems => excessItems));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -703,21 +702,21 @@ public AndConstraint<TAssertions> BeSubsetOf(IEnumerable<T> expectedSuperset,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndWhichConstraint<TAssertions, T> Contain(T expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndWhichConstraint<TAssertions, T> Contain(T expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0}{reason}, but found <null>.", expected);
 
         IEnumerable<T> matches = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             ICollection<T> collection = Subject.ConvertOrCastToCollection();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(collection.Contains(expected))
                 .FailWith("Expected {context:collection} {0} to contain {1}{reason}.", collection, expected);
@@ -746,25 +745,37 @@ public AndWhichConstraint<TAssertions, T> Contain(Expression<Func<T, bool>> pred
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0}{reason}, but found <null>.", predicate.Body);
 
         IEnumerable<T> matches = [];
 
-        if (success)
+        int? firstMatchingIndex = null;
+        if (assertionChain.Succeeded)
         {
             Func<T, bool> func = predicate.Compile();
 
-            Execute.Assertion
-                .ForCondition(Subject!.Any(func))
+            foreach (var (item, index) in Subject!.Select((item, index) => (item, index)))
+            {
+                if (func(item))
+                {
+                    firstMatchingIndex = index;
+                    break;
+                }
+            }
+
+            assertionChain
+                .ForCondition(firstMatchingIndex.HasValue)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} {0} to have an item matching {1}{reason}.", Subject, predicate.Body);
 
             matches = Subject.Where(func);
         }
 
+        assertionChain.WithCallerPostfix($"[{firstMatchingIndex}]").ReuseOnce();
+
         return new AndWhichConstraint<TAssertions, T>((TAssertions)this, matches);
     }
 
@@ -782,20 +793,20 @@ public AndWhichConstraint<TAssertions, T> Contain(Expression<Func<T, bool>> pred
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="expected"/> is empty.</exception>
-    public AndConstraint<TAssertions> Contain(IEnumerable<T> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Contain(IEnumerable<T> expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot verify containment against a <null> collection");
 
         ICollection<T> expectedObjects = expected.ConvertOrCastToCollection();
         Guard.ThrowIfArgumentIsEmpty(expectedObjects, nameof(expected), "Cannot verify containment against an empty collection");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0}{reason}, but found <null>.", expectedObjects);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<T> missingItems = expectedObjects.Except(Subject!);
 
@@ -803,14 +814,14 @@ public AndConstraint<TAssertions> Contain(IEnumerable<T> expected,
             {
                 if (expectedObjects.Count > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} {0} to contain {1}{reason}, but could not find {2}.",
                             Subject, expectedObjects, missingItems);
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} {0} to contain {1}{reason}.",
                             Subject, expectedObjects.Single());
@@ -844,7 +855,8 @@ public AndConstraint<TAssertions> Contain(IEnumerable<T> expected,
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
     public AndWhichConstraint<TAssertions, T> ContainEquivalentOf<TExpectation>(TExpectation expectation,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return ContainEquivalentOf(expectation, config => config, because, becauseArgs);
     }
@@ -879,27 +891,28 @@ public AndWhichConstraint<TAssertions, T> ContainEquivalentOf<TExpectation>(TExp
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="config"/> is <see langword="null"/>.</exception>
     public AndWhichConstraint<TAssertions, T> ContainEquivalentOf<TExpectation>(TExpectation expectation,
-        Func<EquivalencyOptions<TExpectation>, EquivalencyOptions<TExpectation>> config,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Func<EquivalencyOptions<TExpectation>,
+            EquivalencyOptions<TExpectation>> config, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(config);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain equivalent of {0}{reason}, but found <null>.", expectation);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             EquivalencyOptions<TExpectation> options = config(AssertionOptions.CloneDefaults<TExpectation>());
 
             using var scope = new AssertionScope();
-            scope.AddReportable("configuration", () => options.ToString());
+            assertionChain.AddReportable("configuration", () => options.ToString());
 
-            foreach (T actualItem in Subject!)
+            foreach ((T actualItem, int index) in Subject!.Select((item, index) => (item, index)))
             {
                 var context =
-                    new EquivalencyValidationContext(Node.From<TExpectation>(() => AssertionScope.Current.CallerIdentity),
+                    new EquivalencyValidationContext(Node.From<TExpectation>(() => CurrentAssertionChain.CallerIdentifier),
                         options)
                     {
                         Reason = new Reason(because, becauseArgs),
@@ -919,11 +932,11 @@ public AndWhichConstraint<TAssertions, T> ContainEquivalentOf<TExpectation>(TExp
 
                 if (failures.Length == 0)
                 {
-                    return new AndWhichConstraint<TAssertions, T>((TAssertions)this, actualItem);
+                    return new AndWhichConstraint<TAssertions, T>((TAssertions)this, actualItem, assertionChain, $"[{index}]");
                 }
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} {0} to contain equivalent of {1}{reason}.", Subject, expectation);
         }
@@ -957,16 +970,17 @@ public AndConstraint<TAssertions> ContainInOrder(params T[] expected)
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> ContainInOrder(IEnumerable<T> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot verify ordered containment against a <null> collection.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0} in order{reason}, but found <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IList<T> expectedItems = expected.ConvertOrCastToList();
             IList<T> actualItems = Subject.ConvertOrCastToList();
@@ -980,7 +994,7 @@ public AndConstraint<TAssertions> ContainInOrder(IEnumerable<T> expected,
 
                 if (subjectIndex == -1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith(
                             "Expected {context:collection} {0} to contain items {1} in order{reason}" +
@@ -1019,16 +1033,17 @@ public AndConstraint<TAssertions> ContainInConsecutiveOrder(params T[] expected)
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> ContainInConsecutiveOrder(IEnumerable<T> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot verify ordered containment against a <null> collection.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0} in order{reason}, but found <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IList<T> expectedItems = expected.ConvertOrCastToList();
 
@@ -1060,7 +1075,7 @@ public AndConstraint<TAssertions> ContainInConsecutiveOrder(IEnumerable<T> expec
                 }
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
                     "Expected {context:collection} {0} to contain items {1} in order{reason}" +
@@ -1081,21 +1096,18 @@ public AndConstraint<TAssertions> ContainInConsecutiveOrder(IEnumerable<T> expec
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> ContainItemsAssignableTo<TExpectation>(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> ContainItemsAssignableTo<TExpectation>(string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .WithExpectation("Expected {context:collection} to contain at least one element assignable to type {0}{reason}, ",
-                typeof(TExpectation).FullName)
-            .ForCondition(Subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(() => Subject.ConvertOrCastToCollection())
-            .ForCondition(subject => subject.Any(x => typeof(TExpectation).IsAssignableFrom(GetType(x))))
-            .FailWith("but found {0}.", subject => subject.Select(x => GetType(x)))
-            .Then
-            .ClearExpectation();
+                typeof(TExpectation).FullName, chain => chain
+                    .ForCondition(Subject is not null)
+                    .FailWith("but found <null>.")
+                    .Then
+                    .Given(() => Subject.ConvertOrCastToCollection())
+                    .ForCondition(subject => subject.Any(x => typeof(TExpectation).IsAssignableFrom(GetType(x))))
+                    .FailWith("but found {0}.", subject => subject.Select(x => GetType(x))));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1110,8 +1122,8 @@ public AndConstraint<TAssertions> ContainItemsAssignableTo<TExpectation>(
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotContainItemsAssignableTo<TExpectation>(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs) =>
+    public AndConstraint<TAssertions>
+        NotContainItemsAssignableTo<TExpectation>(string because = "", params object[] becauseArgs) =>
         NotContainItemsAssignableTo(typeof(TExpectation), because, becauseArgs);
 
     /// <summary>
@@ -1132,18 +1144,16 @@ public AndConstraint<TAssertions> NotContainItemsAssignableTo(Type type,
     {
         Guard.ThrowIfArgumentIsNull(type);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .WithExpectation("Expected {context:collection} to not contain any elements assignable to type {0}{reason}, ",
-                type.FullName)
-            .ForCondition(Subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(() => Subject.ConvertOrCastToCollection())
-            .ForCondition(subject => subject.All(x => !type.IsAssignableFrom(GetType(x))))
-            .FailWith("but found {0}.", subject => subject.Select(x => GetType(x)))
-            .Then
-            .ClearExpectation();
+                type.FullName, chain => chain
+                    .ForCondition(Subject is not null)
+                    .FailWith("but found <null>.")
+                    .Then
+                    .Given(() => Subject.ConvertOrCastToCollection())
+                    .ForCondition(subject => subject.All(x => !type.IsAssignableFrom(GetType(x))))
+                    .FailWith("but found {0}.", subject => subject.Select(x => GetType(x))));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1158,23 +1168,23 @@ public AndConstraint<TAssertions> NotContainItemsAssignableTo(Type type,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndWhichConstraint<TAssertions, T> ContainSingle([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndWhichConstraint<TAssertions, T> ContainSingle(string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain a single item{reason}, but found <null>.");
 
         T match = default;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             ICollection<T> actualItems = Subject.ConvertOrCastToCollection();
 
             switch (actualItems.Count)
             {
                 case 0: // Fail, Collection is empty
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} to contain a single item{reason}, but the collection is empty.");
 
@@ -1183,7 +1193,7 @@ public AndWhichConstraint<TAssertions, T> ContainSingle([StringSyntax("Composite
                     match = actualItems.Single();
                     break;
                 default: // Fail, Collection contains more than a single item
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} to contain a single item{reason}, but found {0}.", Subject);
 
@@ -1191,7 +1201,7 @@ public AndWhichConstraint<TAssertions, T> ContainSingle([StringSyntax("Composite
             }
         }
 
-        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, match);
+        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, match, assertionChain, "[0]");
     }
 
     /// <summary>
@@ -1207,25 +1217,25 @@ public AndWhichConstraint<TAssertions, T> ContainSingle([StringSyntax("Composite
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public AndWhichConstraint<TAssertions, T> ContainSingle(Expression<Func<T, bool>> predicate,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
         const string expectationPrefix =
             "Expected {context:collection} to contain a single item matching {0}{reason}, ";
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(expectationPrefix + "but found <null>.", predicate);
 
         T[] matches = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             ICollection<T> actualItems = Subject.ConvertOrCastToCollection();
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(actualItems.Count > 0)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(expectationPrefix + "but the collection is empty.", predicate);
@@ -1235,13 +1245,13 @@ public AndWhichConstraint<TAssertions, T> ContainSingle(Expression<Func<T, bool>
 
             if (count == 0)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith(expectationPrefix + "but no such item was found.", predicate);
             }
             else if (count > 1)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith(
                         expectationPrefix + "but " + count.ToString(CultureInfo.InvariantCulture) + " such items were found.",
@@ -1253,7 +1263,7 @@ public AndWhichConstraint<TAssertions, T> ContainSingle(Expression<Func<T, bool>
             }
         }
 
-        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, matches);
+        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, matches, assertionChain, "[0]");
     }
 
     /// <summary>
@@ -1270,8 +1280,8 @@ public AndWhichConstraint<TAssertions, T> ContainSingle(Expression<Func<T, bool>
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> EndWith(IEnumerable<T> expectation,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> EndWith(IEnumerable<T> expectation, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return EndWith(expectation, (a, b) => EqualityComparer<T>.Default.Equals(a, b), because, becauseArgs);
     }
@@ -1296,7 +1306,8 @@ public AndConstraint<TAssertions> EndWith(IEnumerable<T> expectation,
     /// <exception cref="ArgumentNullException"><paramref name="expectation"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> EndWith<TExpectation>(
         IEnumerable<TExpectation> expectation, Func<T, TExpectation, bool> equalityComparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expectation, nameof(expectation), "Cannot compare collection with <null>.");
 
@@ -1318,8 +1329,8 @@ public AndConstraint<TAssertions> EndWith<TExpectation>(
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> EndWith(T element,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> EndWith(T element, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return EndWith([element], ObjectExtensions.GetComparer<T>(), because, becauseArgs);
     }
@@ -1355,7 +1366,8 @@ public AndConstraint<TAssertions> Equal(params T[] elements)
     /// </param>
     public AndConstraint<TAssertions> Equal<TExpectation>(
         IEnumerable<TExpectation> expectation, Func<T, TExpectation, bool> equalityComparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         AssertSubjectEquality(expectation, equalityComparison, because, becauseArgs);
 
@@ -1374,8 +1386,8 @@ public AndConstraint<TAssertions> Equal<TExpectation>(
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> Equal(IEnumerable<T> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Equal(IEnumerable<T> expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         AssertSubjectEquality(expected, ObjectExtensions.GetComparer<T>(), because, becauseArgs);
 
@@ -1393,19 +1405,19 @@ public AndConstraint<TAssertions> Equal(IEnumerable<T> expected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveCount(int expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveCount(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0} item(s){reason}, but found <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             int actualCount = Subject!.Count();
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(actualCount == expected)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -1429,17 +1441,18 @@ public AndConstraint<TAssertions> HaveCount(int expected,
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="countPredicate"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> HaveCount(Expression<Func<int, bool>> countPredicate,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(countPredicate, nameof(countPredicate),
             "Cannot compare collection count against a <null> predicate.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain {0} items{reason}, but found <null>.", countPredicate.Body);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Func<int, bool> compiledPredicate = countPredicate.Compile();
 
@@ -1447,7 +1460,7 @@ public AndConstraint<TAssertions> HaveCount(Expression<Func<int, bool>> countPre
 
             if (!compiledPredicate(actualCount))
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:collection} to have a count {0}{reason}, but count is {1}: {2}.",
                         countPredicate.Body, actualCount, Subject);
@@ -1469,20 +1482,19 @@ public AndConstraint<TAssertions> HaveCount(Expression<Func<int, bool>> countPre
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndConstraint<TAssertions> HaveCountGreaterThanOrEqualTo(int expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to contain at least {0} item(s){reason}, ", expected)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(subject => subject.Count())
-            .ForCondition(actualCount => actualCount >= expected)
-            .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to contain at least {0} item(s){reason}, ", expected, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .Given(subject => subject.Count())
+                .ForCondition(actualCount => actualCount >= expected)
+                .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1498,21 +1510,19 @@ public AndConstraint<TAssertions> HaveCountGreaterThanOrEqualTo(int expected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveCountGreaterThan(int expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveCountGreaterThan(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to contain more than {0} item(s){reason}, ", expected)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(subject => subject.Count())
-            .ForCondition(actualCount => actualCount > expected)
-            .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to contain more than {0} item(s){reason}, ", expected, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .Given(subject => subject.Count())
+                .ForCondition(actualCount => actualCount > expected)
+                .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1531,18 +1541,16 @@ public AndConstraint<TAssertions> HaveCountGreaterThan(int expected,
     public AndConstraint<TAssertions> HaveCountLessThanOrEqualTo(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to contain at most {0} item(s){reason}, ", expected)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(subject => subject.Count())
-            .ForCondition(actualCount => actualCount <= expected)
-            .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to contain at most {0} item(s){reason}, ", expected, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .Given(subject => subject.Count())
+                .ForCondition(actualCount => actualCount <= expected)
+                .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1558,21 +1566,19 @@ public AndConstraint<TAssertions> HaveCountLessThanOrEqualTo(int expected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveCountLessThan(int expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveCountLessThan(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to contain fewer than {0} item(s){reason}, ", expected)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(subject => subject.Count())
-            .ForCondition(actualCount => actualCount < expected)
-            .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to contain fewer than {0} item(s){reason}, ", expected, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .Given(subject => subject.Count())
+                .ForCondition(actualCount => actualCount < expected)
+                .FailWith("but found {0}: {1}.", actualCount => actualCount, _ => Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1591,35 +1597,36 @@ public AndConstraint<TAssertions> HaveCountLessThan(int expected,
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndWhichConstraint<TAssertions, T> HaveElementAt(int index, T element,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to have element at index {0}{reason}, but found <null>.", index);
 
         T actual = default;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             if (index < Subject!.Count())
             {
                 actual = Subject.ElementAt(index);
 
-                Execute.Assertion
+                assertionChain
                     .ForCondition(ObjectExtensions.GetComparer<T>()(actual, element))
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {0} at index {1}{reason}, but found {2}.", element, index, actual);
             }
             else
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {0} at index {1}{reason}, but found no element.", element, index);
             }
         }
 
-        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, actual);
+        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, actual, assertionChain, $"[{index}]");
     }
 
     /// <summary>
@@ -1635,26 +1642,26 @@ public AndWhichConstraint<TAssertions, T> HaveElementAt(int index, T element,
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndConstraint<TAssertions> HaveElementPreceding(T successor, T expectation,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to have {0} precede {1}{reason}, ", expectation, successor)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but the collection is <null>.")
-            .Then
-            .ForCondition(subject => subject.Any())
-            .FailWith("but the collection is empty.")
-            .Then
-            .ForCondition(subject => HasPredecessor(successor, subject))
-            .FailWith("but found nothing.")
-            .Then
-            .Given(subject => PredecessorOf(successor, subject))
-            .ForCondition(predecessor => ObjectExtensions.GetComparer<T>()(predecessor, expectation))
-            .FailWith("but found {0}.", predecessor => predecessor)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to have {0} precede {1}{reason}, ", expectation, successor, chain =>
+                chain
+                    .Given(() => Subject)
+                    .ForCondition(subject => subject is not null)
+                    .FailWith("but the collection is <null>.")
+                    .Then
+                    .ForCondition(subject => subject.Any())
+                    .FailWith("but the collection is empty.")
+                    .Then
+                    .ForCondition(subject => HasPredecessor(successor, subject))
+                    .FailWith("but found nothing.")
+                    .Then
+                    .Given(subject => PredecessorOf(successor, subject))
+                    .ForCondition(predecessor => ObjectExtensions.GetComparer<T>()(predecessor, expectation))
+                    .FailWith("but found {0}.", predecessor => predecessor));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1672,26 +1679,26 @@ public AndConstraint<TAssertions> HaveElementPreceding(T successor, T expectatio
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndConstraint<TAssertions> HaveElementSucceeding(T predecessor, T expectation,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to have {0} succeed {1}{reason}, ", expectation, predecessor)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but the collection is <null>.")
-            .Then
-            .ForCondition(subject => subject.Any())
-            .FailWith("but the collection is empty.")
-            .Then
-            .ForCondition(subject => HasSuccessor(predecessor, subject))
-            .FailWith("but found nothing.")
-            .Then
-            .Given(subject => SuccessorOf(predecessor, subject))
-            .ForCondition(successor => ObjectExtensions.GetComparer<T>()(successor, expectation))
-            .FailWith("but found {0}.", successor => successor)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to have {0} succeed {1}{reason}, ", expectation, predecessor,
+                chain => chain
+                    .Given(() => Subject)
+                    .ForCondition(subject => subject is not null)
+                    .FailWith("but the collection is <null>.")
+                    .Then
+                    .ForCondition(subject => subject.Any())
+                    .FailWith("but the collection is empty.")
+                    .Then
+                    .ForCondition(subject => HasSuccessor(predecessor, subject))
+                    .FailWith("but found nothing.")
+                    .Then
+                    .Given(subject => SuccessorOf(predecessor, subject))
+                    .ForCondition(successor => ObjectExtensions.GetComparer<T>()(successor, expectation))
+                    .FailWith("but found {0}.", successor => successor));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1709,22 +1716,21 @@ public AndConstraint<TAssertions> HaveElementSucceeding(T predecessor, T expecta
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="otherCollection"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> HaveSameCount<TExpectation>(IEnumerable<TExpectation> otherCollection,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(otherCollection, nameof(otherCollection), "Cannot verify count against a <null> collection.");
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to have ")
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("the same count as {0}{reason}, but found <null>.", otherCollection)
-            .Then
-            .Given(subject => (actual: subject.Count(), expected: otherCollection.Count()))
-            .ForCondition(count => count.actual == count.expected)
-            .FailWith("{0} item(s){reason}, but found {1}.", count => count.expected, count => count.actual)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to have ", chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("the same count as {0}{reason}, but found <null>.", otherCollection)
+                .Then
+                .Given(subject => (actual: subject.Count(), expected: otherCollection.Count()))
+                .ForCondition(count => count.actual == count.expected)
+                .FailWith("{0} item(s){reason}, but found {1}.", count => count.expected, count => count.actual));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1742,21 +1748,22 @@ public AndConstraint<TAssertions> HaveSameCount<TExpectation>(IEnumerable<TExpec
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="otherCollection"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> IntersectWith(IEnumerable<T> otherCollection,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(otherCollection, nameof(otherCollection),
             "Cannot verify intersection against a <null> collection.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to intersect with {0}{reason}, but found <null>.", otherCollection);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<T> sharedItems = Subject!.Intersect(otherCollection);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(sharedItems.Any())
                 .FailWith(
@@ -1777,19 +1784,17 @@ public AndConstraint<TAssertions> IntersectWith(IEnumerable<T> otherCollection,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotBeEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeEmpty(string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} not to be empty{reason}")
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith(", but found <null>.")
-            .Then
-            .ForCondition(subject => subject.Any())
-            .FailWith(".")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} not to be empty{reason}", chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith(", but found <null>.")
+                .Then
+                .ForCondition(subject => subject.Any())
+                .FailWith("."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1808,20 +1813,21 @@ public AndConstraint<TAssertions> NotBeEmpty([StringSyntax("CompositeFormat")] s
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="unexpected"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(IEnumerable<TExpectation> unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected), "Cannot verify inequivalence against a <null> collection.");
 
         if (Subject is null)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} not to be equivalent{reason}, but found <null>.");
         }
 
         if (ReferenceEquals(Subject, unexpected))
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
                     "Expected {context:collection} {0} not to be equivalent with collection {1}{reason}, but they both reference the same object.",
@@ -1852,13 +1858,13 @@ public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(IEnumerable<TE
     /// </param>
     public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(IEnumerable<TExpectation> unexpected,
         Func<EquivalencyOptions<TExpectation>, EquivalencyOptions<TExpectation>> config,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected), "Cannot verify inequivalence against a <null> collection.");
 
         if (Subject is null)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} not to be equivalent{reason}, but found <null>.");
         }
@@ -1872,7 +1878,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(IEnumerable<TE
             failures = scope.Discard();
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(failures.Length > 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:collection} {0} not to be equivalent to collection {1}{reason}.", Subject,
@@ -1899,8 +1905,8 @@ public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(IEnumerable<TE
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<TAssertions> NotBeInAscendingOrder<TSelector>(
-        Expression<Func<T, TSelector>> propertyExpression,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Expression<Func<T, TSelector>> propertyExpression, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBeInAscendingOrder(propertyExpression, GetComparer<TSelector>(), because, becauseArgs);
     }
@@ -1924,8 +1930,7 @@ public AndConstraint<TAssertions> NotBeInAscendingOrder<TSelector>(
     /// </remarks>
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotBeInAscendingOrder(
-        IComparer<T> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        IComparer<T> comparer, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -1956,7 +1961,8 @@ public AndConstraint<TAssertions> NotBeInAscendingOrder(
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotBeInAscendingOrder<TSelector>(
         Expression<Func<T, TSelector>> propertyExpression, IComparer<TSelector> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -1978,7 +1984,7 @@ public AndConstraint<TAssertions> NotBeInAscendingOrder<TSelector>(
     /// <remarks>
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
-    public AndConstraint<TAssertions> NotBeInAscendingOrder([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeInAscendingOrder(string because = "", params object[] becauseArgs)
     {
         return NotBeInAscendingOrder(GetComparer<T>(), because, becauseArgs);
     }
@@ -2000,7 +2006,8 @@ public AndConstraint<TAssertions> NotBeInAscendingOrder([StringSyntax("Composite
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<TAssertions> NotBeInAscendingOrder(Func<T, T, int> comparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBeInOrder(Comparer<T>.Create((x, y) => comparison(x, y)), SortOrder.Ascending, because, becauseArgs);
     }
@@ -2023,8 +2030,8 @@ public AndConstraint<TAssertions> NotBeInAscendingOrder(Func<T, T, int> comparis
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<TAssertions> NotBeInDescendingOrder<TSelector>(
-        Expression<Func<T, TSelector>> propertyExpression,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Expression<Func<T, TSelector>> propertyExpression, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBeInDescendingOrder(propertyExpression, GetComparer<TSelector>(), because, becauseArgs);
     }
@@ -2079,7 +2086,8 @@ public AndConstraint<TAssertions> NotBeInDescendingOrder(
     /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotBeInDescendingOrder<TSelector>(
         Expression<Func<T, TSelector>> propertyExpression, IComparer<TSelector> comparer,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(comparer, nameof(comparer),
             "Cannot assert collection ordering without specifying a comparer.");
@@ -2101,7 +2109,7 @@ public AndConstraint<TAssertions> NotBeInDescendingOrder<TSelector>(
     /// <remarks>
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
-    public AndConstraint<TAssertions> NotBeInDescendingOrder([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeInDescendingOrder(string because = "", params object[] becauseArgs)
     {
         return NotBeInDescendingOrder(GetComparer<T>(), because, becauseArgs);
     }
@@ -2123,7 +2131,8 @@ public AndConstraint<TAssertions> NotBeInDescendingOrder([StringSyntax("Composit
     /// Empty and single element collections are considered to be ordered both in ascending and descending order at the same time.
     /// </remarks>
     public AndConstraint<TAssertions> NotBeInDescendingOrder(Func<T, T, int> comparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBeInOrder(Comparer<T>.Create((x, y) => comparison(x, y)), SortOrder.Descending, because, becauseArgs);
     }
@@ -2138,7 +2147,7 @@ public AndConstraint<TAssertions> NotBeInDescendingOrder(Func<T, T, int> compari
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotBeNullOrEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeNullOrEmpty(string because = "", params object[] becauseArgs)
     {
         return NotBeNull(because, becauseArgs)
             .And.NotBeEmpty(because, becauseArgs);
@@ -2156,18 +2165,19 @@ public AndConstraint<TAssertions> NotBeNullOrEmpty([StringSyntax("CompositeForma
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     public AndConstraint<TAssertions> NotBeSubsetOf(IEnumerable<T> unexpectedSuperset,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Cannot assert a <null> collection against a subset.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             if (ReferenceEquals(Subject, unexpectedSuperset))
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith(
                         "Did not expect {context:collection} {0} to be a subset of {1}{reason}, but they both reference the same object.",
@@ -2179,7 +2189,7 @@ public AndConstraint<TAssertions> NotBeSubsetOf(IEnumerable<T> unexpectedSuperse
 
             if (actualItems.Intersect(unexpectedSuperset).Count() == actualItems.Count)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Did not expect {context:collection} {0} to be a subset of {1}{reason}.", actualItems,
                         unexpectedSuperset);
@@ -2200,23 +2210,23 @@ public AndConstraint<TAssertions> NotBeSubsetOf(IEnumerable<T> unexpectedSuperse
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndWhichConstraint<TAssertions, T> NotContain(T unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotContain(T unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to not contain {0}{reason}, but found <null>.", unexpected);
 
         IEnumerable<T> matched = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             ICollection<T> collection = Subject.ConvertOrCastToCollection();
 
             if (collection.Contains(unexpected))
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:collection} {0} to not contain {1}{reason}.", collection, unexpected);
             }
@@ -2224,7 +2234,7 @@ public AndWhichConstraint<TAssertions, T> NotContain(T unexpected,
             matched = collection.Where(item => !EqualityComparer<T>.Default.Equals(item, unexpected));
         }
 
-        return new AndWhichConstraint<TAssertions, T>((TAssertions)this, matched);
+        return new AndConstraint<TAssertions>((TAssertions)this);
     }
 
     /// <summary>
@@ -2240,21 +2250,22 @@ public AndWhichConstraint<TAssertions, T> NotContain(T unexpected,
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotContain(Expression<Func<T, bool>> predicate,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} not to contain {0}{reason}, but found <null>.", predicate.Body);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Func<T, bool> compiledPredicate = predicate.Compile();
             IEnumerable<T> unexpectedItems = Subject!.Where(item => compiledPredicate(item));
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!unexpectedItems.Any())
                 .FailWith("Expected {context:collection} {0} to not have any items matching {1}{reason}, but found {2}.",
@@ -2278,8 +2289,8 @@ public AndConstraint<TAssertions> NotContain(Expression<Func<T, bool>> predicate
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="unexpected"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="unexpected"/> is empty.</exception>
-    public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected), "Cannot verify non-containment against a <null> collection");
 
@@ -2288,12 +2299,12 @@ public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected,
         Guard.ThrowIfArgumentIsEmpty(unexpectedObjects, nameof(unexpected),
             "Cannot verify non-containment against an empty collection");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to not contain {0}{reason}, but found <null>.", unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<T> foundItems = unexpectedObjects.Intersect(Subject!);
 
@@ -2301,14 +2312,14 @@ public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected,
             {
                 if (unexpectedObjects.Count > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} {0} to not contain {1}{reason}, but found {2}.", Subject,
                             unexpected, foundItems);
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} {0} to not contain {1}{reason}.",
                             Subject, unexpectedObjects.First());
@@ -2342,7 +2353,8 @@ public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected,
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
     public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotContainEquivalentOf(unexpected, config => config, because, becauseArgs);
     }
@@ -2378,18 +2390,19 @@ public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectat
     /// <exception cref="ArgumentNullException"><paramref name="config"/> is <see langword="null"/>.</exception>
     [SuppressMessage("Design", "MA0051:Method is too long", Justification = "Needs refactoring")]
     public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected,
-        Func<EquivalencyOptions<TExpectation>, EquivalencyOptions<TExpectation>> config,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Func<EquivalencyOptions<TExpectation>,
+            EquivalencyOptions<TExpectation>> config, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(config);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} not to contain equivalent of {0}{reason}, but collection is <null>.",
                 unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             EquivalencyOptions<TExpectation> options = config(AssertionOptions.CloneDefaults<TExpectation>());
 
@@ -2402,7 +2415,7 @@ public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectat
                 foreach (T actualItem in Subject!)
                 {
                     var context =
-                        new EquivalencyValidationContext(Node.From<TExpectation>(() => AssertionScope.Current.CallerIdentity),
+                        new EquivalencyValidationContext(Node.From<TExpectation>(() => CurrentAssertionChain.CallerIdentifier),
                             options)
                         {
                             Reason = new Reason(because, becauseArgs),
@@ -2433,22 +2446,21 @@ public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectat
             {
                 using (new AssertionScope())
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
+                        .WithReportable("configuration", () => options.ToString())
                         .WithExpectation("Expected {context:collection} {0} not to contain equivalent of {1}{reason}, ", Subject,
-                            unexpected)
-                        .AddReportable("configuration", () => options.ToString());
-
-                    if (foundIndices.Count == 1)
-                    {
-                        Execute.Assertion
-                            .FailWith("but found one at index {0}.", foundIndices[0]);
-                    }
-                    else
-                    {
-                        Execute.Assertion
-                            .FailWith("but found several at indices {0}.", foundIndices);
-                    }
+                            unexpected, chain =>
+                            {
+                                if (foundIndices.Count == 1)
+                                {
+                                    chain.FailWith("but found one at index {0}.", foundIndices[0]);
+                                }
+                                else
+                                {
+                                    chain.FailWith("but found several at indices {0}.", foundIndices);
+                                }
+                            });
                 }
             }
         }
@@ -2485,14 +2497,15 @@ public AndConstraint<TAssertions> NotContainInOrder(params T[] unexpected)
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="unexpected"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotContainInOrder(IEnumerable<T> unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected),
             "Cannot verify absence of ordered containment against a <null> collection.");
 
         if (Subject is null)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Cannot verify absence of ordered containment in a <null> collection.");
 
@@ -2516,7 +2529,7 @@ public AndConstraint<TAssertions> NotContainInOrder(IEnumerable<T> unexpected,
                 }
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
                     "Expected {context:collection} {0} to not contain items {1} in order{reason}, " +
@@ -2556,14 +2569,15 @@ public AndConstraint<TAssertions> NotContainInConsecutiveOrder(params T[] unexpe
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="unexpected"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotContainInConsecutiveOrder(IEnumerable<T> unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected),
             "Cannot verify absence of ordered containment against a <null> collection.");
 
         if (Subject is null)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Cannot verify absence of ordered containment in a <null> collection.");
 
@@ -2593,7 +2607,7 @@ public AndConstraint<TAssertions> NotContainInConsecutiveOrder(IEnumerable<T> un
 
                     if (consecutiveItems == unexpectedItems.Count)
                     {
-                        Execute.Assertion
+                        assertionChain
                             .BecauseOf(because, becauseArgs)
                             .FailWith(
                                 "Expected {context:collection} {0} to not contain items {1} in consecutive order{reason}, " +
@@ -2622,17 +2636,18 @@ public AndConstraint<TAssertions> NotContainInConsecutiveOrder(IEnumerable<T> un
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotContainNulls<TKey>(Expression<Func<T, TKey>> predicate,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TKey : class
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} not to contain <null>s{reason}, but collection is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Func<T, TKey> compiledPredicate = predicate.Compile();
 
@@ -2640,7 +2655,7 @@ public AndConstraint<TAssertions> NotContainNulls<TKey>(Expression<Func<T, TKey>
                 .Where(e => compiledPredicate(e) is null)
                 .ToArray();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(values.Length == 0)
                 .FailWith("Expected {context:collection} not to contain <null>s on {0}{reason}, but found {1}.",
@@ -2660,14 +2675,14 @@ public AndConstraint<TAssertions> NotContainNulls<TKey>(Expression<Func<T, TKey>
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotContainNulls([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotContainNulls(string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} not to contain <null>s{reason}, but collection is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             int[] indices = Subject!
                 .Select((item, index) => (Item: item, Index: index))
@@ -2679,7 +2694,7 @@ public AndConstraint<TAssertions> NotContainNulls([StringSyntax("CompositeFormat
             {
                 if (indices.Length > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith(
                             "Expected {context:collection} not to contain <null>s{reason}, but found several at indices {0}.",
@@ -2687,7 +2702,7 @@ public AndConstraint<TAssertions> NotContainNulls([StringSyntax("CompositeFormat
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} not to contain <null>s{reason}, but found one at index {0}.",
                             indices[0]);
@@ -2711,26 +2726,25 @@ public AndConstraint<TAssertions> NotContainNulls([StringSyntax("CompositeFormat
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="unexpected"/> is <see langword="null"/>.</exception>
-    public AndConstraint<TAssertions> NotEqual(IEnumerable<T> unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotEqual(IEnumerable<T> unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected), "Cannot compare collection with <null>.");
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected collections not to be equal{reason}, ")
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .ForCondition(subject => !ReferenceEquals(subject, unexpected))
-            .FailWith("but they both reference the same object.")
-            .Then
-            .ClearExpectation()
+            .WithExpectation("Expected collections not to be equal{reason}, ", chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .ForCondition(subject => !ReferenceEquals(subject, unexpected))
+                .FailWith("but they both reference the same object."))
             .Then
-            .Given(subject => subject.ConvertOrCastToCollection())
+            .Given(() => Subject.ConvertOrCastToCollection())
             .ForCondition(actualItems => !actualItems.SequenceEqual(unexpected))
-            .FailWith("Did not expect collections {0} and {1} to be equal{reason}.", _ => unexpected, actualItems => actualItems);
+            .FailWith("Did not expect collections {0} and {1} to be equal{reason}.", _ => unexpected,
+                actualItems => actualItems);
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -2746,21 +2760,19 @@ public AndConstraint<TAssertions> NotEqual(IEnumerable<T> unexpected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveCount(int unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveCount(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to not contain {0} item(s){reason}, ", unexpected)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .Given(subject => subject.Count())
-            .ForCondition(actualCount => actualCount != unexpected)
-            .FailWith("but found {0}.", actualCount => actualCount)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to not contain {0} item(s){reason}, ", unexpected, chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .Given(subject => subject.Count())
+                .ForCondition(actualCount => actualCount != unexpected)
+                .FailWith("but found {0}.", actualCount => actualCount));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -2778,11 +2790,12 @@ public AndConstraint<TAssertions> NotHaveCount(int unexpected,
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="otherCollection"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotHaveSameCount<TExpectation>(IEnumerable<TExpectation> otherCollection,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(otherCollection, nameof(otherCollection), "Cannot verify count against a <null> collection.");
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject)
             .ForCondition(subject => subject is not null)
@@ -2817,12 +2830,13 @@ public AndConstraint<TAssertions> NotHaveSameCount<TExpectation>(IEnumerable<TEx
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="otherCollection"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> NotIntersectWith(IEnumerable<T> otherCollection,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(otherCollection, nameof(otherCollection),
             "Cannot verify intersection against a <null> collection.");
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject)
             .ForCondition(subject => subject is not null)
@@ -2857,25 +2871,23 @@ public AndConstraint<TAssertions> NotIntersectWith(IEnumerable<T> otherCollectio
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> OnlyContain(
-        Expression<Func<T, bool>> predicate,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Expression<Func<T, bool>> predicate, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
         Func<T, bool> compiledPredicate = predicate.Compile();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to contain only items matching {0}{reason}, ", predicate.Body)
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but the collection is <null>.")
-            .Then
-            .Given(subject => subject.ConvertOrCastToCollection().Where(item => !compiledPredicate(item)))
-            .ForCondition(mismatchingItems => !mismatchingItems.Any())
-            .FailWith("but {0} do(es) not match.", mismatchingItems => mismatchingItems)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to contain only items matching {0}{reason}, ", predicate.Body,
+                chain => chain
+                    .Given(() => Subject)
+                    .ForCondition(subject => subject is not null)
+                    .FailWith("but the collection is <null>.")
+                    .Then
+                    .Given(subject => subject.ConvertOrCastToCollection().Where(item => !compiledPredicate(item)))
+                    .ForCondition(mismatchingItems => !mismatchingItems.Any())
+                    .FailWith("but {0} do(es) not match.", mismatchingItems => mismatchingItems));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -2893,16 +2905,17 @@ public AndConstraint<TAssertions> OnlyContain(
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> OnlyHaveUniqueItems<TKey>(Expression<Func<T, TKey>> predicate,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to only have unique items{reason}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Func<T, TKey> compiledPredicate = predicate.Compile();
 
@@ -2915,7 +2928,7 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems<TKey>(Expression<Func<T, T
             {
                 if (groupWithMultipleItems.Length > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith(
                             "Expected {context:collection} to only have unique items on {0}{reason}, but items {1} are not unique.",
@@ -2924,7 +2937,7 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems<TKey>(Expression<Func<T, T
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith(
                             "Expected {context:collection} to only have unique items on {0}{reason}, but item {1} is not unique.",
@@ -2947,25 +2960,26 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems<TKey>(Expression<Func<T, T
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> OnlyHaveUniqueItems([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> OnlyHaveUniqueItems(string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to only have unique items{reason}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            IEnumerable<T> groupWithMultipleItems = Subject!
+            T[] groupWithMultipleItems = Subject!
                 .GroupBy(o => o)
                 .Where(g => g.Count() > 1)
-                .Select(g => g.Key);
+                .Select(g => g.Key)
+                .ToArray();
 
-            if (groupWithMultipleItems.Any())
+            if (groupWithMultipleItems.Length > 0)
             {
-                if (groupWithMultipleItems.Count() > 1)
+                if (groupWithMultipleItems.Length > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith(
                             "Expected {context:collection} to only have unique items{reason}, but items {0} are not unique.",
@@ -2973,10 +2987,10 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems([StringSyntax("CompositeFo
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} to only have unique items{reason}, but item {0} is not unique.",
-                            groupWithMultipleItems.First());
+                            groupWithMultipleItems[0]);
                 }
             }
         }
@@ -2999,21 +3013,20 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems([StringSyntax("CompositeFo
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <see langword="null"/>.</exception>
-    public AndConstraint<TAssertions> AllSatisfy(Action<T> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> AllSatisfy(Action<T> expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot verify against a <null> inspector");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to contain only items satisfying the inspector{reason}, ")
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but collection is <null>.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to contain only items satisfying the inspector{reason}, ",
+                chain => chain
+                    .Given(() => Subject)
+                    .ForCondition(subject => subject is not null)
+                    .FailWith("but collection is <null>."));
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             string[] failuresFromInspectors;
 
@@ -3028,12 +3041,11 @@ public AndConstraint<TAssertions> AllSatisfy(Action<T> expected,
                 string failureMessage = Environment.NewLine
                     + string.Join(Environment.NewLine, failuresFromInspectors.Select(x => x.IndentLines()));
 
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
-                    .WithExpectation("Expected {context:collection} to contain only items satisfying the inspector{reason}:")
-                    .FailWithPreFormatted(failureMessage)
-                    .Then
-                    .ClearExpectation();
+                    .WithExpectation("Expected {context:collection} to contain only items satisfying the inspector{reason}:",
+                        chain => chain
+                            .FailWithPreFormatted(failureMessage));
             }
 
             return new AndConstraint<TAssertions>((TAssertions)this);
@@ -3075,7 +3087,8 @@ public AndConstraint<TAssertions> SatisfyRespectively(params Action<T>[] element
     /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="expected"/> is empty.</exception>
     public AndConstraint<TAssertions> SatisfyRespectively(IEnumerable<Action<T>> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot verify against a <null> collection of inspectors");
 
@@ -3084,25 +3097,23 @@ public AndConstraint<TAssertions> SatisfyRespectively(IEnumerable<Action<T>> exp
         Guard.ThrowIfArgumentIsEmpty(elementInspectors, nameof(expected),
             "Cannot verify against an empty collection of inspectors");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to satisfy all inspectors{reason}, ")
-            .Given(() => Subject)
-            .ForCondition(subject => subject is not null)
-            .FailWith("but collection is <null>.")
-            .Then
-            .ForCondition(subject => subject.Any())
-            .FailWith("but collection is empty.")
-            .Then
-            .ClearExpectation()
+            .WithExpectation("Expected {context:collection} to satisfy all inspectors{reason}, ", chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject is not null)
+                .FailWith("but collection is <null>.")
+                .Then
+                .ForCondition(subject => subject.Any())
+                .FailWith("but collection is empty."))
             .Then
-            .Given(subject => (elements: subject.Count(), inspectors: elementInspectors.Count))
+            .Given(() => (elements: Subject.Count(), inspectors: elementInspectors.Count))
             .ForCondition(count => count.elements == count.inspectors)
             .FailWith(
                 "Expected {context:collection} to contain exactly {0} items{reason}, but it contains {1} items",
                 count => count.inspectors, count => count.elements);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             string[] failuresFromInspectors;
 
@@ -3116,13 +3127,12 @@ public AndConstraint<TAssertions> SatisfyRespectively(IEnumerable<Action<T>> exp
                 string failureMessage = Environment.NewLine
                     + string.Join(Environment.NewLine, failuresFromInspectors.Select(x => x.IndentLines()));
 
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .WithExpectation(
-                        "Expected {context:collection} to satisfy all inspectors{reason}, but some inspectors are not satisfied:")
-                    .FailWithPreFormatted(failureMessage)
-                    .Then
-                    .ClearExpectation();
+                        "Expected {context:collection} to satisfy all inspectors{reason}, but some inspectors are not satisfied:",
+                        chain => chain
+                            .FailWithPreFormatted(failureMessage));
             }
         }
 
@@ -3165,7 +3175,8 @@ public AndConstraint<TAssertions> Satisfy(params Expression<Func<T, bool>>[] pre
     /// <exception cref="ArgumentNullException"><paramref name="predicates"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="predicates"/> is empty.</exception>
     public AndConstraint<TAssertions> Satisfy(IEnumerable<Expression<Func<T, bool>>> predicates,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(predicates, nameof(predicates), "Cannot verify against a <null> collection of predicates");
 
@@ -3174,7 +3185,7 @@ public AndConstraint<TAssertions> Satisfy(IEnumerable<Expression<Func<T, bool>>>
         Guard.ThrowIfArgumentIsEmpty(predicatesList, nameof(predicates),
             "Cannot verify against an empty collection of predicates");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .Given(() => Subject)
             .ForCondition(subject => subject is not null)
@@ -3183,7 +3194,7 @@ public AndConstraint<TAssertions> Satisfy(IEnumerable<Expression<Func<T, bool>>>
             .ForCondition(subject => subject.Any())
             .FailWith("Expected {context:collection} to satisfy all predicates{reason}, but collection is empty.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             MaximumMatchingSolution<T> maximumMatchingSolution = new MaximumMatchingProblem<T>(predicatesList, Subject).Solve();
 
@@ -3215,10 +3226,10 @@ public AndConstraint<TAssertions> Satisfy(IEnumerable<Expression<Func<T, bool>>>
                     message += doubleNewLine + string.Join(doubleNewLine, elementDescriptions);
                 }
 
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
-                    .WithExpectation("Expected {context:collection} to satisfy all predicates{reason}, but:")
-                    .FailWithPreFormatted(message);
+                    .WithExpectation("Expected {context:collection} to satisfy all predicates{reason}, but:", chain => chain
+                        .FailWithPreFormatted(message));
             }
         }
 
@@ -3240,8 +3251,8 @@ public AndConstraint<TAssertions> Satisfy(IEnumerable<Expression<Func<T, bool>>>
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expectation"/> is <see langword="null"/>.</exception>
-    public AndConstraint<TAssertions> StartWith(IEnumerable<T> expectation,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> StartWith(IEnumerable<T> expectation, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return StartWith(expectation, (a, b) => EqualityComparer<T>.Default.Equals(a, b), because, becauseArgs);
     }
@@ -3266,7 +3277,8 @@ public AndConstraint<TAssertions> StartWith(IEnumerable<T> expectation,
     /// <exception cref="ArgumentNullException"><paramref name="expectation"/> is <see langword="null"/>.</exception>
     public AndConstraint<TAssertions> StartWith<TExpectation>(
         IEnumerable<TExpectation> expectation, Func<T, TExpectation, bool> equalityComparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expectation, nameof(expectation), "Cannot compare collection with <null>.");
 
@@ -3288,8 +3300,8 @@ public AndConstraint<TAssertions> StartWith<TExpectation>(
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> StartWith(T element,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> StartWith(T element, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return StartWith([element], ObjectExtensions.GetComparer<T>(), because, becauseArgs);
     }
@@ -3298,7 +3310,7 @@ internal AndConstraint<SubsequentOrderingAssertions<T>> BeOrderedBy<TSelector>(
         Expression<Func<T, TSelector>> propertyExpression,
         IComparer<TSelector> comparer,
         SortOrder direction,
-        [StringSyntax("CompositeFormat")] string because,
+        string because,
         object[] becauseArgs)
     {
         if (IsValidProperty(propertyExpression, because, becauseArgs))
@@ -3311,18 +3323,18 @@ internal AndConstraint<SubsequentOrderingAssertions<T>> BeOrderedBy<TSelector>(
                 direction,
                 unordered);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(unordered.SequenceEqual(expectation))
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} {0} to be ordered {1}{reason} and result in {2}.",
                     () => Subject, () => GetExpressionOrderString(propertyExpression), () => expectation);
 
             return new AndConstraint<SubsequentOrderingAssertions<T>>(
-                new SubsequentOrderingAssertions<T>(Subject, expectation));
+                new SubsequentOrderingAssertions<T>(Subject, expectation, assertionChain));
         }
 
         return new AndConstraint<SubsequentOrderingAssertions<T>>(
-            new SubsequentOrderingAssertions<T>(Subject, Enumerable.Empty<T>().OrderBy(x => x)));
+            new SubsequentOrderingAssertions<T>(Subject, Enumerable.Empty<T>().OrderBy(x => x), assertionChain));
     }
 
     internal virtual IOrderedEnumerable<T> GetOrderedEnumerable<TSelector>(
@@ -3352,50 +3364,49 @@ protected static IEnumerable<TExpectation> RepeatAsManyAs<TExpectation>(TExpecta
 
     protected void AssertCollectionEndsWith<TActual, TExpectation>(IEnumerable<TActual> actual,
         ICollection<TExpectation> expected, Func<TActual, TExpectation, bool> equalityComparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(equalityComparison);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to end with {0}{reason}, ", expected)
-            .Given(() => actual)
-            .AssertCollectionIsNotNull()
-            .Then
-            .AssertCollectionHasEnoughItems(expected.Count)
-            .Then
-            .AssertCollectionsHaveSameItems(expected, (a, e) =>
-            {
-                int firstIndexToCompare = a.Count - e.Count;
-                int index = a.Skip(firstIndexToCompare).IndexOfFirstDifferenceWith(e, equalityComparison);
-                return index >= 0 ? index + firstIndexToCompare : index;
-            })
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to end with {0}{reason}, ", expected, chain => chain
+                .Given(() => actual)
+                .AssertCollectionIsNotNull()
+                .Then
+                .AssertCollectionHasEnoughItems(expected.Count)
+                .Then
+                .AssertCollectionsHaveSameItems(expected, (a, e) =>
+                {
+                    int firstIndexToCompare = a.Count - e.Count;
+                    int index = a.Skip(firstIndexToCompare).IndexOfFirstDifferenceWith(e, equalityComparison);
+                    return index >= 0 ? index + firstIndexToCompare : index;
+                }));
     }
 
     protected void AssertCollectionStartsWith<TActual, TExpectation>(IEnumerable<TActual> actualItems,
         ICollection<TExpectation> expected, Func<TActual, TExpectation, bool> equalityComparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(equalityComparison);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:collection} to start with {0}{reason}, ", expected)
-            .Given(() => actualItems)
-            .AssertCollectionIsNotNull()
-            .Then
-            .AssertCollectionHasEnoughItems(expected.Count)
-            .Then
-            .AssertCollectionsHaveSameItems(expected, (a, e) => a.Take(e.Count).IndexOfFirstDifferenceWith(e, equalityComparison))
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to start with {0}{reason}, ", expected, chain => chain
+                .Given(() => actualItems)
+                .AssertCollectionIsNotNull()
+                .Then
+                .AssertCollectionHasEnoughItems(expected.Count)
+                .Then
+                .AssertCollectionsHaveSameItems(expected,
+                    (a, e) => a.Take(e.Count).IndexOfFirstDifferenceWith(e, equalityComparison)));
     }
 
     protected void AssertSubjectEquality<TExpectation>(IEnumerable<TExpectation> expectation,
-        Func<T, TExpectation, bool> equalityComparison,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        Func<T, TExpectation, bool> equalityComparison, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(equalityComparison);
 
@@ -3411,21 +3422,16 @@ protected void AssertSubjectEquality<TExpectation>(IEnumerable<TExpectation> exp
 
         ICollection<TExpectation> expectedItems = expectation.ConvertOrCastToCollection();
 
-        AssertionScope assertion = Execute.Assertion.BecauseOf(because, becauseArgs);
-
-        if (subjectIsNull)
-        {
-            assertion.FailWith("Expected {context:collection} to be equal to {0}{reason}, but found <null>.", expectedItems);
-        }
-
-        assertion
-            .WithExpectation("Expected {context:collection} to be equal to {0}{reason}, ", expectedItems)
-            .Given(() => Subject.ConvertOrCastToCollection())
-            .AssertCollectionsHaveSameCount(expectedItems.Count)
-            .Then
-            .AssertCollectionsHaveSameItems(expectedItems, (a, e) => a.IndexOfFirstDifferenceWith(e, equalityComparison))
+        assertionChain
+            .BecauseOf(because, becauseArgs)
+            .ForCondition(!subjectIsNull)
+            .FailWith("Expected {context:collection} to be equal to {0}{reason}, but found <null>.", expectedItems)
             .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:collection} to be equal to {0}{reason}, ", expectedItems, chain => chain
+                .Given(() => Subject.ConvertOrCastToCollection())
+                .AssertCollectionsHaveSameCount(expectedItems.Count)
+                .Then
+                .AssertCollectionsHaveSameItems(expectedItems, (a, e) => a.IndexOfFirstDifferenceWith(e, equalityComparison)));
     }
 
     private static string GetExpressionOrderString<TSelector>(Expression<Func<T, TSelector>> propertyExpression)
@@ -3512,25 +3518,28 @@ private string[] CollectFailuresFromInspectors(IEnumerable<Action<T>> elementIns
     }
 
     private bool IsValidProperty<TSelector>(Expression<Func<T, TSelector>> propertyExpression,
-        [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because,
+        object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(propertyExpression, nameof(propertyExpression),
             "Cannot assert collection ordering without specifying a property.");
 
         propertyExpression.ValidateMemberPath();
 
-        return Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to be ordered by {0}{reason} but found <null>.",
                 () => propertyExpression.GetMemberPath());
+
+        return assertionChain.Succeeded;
     }
 
     private AndConstraint<TAssertions> NotBeOrderedBy<TSelector>(
         Expression<Func<T, TSelector>> propertyExpression,
         IComparer<TSelector> comparer,
         SortOrder direction,
-        [StringSyntax("CompositeFormat")] string because,
+        string because,
         object[] becauseArgs)
     {
         if (IsValidProperty(propertyExpression, because, becauseArgs))
@@ -3543,7 +3552,7 @@ private AndConstraint<TAssertions> NotBeOrderedBy<TSelector>(
                 direction,
                 unordered);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!unordered.SequenceEqual(expectation))
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} {0} to not be ordered {1}{reason} and not result in {2}.",
@@ -3558,19 +3567,19 @@ private AndConstraint<TAssertions> NotBeOrderedBy<TSelector>(
     /// Elements are compared using their <see cref="object.Equals(object)" /> implementation.
     /// </summary>
     private AndConstraint<SubsequentOrderingAssertions<T>> BeInOrder(
-        IComparer<T> comparer, SortOrder expectedOrder,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        IComparer<T> comparer, SortOrder expectedOrder, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         string sortOrder = expectedOrder == SortOrder.Ascending ? "ascending" : "descending";
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith($"Expected {{context:collection}} to be in {sortOrder} order{{reason}}, but found <null>.");
 
         IOrderedEnumerable<T> ordering = Array.Empty<T>().OrderBy(x => x);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IList<T> actualItems = Subject.ConvertOrCastToList();
 
@@ -3585,19 +3594,20 @@ private AndConstraint<SubsequentOrderingAssertions<T>> BeInOrder(
             {
                 if (!areSameOrEqual(actualItems[index], orderedItems[index]))
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:collection} to be in " + sortOrder +
                             " order{reason}, but found {0} where item at index {1} is in wrong order.",
                             actualItems, index);
 
                     return new AndConstraint<SubsequentOrderingAssertions<T>>(
-                        new SubsequentOrderingAssertions<T>(Subject, Enumerable.Empty<T>().OrderBy(x => x)));
+                        new SubsequentOrderingAssertions<T>(Subject, Enumerable.Empty<T>().OrderBy(x => x), assertionChain));
                 }
             }
         }
 
-        return new AndConstraint<SubsequentOrderingAssertions<T>>(new SubsequentOrderingAssertions<T>(Subject, ordering));
+        return new AndConstraint<SubsequentOrderingAssertions<T>>(
+            new SubsequentOrderingAssertions<T>(Subject, ordering, assertionChain));
     }
 
     /// <summary>
@@ -3605,16 +3615,17 @@ private AndConstraint<SubsequentOrderingAssertions<T>> BeInOrder(
     /// using their <see cref="object.Equals(object)" /> implementation.
     /// </summary>
     private AndConstraint<TAssertions> NotBeInOrder(IComparer<T> comparer, SortOrder order,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         string sortOrder = order == SortOrder.Ascending ? "ascending" : "descending";
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith($"Did not expect {{context:collection}} to be in {sortOrder} order{{reason}}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IList<T> actualItems = Subject.ConvertOrCastToList();
 
@@ -3628,7 +3639,7 @@ private AndConstraint<TAssertions> NotBeInOrder(IComparer<T> comparer, SortOrder
                 .Where((actualItem, index) => !areSameOrEqual(actualItem, orderedItems[index]))
                 .Any();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(itemsAreUnordered)
                 .FailWith(
diff --git a/Src/FluentAssertions/Collections/GenericDictionaryAssertions.cs b/Src/FluentAssertions/Collections/GenericDictionaryAssertions.cs
index 765a90f2ad..381e082a1b 100644
--- a/Src/FluentAssertions/Collections/GenericDictionaryAssertions.cs
+++ b/Src/FluentAssertions/Collections/GenericDictionaryAssertions.cs
@@ -17,8 +17,8 @@ public class GenericDictionaryAssertions<TCollection, TKey, TValue>
     : GenericDictionaryAssertions<TCollection, TKey, TValue, GenericDictionaryAssertions<TCollection, TKey, TValue>>
     where TCollection : IEnumerable<KeyValuePair<TKey, TValue>>
 {
-    public GenericDictionaryAssertions(TCollection keyValuePairs)
-        : base(keyValuePairs)
+    public GenericDictionaryAssertions(TCollection keyValuePairs, AssertionChain assertionChain)
+        : base(keyValuePairs, assertionChain)
     {
     }
 }
@@ -26,15 +26,17 @@ public GenericDictionaryAssertions(TCollection keyValuePairs)
 /// <summary>
 /// Contains a number of methods to assert that a <typeparamref name="TCollection"/> is in the expected state.
 /// </summary>
-[DebuggerNonUserCode]
 public class GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions>
     : GenericCollectionAssertions<TCollection, KeyValuePair<TKey, TValue>, TAssertions>
     where TCollection : IEnumerable<KeyValuePair<TKey, TValue>>
     where TAssertions : GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions>
 {
-    public GenericDictionaryAssertions(TCollection keyValuePairs)
-        : base(keyValuePairs)
+    private readonly AssertionChain assertionChain;
+
+    public GenericDictionaryAssertions(TCollection keyValuePairs, AssertionChain assertionChain)
+        : base(keyValuePairs, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     #region Equal
@@ -59,12 +61,12 @@ public AndConstraint<TAssertions> Equal<T>(T expected,
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare dictionary with <null>.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to be equal to {0}{reason}, but found {1}.", expected, Subject);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<TKey> subjectKeys = GetKeys(Subject);
             IEnumerable<TKey> expectedKeys = GetKeys(expected);
@@ -73,7 +75,7 @@ public AndConstraint<TAssertions> Equal<T>(T expected,
 
             if (missingKeys.Any())
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:dictionary} to be equal to {0}{reason}, but could not find keys {1}.", expected,
                         missingKeys);
@@ -81,9 +83,10 @@ public AndConstraint<TAssertions> Equal<T>(T expected,
 
             if (additionalKeys.Any())
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
-                    .FailWith("Expected {context:dictionary} to be equal to {0}{reason}, but found additional keys {1}.", expected,
+                    .FailWith("Expected {context:dictionary} to be equal to {0}{reason}, but found additional keys {1}.",
+                        expected,
                         additionalKeys);
             }
 
@@ -91,7 +94,7 @@ public AndConstraint<TAssertions> Equal<T>(T expected,
 
             foreach (var key in expectedKeys)
             {
-                Execute.Assertion
+                assertionChain
                     .ForCondition(areSameOrEqual(GetValue(Subject, key), GetValue(expected, key)))
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:dictionary} to be equal to {0}{reason}, but {1} differs at key {2}.",
@@ -122,16 +125,16 @@ public AndConstraint<TAssertions> NotEqual<T>(T unexpected,
     {
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected), "Cannot compare dictionary with <null>.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected dictionaries not to be equal{reason}, but found {0}.", Subject);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             if (ReferenceEquals(Subject, unexpected))
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected dictionaries not to be equal{reason}, but they both reference the same object.");
             }
@@ -149,7 +152,7 @@ public AndConstraint<TAssertions> NotEqual<T>(T unexpected,
 
             if (!foundDifference)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Did not expect dictionaries {0} and {1} to be equal{reason}.", unexpected, Subject);
             }
@@ -220,7 +223,7 @@ public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expe
         EquivalencyOptions<TExpectation> options = config(AssertionOptions.CloneDefaults<TExpectation>());
 
         var context =
-            new EquivalencyValidationContext(Node.From<TExpectation>(() => AssertionScope.Current.CallerIdentity), options)
+            new EquivalencyValidationContext(Node.From<TExpectation>(() => CurrentAssertionChain.CallerIdentifier), options)
             {
                 Reason = new Reason(because, becauseArgs),
                 TraceWriter = options.TraceWriter
@@ -295,12 +298,12 @@ public AndConstraint<TAssertions> ContainKeys(IEnumerable<TKey> expected,
         ICollection<TKey> expectedKeys = expected.ConvertOrCastToCollection();
         Guard.ThrowIfArgumentIsEmpty(expectedKeys, nameof(expected), "Cannot verify key containment against an empty sequence");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to contain keys {0}{reason}, but found <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<TKey> missingKeys = expectedKeys.Where(key => !ContainsKey(Subject, key));
 
@@ -308,14 +311,15 @@ public AndConstraint<TAssertions> ContainKeys(IEnumerable<TKey> expected,
             {
                 if (expectedKeys.Count > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
-                        .FailWith("Expected {context:dictionary} {0} to contain keys {1}{reason}, but could not find {2}.", Subject,
+                        .FailWith("Expected {context:dictionary} {0} to contain keys {1}{reason}, but could not find {2}.",
+                            Subject,
                             expected, missingKeys);
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} {0} to contain key {1}{reason}.", Subject,
                             expected.First());
@@ -345,14 +349,14 @@ public AndConstraint<TAssertions> ContainKeys(IEnumerable<TKey> expected,
     public AndConstraint<TAssertions> NotContainKey(TKey unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} not to contain key {0}{reason}, but found <null>.", unexpected);
 
-        if (success && ContainsKey(Subject, unexpected))
+        if (assertionChain.Succeeded && ContainsKey(Subject, unexpected))
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:dictionary} {0} not to contain key {1}{reason}, but found it anyhow.", Subject,
                     unexpected);
@@ -396,12 +400,12 @@ public AndConstraint<TAssertions> NotContainKeys(IEnumerable<TKey> unexpected,
         Guard.ThrowIfArgumentIsEmpty(unexpectedKeys, nameof(unexpected),
             "Cannot verify key containment against an empty sequence");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to not contain keys {0}{reason}, but found <null>.", unexpectedKeys);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<TKey> foundKeys = unexpectedKeys.Where(key => ContainsKey(Subject, key));
 
@@ -409,14 +413,14 @@ public AndConstraint<TAssertions> NotContainKeys(IEnumerable<TKey> unexpected,
             {
                 if (unexpectedKeys.Count > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} {0} to not contain keys {1}{reason}, but found {2}.", Subject,
                             unexpectedKeys, foundKeys);
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} {0} to not contain key {1}{reason}.", Subject,
                             unexpectedKeys.First());
@@ -446,12 +450,10 @@ public AndConstraint<TAssertions> NotContainKeys(IEnumerable<TKey> unexpected,
     public AndWhichConstraint<TAssertions, TValue> ContainValue(TValue expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        AndWhichConstraint<TAssertions, IEnumerable<TValue>> innerConstraint =
-            ContainValuesAndWhich([expected], because, becauseArgs);
+        AndWhichConstraint<TAssertions, IEnumerable<TValue>> result =
+            ContainValues([expected], because, becauseArgs);
 
-        return
-            new AndWhichConstraint<TAssertions, TValue>(
-                innerConstraint.And, innerConstraint.Which);
+        return new AndWhichConstraint<TAssertions, TValue>(result.And, result.Subject);
     }
 
     /// <summary>
@@ -459,13 +461,13 @@ public AndWhichConstraint<TAssertions, TValue> ContainValue(TValue expected,
     /// their <see cref="object.Equals(object)" /> implementation.
     /// </summary>
     /// <param name="expected">The expected values</param>
-    public AndConstraint<TAssertions> ContainValues(params TValue[] expected)
+    public AndWhichConstraint<TAssertions, IEnumerable<TValue>> ContainValues(params TValue[] expected)
     {
         return ContainValues(expected, string.Empty);
     }
 
     /// <summary>
-    /// Asserts that the dictionary contains all of the specified values. Values are compared using
+    /// Asserts that the dictionary contains all the specified values. Values are compared using
     /// their <see cref="object.Equals(object)" /> implementation.
     /// </summary>
     /// <param name="expected">The expected values</param>
@@ -478,68 +480,57 @@ public AndConstraint<TAssertions> ContainValues(params TValue[] expected)
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="expected"/> is empty.</exception>
-    public AndConstraint<TAssertions> ContainValues(IEnumerable<TValue> expected,
+    public AndWhichConstraint<TAssertions, IEnumerable<TValue>> ContainValues(IEnumerable<TValue> expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected),
             "Cannot verify value containment against a <null> collection of values");
 
-        return ContainValuesAndWhich(expected, because, becauseArgs);
-    }
-
-    private AndWhichConstraint<TAssertions, IEnumerable<TValue>> ContainValuesAndWhich(IEnumerable<TValue> expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
-    {
         ICollection<TValue> expectedValues = expected.ConvertOrCastToCollection();
 
         Guard.ThrowIfArgumentIsEmpty(expectedValues, nameof(expected),
             "Cannot verify value containment against an empty sequence");
 
-        bool success = Execute.Assertion
+        var missingValues = new List<TValue>(expectedValues);
+
+        Dictionary<TKey, TValue> matches = new();
+
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
-            .FailWith("Expected {context:dictionary} to contain values {0}{reason}, but found {1}.", expected, Subject);
-
-        IEnumerable<TValue> matchedConstraint = null;
+            .FailWith("Expected {context:dictionary} to contain values {0}{reason}, but found <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            IEnumerable<TValue> subjectValues = GetValues(Subject);
-            IEnumerable<TValue> missingValues = expectedValues.Except(subjectValues);
+            foreach (var pair in Subject!)
+            {
+                if (missingValues.Contains(pair.Value))
+                {
+                    matches.Add(pair.Key, pair.Value);
+                    missingValues.Remove(pair.Value);
+                }
+            }
 
-            if (missingValues.Any())
+            if (missingValues.Count > 0)
             {
-                if (expectedValues.Count > 1)
+                if (expectedValues.Count == 1)
                 {
-                    Execute.Assertion
-                        .BecauseOf(because, becauseArgs)
-                        .FailWith("Expected {context:dictionary} {0} to contain value {1}{reason}, but could not find {2}.", Subject,
-                            expected, missingValues);
+                    assertionChain.FailWith(
+                        "Expected {context:dictionary} {0} to contain value {1}{reason}.",
+                        Subject, expectedValues.Single());
                 }
                 else
                 {
-                    Execute.Assertion
-                        .BecauseOf(because, becauseArgs)
-                        .FailWith("Expected {context:dictionary} {0} to contain value {1}{reason}.", Subject,
-                            expected.First());
+                    assertionChain.FailWith(
+                        "Expected {context:dictionary} {0} to contain values {1}{reason}, but could not find {2}.",
+                        Subject, expectedValues, missingValues.Count == 1 ? missingValues.Single() : missingValues);
                 }
             }
-
-            matchedConstraint = RepetitionPreservingIntersect(subjectValues, expectedValues);
         }
 
-        return new AndWhichConstraint<TAssertions, IEnumerable<TValue>>((TAssertions)this, matchedConstraint);
-    }
+        string postfix = matches.Count > 0 ? "[" + string.Join(" and ", matches.Keys) + "]" : "";
 
-    /// <summary>
-    /// Returns an enumerable consisting of all items in the first collection also appearing in the second.
-    /// </summary>
-    /// <remarks>Enumerable.Intersect is not suitable because it drops any repeated elements.</remarks>
-    private static IEnumerable<TValue> RepetitionPreservingIntersect(
-        IEnumerable<TValue> first, IEnumerable<TValue> second)
-    {
-        var secondSet = new HashSet<TValue>(second);
-        return first.Where(e => secondSet.Contains(e));
+        return new AndWhichConstraint<TAssertions, IEnumerable<TValue>>((TAssertions)this, matches.Values, assertionChain, postfix);
     }
 
     #endregion
@@ -561,14 +552,14 @@ private static IEnumerable<TValue> RepetitionPreservingIntersect(
     public AndConstraint<TAssertions> NotContainValue(TValue unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} not to contain value {0}{reason}, but found <null>.", unexpected);
 
-        if (success && GetValues(Subject).Contains(unexpected))
+        if (assertionChain.Succeeded && GetValues(Subject).Contains(unexpected))
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:dictionary} {0} not to contain value {1}{reason}, but found it anyhow.", Subject,
                     unexpected);
@@ -612,12 +603,12 @@ public AndConstraint<TAssertions> NotContainValues(IEnumerable<TValue> unexpecte
         Guard.ThrowIfArgumentIsEmpty(unexpectedValues, nameof(unexpected),
             "Cannot verify value containment with an empty sequence");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to not contain values {0}{reason}, but found <null>.", unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<TValue> foundValues = unexpectedValues.Intersect(GetValues(Subject));
 
@@ -625,14 +616,15 @@ public AndConstraint<TAssertions> NotContainValues(IEnumerable<TValue> unexpecte
             {
                 if (unexpectedValues.Count > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
-                        .FailWith("Expected {context:dictionary} {0} to not contain value {1}{reason}, but found {2}.", Subject,
+                        .FailWith("Expected {context:dictionary} {0} to not contain value {1}{reason}, but found {2}.",
+                            Subject,
                             unexpected, foundValues);
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} {0} to not contain value {1}{reason}.", Subject,
                             unexpected.First());
@@ -684,13 +676,13 @@ public AndConstraint<TAssertions> Contain(params KeyValuePair<TKey, TValue>[] ex
         Guard.ThrowIfArgumentIsEmpty(expectedKeyValuePairs, nameof(expected),
             "Cannot verify key containment against an empty collection of key/value pairs");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to contain key/value pairs {0}{reason}, but dictionary is <null>.",
                 expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             TKey[] expectedKeys = expectedKeyValuePairs.Select(keyValuePair => keyValuePair.Key).ToArray();
             IEnumerable<TKey> missingKeys = expectedKeys.Where(key => !ContainsKey(Subject, key));
@@ -699,7 +691,7 @@ public AndConstraint<TAssertions> Contain(params KeyValuePair<TKey, TValue>[] ex
             {
                 if (expectedKeyValuePairs.Count > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} {0} to contain key(s) {1}{reason}, but could not find keys {2}.",
                             Subject,
@@ -707,7 +699,7 @@ public AndConstraint<TAssertions> Contain(params KeyValuePair<TKey, TValue>[] ex
                 }
                 else
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} {0} to contain key {1}{reason}.", Subject,
                             expectedKeys[0]);
@@ -723,7 +715,7 @@ public AndConstraint<TAssertions> Contain(params KeyValuePair<TKey, TValue>[] ex
             {
                 if (keyValuePairsNotSameOrEqualInSubject.Length > 1)
                 {
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith(
                             "Expected {context:dictionary} to contain {0}{reason}, but {context:dictionary} differs at keys {1}.",
@@ -734,7 +726,7 @@ public AndConstraint<TAssertions> Contain(params KeyValuePair<TKey, TValue>[] ex
                     KeyValuePair<TKey, TValue> expectedKeyValuePair = keyValuePairsNotSameOrEqualInSubject[0];
                     TValue actual = GetValue(Subject, expectedKeyValuePair.Key);
 
-                    Execute.Assertion
+                    assertionChain
                         .BecauseOf(because, becauseArgs)
                         .FailWith("Expected {context:dictionary} to contain value {0} at key {1}{reason}, but found {2}.",
                             expectedKeyValuePair.Value, expectedKeyValuePair.Key, actual);
@@ -782,19 +774,19 @@ public AndConstraint<TAssertions> Contain(params KeyValuePair<TKey, TValue>[] ex
     public AndConstraint<TAssertions> Contain(TKey key, TValue value,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to contain value {0} at key {1}{reason}, but dictionary is <null>.",
                 value, key);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             if (TryGetValue(Subject, key, out TValue actual))
             {
                 Func<TValue, TValue, bool> areSameOrEqual = ObjectExtensions.GetComparer<TValue>();
 
-                Execute.Assertion
+                assertionChain
                     .ForCondition(areSameOrEqual(actual, value))
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:dictionary} to contain value {0} at key {1}{reason}, but found {2}.", value, key,
@@ -802,7 +794,7 @@ public AndConstraint<TAssertions> Contain(TKey key, TValue value,
             }
             else
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:dictionary} to contain value {0} at key {1}{reason}, but the key was not found.",
                         value,
@@ -853,13 +845,13 @@ public AndConstraint<TAssertions> NotContain(params KeyValuePair<TKey, TValue>[]
         Guard.ThrowIfArgumentIsEmpty(keyValuePairs, nameof(items),
             "Cannot verify key containment against an empty collection of key/value pairs");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} to not contain key/value pairs {0}{reason}, but dictionary is <null>.",
                 items);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             KeyValuePair<TKey, TValue>[] keyValuePairsFound =
                 keyValuePairs.Where(keyValuePair => ContainsKey(Subject, keyValuePair.Key)).ToArray();
@@ -875,7 +867,7 @@ public AndConstraint<TAssertions> NotContain(params KeyValuePair<TKey, TValue>[]
                 {
                     if (keyValuePairsSameOrEqualInSubject.Length > 1)
                     {
-                        Execute.Assertion
+                        assertionChain
                             .BecauseOf(because, becauseArgs)
                             .FailWith(
                                 "Expected {context:dictionary} to not contain key/value pairs {0}{reason}, but found them anyhow.",
@@ -885,7 +877,7 @@ public AndConstraint<TAssertions> NotContain(params KeyValuePair<TKey, TValue>[]
                     {
                         KeyValuePair<TKey, TValue> keyValuePair = keyValuePairsSameOrEqualInSubject[0];
 
-                        Execute.Assertion
+                        assertionChain
                             .BecauseOf(because, becauseArgs)
                             .FailWith(
                                 "Expected {context:dictionary} to not contain value {0} at key {1}{reason}, but found it anyhow.",
@@ -935,15 +927,15 @@ public AndConstraint<TAssertions> NotContain(params KeyValuePair<TKey, TValue>[]
     public AndConstraint<TAssertions> NotContain(TKey key, TValue value,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:dictionary} not to contain value {0} at key {1}{reason}, but dictionary is <null>.",
                 value, key);
 
-        if (success && TryGetValue(Subject, key, out TValue actual))
+        if (assertionChain.Succeeded && TryGetValue(Subject, key, out TValue actual))
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!ObjectExtensions.GetComparer<TValue>()(actual, value))
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:dictionary} not to contain value {0} at key {1}{reason}, but found it anyhow.",
diff --git a/Src/FluentAssertions/Collections/StringCollectionAssertions.cs b/Src/FluentAssertions/Collections/StringCollectionAssertions.cs
index 82e4498f3c..9229b4f846 100644
--- a/Src/FluentAssertions/Collections/StringCollectionAssertions.cs
+++ b/Src/FluentAssertions/Collections/StringCollectionAssertions.cs
@@ -13,8 +13,8 @@ public class StringCollectionAssertions : StringCollectionAssertions<IEnumerable
     /// <summary>
     /// Initializes a new instance of the <see cref="StringCollectionAssertions"/> class.
     /// </summary>
-    public StringCollectionAssertions(IEnumerable<string> actualValue)
-        : base(actualValue)
+    public StringCollectionAssertions(IEnumerable<string> actualValue, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
     }
 }
@@ -26,8 +26,8 @@ public class StringCollectionAssertions<TCollection>
     /// <summary>
     /// Initializes a new instance of the <see cref="StringCollectionAssertions{TCollection}"/> class.
     /// </summary>
-    public StringCollectionAssertions(TCollection actualValue)
-        : base(actualValue)
+    public StringCollectionAssertions(TCollection actualValue, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
     }
 }
@@ -36,12 +36,15 @@ public class StringCollectionAssertions<TCollection, TAssertions> : GenericColle
     where TCollection : IEnumerable<string>
     where TAssertions : StringCollectionAssertions<TCollection, TAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="StringCollectionAssertions{TCollection, TAssertions}"/> class.
     /// </summary>
-    public StringCollectionAssertions(TCollection actualValue)
-        : base(actualValue)
+    public StringCollectionAssertions(TCollection actualValue, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -131,7 +134,7 @@ public AndConstraint<TAssertions> BeEquivalentTo(IEnumerable<string> expectation
             options = config(AssertionOptions.CloneDefaults<string>()).AsCollection();
 
         var context =
-            new EquivalencyValidationContext(Node.From<IEnumerable<string>>(() => AssertionScope.Current.CallerIdentity), options)
+            new EquivalencyValidationContext(Node.From<IEnumerable<string>>(() => CurrentAssertionChain.CallerIdentifier), options)
             {
                 Reason = new Reason(because, becauseArgs),
                 TraceWriter = options.TraceWriter
@@ -248,45 +251,48 @@ public AndWhichConstraint<TAssertions, string> ContainMatch(string wildcardPatte
         Guard.ThrowIfArgumentIsEmpty(wildcardPattern, nameof(wildcardPattern),
             "Cannot match strings in collection against an empty string. Provide a wildcard pattern or use the Contain method.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:collection} to contain a match of {0}{reason}, but found <null>.", wildcardPattern);
 
-        IEnumerable<string> matched = [];
+        IEnumerable<string> matches = [];
+
+        int? firstMatch = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            (matches, firstMatch) = AllThatMatch(wildcardPattern);
+
+            assertionChain
                 .BecauseOf(because, becauseArgs)
-                .ForCondition(ContainsMatch(wildcardPattern))
+                .ForCondition(matches.Any())
                 .FailWith("Expected {context:collection} {0} to contain a match of {1}{reason}.", Subject, wildcardPattern);
-
-            matched = AllThatMatch(wildcardPattern);
         }
 
-        return new AndWhichConstraint<TAssertions, string>((TAssertions)this, matched);
+        return new AndWhichConstraint<TAssertions, string>((TAssertions)this, matches, assertionChain, "[" + firstMatch + "]");
     }
 
-    private bool ContainsMatch(string wildcardPattern)
+    private (string[] MatchingItems, int? FirstMatchingIndex) AllThatMatch(string wildcardPattern)
     {
-        using var scope = new AssertionScope();
-
-        return Subject.Any(item =>
-        {
-            item.Should().Match(wildcardPattern);
-            return scope.Discard().Length == 0;
-        });
-    }
+        int? firstMatchingIndex = null;
 
-    private IEnumerable<string> AllThatMatch(string wildcardPattern)
-    {
-        return Subject.Where(item =>
+        var matches = Subject.Where((item, index) =>
         {
             using var scope = new AssertionScope();
+
             item.Should().Match(wildcardPattern);
-            return scope.Discard().Length == 0;
+
+            if (scope.Discard().Length == 0)
+            {
+                firstMatchingIndex ??= index;
+                return true;
+            }
+
+            return false;
         });
+
+        return (matches.ToArray(), firstMatchingIndex);
     }
 
     /// <summary>
@@ -333,15 +339,15 @@ public AndConstraint<TAssertions> NotContainMatch(string wildcardPattern,
         Guard.ThrowIfArgumentIsEmpty(wildcardPattern, nameof(wildcardPattern),
             "Cannot match strings in collection against an empty string. Provide a wildcard pattern or use the NotContain method.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Did not expect {context:collection} to contain a match of {0}{reason}, but found <null>.",
                 wildcardPattern);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(NotContainsMatch(wildcardPattern))
                 .FailWith("Did not expect {context:collection} {0} to contain a match of {1}{reason}.", Subject, wildcardPattern);
diff --git a/Src/FluentAssertions/Collections/SubsequentOrderingAssertions.cs b/Src/FluentAssertions/Collections/SubsequentOrderingAssertions.cs
index 8d1faebf3b..82634696b1 100644
--- a/Src/FluentAssertions/Collections/SubsequentOrderingAssertions.cs
+++ b/Src/FluentAssertions/Collections/SubsequentOrderingAssertions.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Collections;
 
@@ -8,8 +9,8 @@ namespace FluentAssertions.Collections;
 public class SubsequentOrderingAssertions<T>
     : SubsequentOrderingGenericCollectionAssertions<IEnumerable<T>, T, SubsequentOrderingAssertions<T>>
 {
-    public SubsequentOrderingAssertions(IEnumerable<T> actualValue, IOrderedEnumerable<T> previousOrderedEnumerable)
-        : base(actualValue, previousOrderedEnumerable)
+    public SubsequentOrderingAssertions(IEnumerable<T> actualValue, IOrderedEnumerable<T> previousOrderedEnumerable, AssertionChain assertionChain)
+        : base(actualValue, previousOrderedEnumerable, assertionChain)
     {
     }
 }
diff --git a/Src/FluentAssertions/Collections/SubsequentOrderingGenericCollectionAssertions.cs b/Src/FluentAssertions/Collections/SubsequentOrderingGenericCollectionAssertions.cs
index 104dedac65..789176f263 100644
--- a/Src/FluentAssertions/Collections/SubsequentOrderingGenericCollectionAssertions.cs
+++ b/Src/FluentAssertions/Collections/SubsequentOrderingGenericCollectionAssertions.cs
@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Collections;
 
@@ -17,8 +18,8 @@ public class SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAsse
     private readonly IOrderedEnumerable<T> previousOrderedEnumerable;
     private bool subsequentOrdering;
 
-    public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, IOrderedEnumerable<T> previousOrderedEnumerable)
-        : base(actualValue)
+    public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, IOrderedEnumerable<T> previousOrderedEnumerable, AssertionChain assertionChain)
+        : base(actualValue, assertionChain)
     {
         this.previousOrderedEnumerable = previousOrderedEnumerable;
     }
@@ -170,8 +171,8 @@ public class SubsequentOrderingGenericCollectionAssertions<TCollection, T>
     : SubsequentOrderingGenericCollectionAssertions<TCollection, T, SubsequentOrderingGenericCollectionAssertions<TCollection, T>>
     where TCollection : IEnumerable<T>
 {
-    public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, IOrderedEnumerable<T> previousOrderedEnumerable)
-        : base(actualValue, previousOrderedEnumerable)
+    public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, IOrderedEnumerable<T> previousOrderedEnumerable, AssertionChain assertionChain)
+        : base(actualValue, previousOrderedEnumerable, assertionChain)
     {
     }
 }
diff --git a/Src/FluentAssertions/Common/MethodInfoExtensions.cs b/Src/FluentAssertions/Common/MethodInfoExtensions.cs
index 7fcef498a5..5219f0570b 100644
--- a/Src/FluentAssertions/Common/MethodInfoExtensions.cs
+++ b/Src/FluentAssertions/Common/MethodInfoExtensions.cs
@@ -30,7 +30,6 @@ internal static IEnumerable<TAttribute> GetMatchingAttributes<TAttribute>(this M
         if (typeof(TAttribute) == typeof(MethodImplAttribute) && memberInfo is MethodBase methodBase)
         {
             (bool success, MethodImplAttribute methodImplAttribute) = RecreateMethodImplAttribute(methodBase);
-
             if (success)
             {
                 customAttributes.Add(methodImplAttribute as TAttribute);
diff --git a/Src/FluentAssertions/Common/ObjectExtensions.cs b/Src/FluentAssertions/Common/ObjectExtensions.cs
index 7ba5e3bdcc..e1bf0f0032 100644
--- a/Src/FluentAssertions/Common/ObjectExtensions.cs
+++ b/Src/FluentAssertions/Common/ObjectExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using FluentAssertions.Formatting;
 
 namespace FluentAssertions.Common;
 
@@ -77,4 +78,12 @@ ushort or
             uint or
             ulong);
     }
+
+    /// <summary>
+    /// Convenience method to format an object to a string using the <see cref="Formatter"/> class.
+    /// </summary>
+    public static string ToFormattedString(this object source)
+    {
+        return Formatter.ToString(source);
+    }
 }
diff --git a/Src/FluentAssertions/Common/StringExtensions.cs b/Src/FluentAssertions/Common/StringExtensions.cs
index e83ab55b24..f1b047d02f 100644
--- a/Src/FluentAssertions/Common/StringExtensions.cs
+++ b/Src/FluentAssertions/Common/StringExtensions.cs
@@ -127,6 +127,12 @@ public static string RemoveNewlineStyle(this string @this)
             .Replace("\r", "\n", StringComparison.Ordinal);
     }
 
+    public static string RemoveTrailingWhitespaceFromLines(this string input)
+    {
+        // This regex matches whitespace characters (\s) that are followed by a line ending (\r?\n)
+        return Regex.Replace(input, @"[ \t]+(?=\r?\n)", string.Empty);
+    }
+
     /// <summary>
     /// Counts the number of times the <paramref name="substring"/> appears within a string by using the specified <paramref name="comparer"/>.
     /// </summary>
@@ -156,4 +162,9 @@ public static bool IsLongOrMultiline(this string value)
         const int humanReadableLength = 8;
         return value.Length > humanReadableLength || value.Contains(Environment.NewLine, StringComparison.Ordinal);
     }
+
+    public static bool IsNullOrEmpty(this string value)
+    {
+        return string.IsNullOrEmpty(value);
+    }
 }
diff --git a/Src/FluentAssertions/CustomAssertionAttribute.cs b/Src/FluentAssertions/CustomAssertionAttribute.cs
index 6078c1457f..87dfa929b1 100644
--- a/Src/FluentAssertions/CustomAssertionAttribute.cs
+++ b/Src/FluentAssertions/CustomAssertionAttribute.cs
@@ -4,7 +4,7 @@ namespace FluentAssertions;
 
 /// <summary>
 /// Marks a method as an extension to Fluent Assertions that either uses the built-in assertions
-/// internally, or directly uses the <c>Execute.Assertion</c>.
+/// internally, or directly uses <c>AssertionChain</c>.
 /// </summary>
 [AttributeUsage(AttributeTargets.Method)]
 #pragma warning disable CA1813 // Avoid unsealed attributes. This type has shipped.
diff --git a/Src/FluentAssertions/CustomAssertionsAssemblyAttribute.cs b/Src/FluentAssertions/CustomAssertionsAssemblyAttribute.cs
index faaff8e2b3..9e0cc90410 100644
--- a/Src/FluentAssertions/CustomAssertionsAssemblyAttribute.cs
+++ b/Src/FluentAssertions/CustomAssertionsAssemblyAttribute.cs
@@ -4,7 +4,7 @@ namespace FluentAssertions;
 
 /// <summary>
 /// Marks an assembly as containing extensions to Fluent Assertions that either uses the built-in assertions
-/// internally, or directly uses the <c>Execute.Assertion</c>.
+/// internally, or directly uses <c>AssertionChain</c>.
 /// </summary>
 [AttributeUsage(AttributeTargets.Assembly)]
 public sealed class CustomAssertionsAssemblyAttribute : Attribute;
diff --git a/Src/FluentAssertions/EnumAssertionsExtensions.cs b/Src/FluentAssertions/EnumAssertionsExtensions.cs
index 31688fb9cc..da15e34440 100644
--- a/Src/FluentAssertions/EnumAssertionsExtensions.cs
+++ b/Src/FluentAssertions/EnumAssertionsExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
+using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 
 namespace FluentAssertions;
@@ -19,7 +20,7 @@ public static class EnumAssertionsExtensions
     public static EnumAssertions<TEnum> Should<TEnum>(this TEnum @enum)
         where TEnum : struct, Enum
     {
-        return new EnumAssertions<TEnum>(@enum);
+        return new EnumAssertions<TEnum>(@enum, AssertionChain.GetOrCreate());
     }
 
     /// <summary>
@@ -30,6 +31,6 @@ public static EnumAssertions<TEnum> Should<TEnum>(this TEnum @enum)
     public static NullableEnumAssertions<TEnum> Should<TEnum>(this TEnum? @enum)
         where TEnum : struct, Enum
     {
-        return new NullableEnumAssertions<TEnum>(@enum);
+        return new NullableEnumAssertions<TEnum>(@enum, AssertionChain.GetOrCreate());
     }
 }
diff --git a/Src/FluentAssertions/Equivalency/AssertionChainExtensions.cs b/Src/FluentAssertions/Equivalency/AssertionChainExtensions.cs
new file mode 100644
index 0000000000..95227db2cb
--- /dev/null
+++ b/Src/FluentAssertions/Equivalency/AssertionChainExtensions.cs
@@ -0,0 +1,19 @@
+using FluentAssertions.Execution;
+
+namespace FluentAssertions.Equivalency;
+
+internal static class AssertionChainExtensions
+{
+    /// <summary>
+    /// Updates the <see cref="AssertionChain"/> with the relevant information from the current <see cref="IEquivalencyValidationContext"/>, including the correct
+    /// caller identification path.
+    /// </summary>
+    public static AssertionChain For(this AssertionChain chain, IEquivalencyValidationContext context)
+    {
+        chain.OverrideCallerIdentifier(() => context.CurrentNode.Description);
+
+        return chain
+            .WithReportable("configuration", () => context.Options.ToString())
+            .BecauseOf(context.Reason);
+    }
+}
diff --git a/Src/FluentAssertions/Equivalency/EquivalencyStep.cs b/Src/FluentAssertions/Equivalency/EquivalencyStep.cs
index d50c77023a..58f689f771 100644
--- a/Src/FluentAssertions/Equivalency/EquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/EquivalencyStep.cs
@@ -20,5 +20,5 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
     /// Implements <see cref="IEquivalencyStep.Handle"/>, but only gets called when the expected type matches <typeparamref name="T"/>.
     /// </summary>
     protected abstract EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
-        IValidateChildNodeEquivalency nested);
+        IValidateChildNodeEquivalency nestedValidator);
 }
diff --git a/Src/FluentAssertions/Equivalency/EquivalencyValidationContext.cs b/Src/FluentAssertions/Equivalency/EquivalencyValidationContext.cs
index 9d7215a971..2fbced998e 100644
--- a/Src/FluentAssertions/Equivalency/EquivalencyValidationContext.cs
+++ b/Src/FluentAssertions/Equivalency/EquivalencyValidationContext.cs
@@ -75,7 +75,7 @@ public bool IsCyclicReference(object expectation)
             is EqualityStrategy.Members or EqualityStrategy.ForceMembers;
 
         var reference = new ObjectReference(expectation, CurrentNode.PathAndName, compareByMembers);
-        return CyclicReferenceDetector.IsCyclicReference(reference, Options.CyclicReferenceHandling, Reason);
+        return CyclicReferenceDetector.IsCyclicReference(reference);
     }
 
     public ITraceWriter TraceWriter { get; set; }
diff --git a/Src/FluentAssertions/Equivalency/EquivalencyValidator.cs b/Src/FluentAssertions/Equivalency/EquivalencyValidator.cs
index 6d7de0a3fd..b856f6d22a 100644
--- a/Src/FluentAssertions/Equivalency/EquivalencyValidator.cs
+++ b/Src/FluentAssertions/Equivalency/EquivalencyValidator.cs
@@ -15,10 +15,6 @@ public void AssertEquality(Comparands comparands, EquivalencyValidationContext c
     {
         using var scope = new AssertionScope();
 
-        scope.AssumeSingleCaller();
-        scope.AddReportable("configuration", () => context.Options.ToString());
-        scope.BecauseOf(context.Reason);
-
         RecursivelyAssertEquivalencyOf(comparands, context);
 
         if (context.TraceWriter is not null)
@@ -34,39 +30,40 @@ private void RecursivelyAssertEquivalencyOf(Comparands comparands, IEquivalencyV
 
     public void AssertEquivalencyOf(Comparands comparands, IEquivalencyValidationContext context)
     {
-        var scope = AssertionScope.Current;
+        var assertionChain = AssertionChain.GetOrCreate()
+            .For(context)
+            .BecauseOf(context.Reason);
 
-        if (ShouldContinueThisDeep(context.CurrentNode, context.Options, scope))
+        if (ShouldContinueThisDeep(context.CurrentNode, context.Options, assertionChain))
         {
-            TrackWhatIsNeededToProvideContextToFailures(scope, comparands, context.CurrentNode);
-
             if (!context.IsCyclicReference(comparands.Expectation))
             {
                 TryToProveNodesAreEquivalent(comparands, context);
             }
+            else if (context.Options.CyclicReferenceHandling == CyclicReferenceHandling.ThrowException)
+            {
+                assertionChain.FailWith("Expected {context:subject} to be {expectation}{reason}, but it contains a cyclic reference.");
+            }
+            else
+            {
+                // If cyclic references are allowed, we consider the objects to be equivalent
+            }
         }
     }
 
     private static bool ShouldContinueThisDeep(INode currentNode, IEquivalencyOptions options,
-        AssertionScope assertionScope)
+        AssertionChain assertionChain)
     {
         bool shouldRecurse = options.AllowInfiniteRecursion || currentNode.Depth <= MaxDepth;
         if (!shouldRecurse)
         {
             // This will throw, unless we're inside an AssertionScope
-            assertionScope.FailWith($"The maximum recursion depth of {MaxDepth} was reached.  ");
+            assertionChain.FailWith($"The maximum recursion depth of {MaxDepth} was reached.  ");
         }
 
         return shouldRecurse;
     }
 
-    private static void TrackWhatIsNeededToProvideContextToFailures(AssertionScope scope, Comparands comparands, INode currentNode)
-    {
-        scope.Context = new Lazy<string>(() => currentNode.Description);
-
-        scope.TrackComparands(comparands.Subject, comparands.Expectation);
-    }
-
     private void TryToProveNodesAreEquivalent(Comparands comparands, IEquivalencyValidationContext context)
     {
         using var _ = context.Tracer.WriteBlock(node => node.Description);
diff --git a/Src/FluentAssertions/Equivalency/Execution/CyclicReferenceDetector.cs b/Src/FluentAssertions/Equivalency/Execution/CyclicReferenceDetector.cs
index 600823aee9..4ca13ce49d 100644
--- a/Src/FluentAssertions/Equivalency/Execution/CyclicReferenceDetector.cs
+++ b/Src/FluentAssertions/Equivalency/Execution/CyclicReferenceDetector.cs
@@ -19,24 +19,13 @@ internal class CyclicReferenceDetector : ICloneable2
     /// Determines whether the specified object reference is a cyclic reference to the same object earlier in the
     /// equivalency validation.
     /// </summary>
-    /// <remarks>
-    /// The behavior of a cyclic reference is determined by the <paramref name="handling"/> parameter.
-    /// </remarks>
-    public bool IsCyclicReference(ObjectReference reference, CyclicReferenceHandling handling, Reason reason = null)
+    public bool IsCyclicReference(ObjectReference reference)
     {
         bool isCyclic = false;
 
         if (reference.CompareByMembers)
         {
             isCyclic = !observedReferences.Add(reference);
-
-            if (isCyclic && handling == CyclicReferenceHandling.ThrowException)
-            {
-                AssertionScope.Current
-                    .BecauseOf(reason)
-                    .FailWith(
-                        "Expected {context:subject} to be {expectation}{reason}, but it contains a cyclic reference.");
-            }
         }
 
         return isCyclic;
diff --git a/Src/FluentAssertions/Equivalency/IEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/IEquivalencyStep.cs
index d4f744b5ea..d0279009ae 100644
--- a/Src/FluentAssertions/Equivalency/IEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/IEquivalencyStep.cs
@@ -15,5 +15,6 @@ public interface IEquivalencyStep
     /// <remarks>
     /// May throw when preconditions are not met or if it detects mismatching data.
     /// </remarks>
-    EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationContext context, IValidateChildNodeEquivalency valueChildNodes);
+    EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationContext context,
+        IValidateChildNodeEquivalency valueChildNodes);
 }
diff --git a/Src/FluentAssertions/Equivalency/IMemberMatchingRule.cs b/Src/FluentAssertions/Equivalency/IMemberMatchingRule.cs
index 00f1dbcdad..0a59d796eb 100644
--- a/Src/FluentAssertions/Equivalency/IMemberMatchingRule.cs
+++ b/Src/FluentAssertions/Equivalency/IMemberMatchingRule.cs
@@ -1,3 +1,5 @@
+using FluentAssertions.Execution;
+
 namespace FluentAssertions.Equivalency;
 
 /// <summary>
@@ -15,17 +17,18 @@ public interface IMemberMatchingRule
     /// simply return <see langword="null"/>.
     /// </remarks>
     /// <param name="expectedMember">
-    /// The <see cref="IMember"/> of the subject's member for which a match must be found. Can never
-    /// be <see langword="null"/>.
+    ///     The <see cref="IMember"/> of the subject's member for which a match must be found. Can never
+    ///     be <see langword="null"/>.
     /// </param>
     /// <param name="subject">
-    /// The subject object for which a matching member must be returned. Can never be <see langword="null"/>.
+    ///     The subject object for which a matching member must be returned. Can never be <see langword="null"/>.
     /// </param>
     /// <param name="parent"></param>
     /// <param name="options"></param>
+    /// <param name="assertionChain"></param>
     /// <returns>
     /// Returns the <see cref="IMember"/> of the property with which to compare the subject with, or <see langword="null"/>
     /// if no match was found.
     /// </returns>
-    IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options);
+    IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options, AssertionChain assertionChain);
 }
diff --git a/Src/FluentAssertions/Equivalency/Matching/MappedMemberMatchingRule.cs b/Src/FluentAssertions/Equivalency/Matching/MappedMemberMatchingRule.cs
index 51b6c43a2b..faa1aaaea2 100644
--- a/Src/FluentAssertions/Equivalency/Matching/MappedMemberMatchingRule.cs
+++ b/Src/FluentAssertions/Equivalency/Matching/MappedMemberMatchingRule.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Text.RegularExpressions;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Matching;
 
@@ -29,7 +30,7 @@ public MappedMemberMatchingRule(string expectationMemberName, string subjectMemb
         this.subjectMemberName = subjectMemberName;
     }
 
-    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options)
+    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options, AssertionChain assertionChain)
     {
         if (parent.Type.IsSameOrInherits(typeof(TExpectation)) && subject is TSubject &&
             expectedMember.Name == expectationMemberName)
diff --git a/Src/FluentAssertions/Equivalency/Matching/MappedPathMatchingRule.cs b/Src/FluentAssertions/Equivalency/Matching/MappedPathMatchingRule.cs
index ded3bcaa9f..88c44a8f4c 100644
--- a/Src/FluentAssertions/Equivalency/Matching/MappedPathMatchingRule.cs
+++ b/Src/FluentAssertions/Equivalency/Matching/MappedPathMatchingRule.cs
@@ -1,5 +1,6 @@
 using System;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Matching;
 
@@ -42,7 +43,7 @@ public MappedPathMatchingRule(string expectationMemberPath, string subjectMember
         }
     }
 
-    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options)
+    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options, AssertionChain assertionChain)
     {
         MemberPath path = expectationPath;
 
diff --git a/Src/FluentAssertions/Equivalency/Matching/MustMatchByNameRule.cs b/Src/FluentAssertions/Equivalency/Matching/MustMatchByNameRule.cs
index 36d220c195..dc5ac17c6e 100644
--- a/Src/FluentAssertions/Equivalency/Matching/MustMatchByNameRule.cs
+++ b/Src/FluentAssertions/Equivalency/Matching/MustMatchByNameRule.cs
@@ -9,7 +9,7 @@ namespace FluentAssertions.Equivalency.Matching;
 /// </summary>
 internal class MustMatchByNameRule : IMemberMatchingRule
 {
-    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options)
+    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options, AssertionChain assertionChain)
     {
         IMember subjectMember = null;
 
@@ -33,12 +33,12 @@ public IMember Match(IMember expectedMember, object subject, INode parent, IEqui
 
         if (subjectMember is null)
         {
-            Execute.Assertion.FailWith(
+            assertionChain.FailWith(
                 $"Expectation has {expectedMember.Description} that the other object does not have.");
         }
         else if (options.IgnoreNonBrowsableOnSubject && !subjectMember.IsBrowsable)
         {
-            Execute.Assertion.FailWith(
+            assertionChain.FailWith(
                 $"Expectation has {expectedMember.Description} that is non-browsable in the other object, and non-browsable " +
                 "members on the subject are ignored with the current configuration");
         }
diff --git a/Src/FluentAssertions/Equivalency/Matching/TryMatchByNameRule.cs b/Src/FluentAssertions/Equivalency/Matching/TryMatchByNameRule.cs
index 06cabfdf60..9d6d7dc95c 100644
--- a/Src/FluentAssertions/Equivalency/Matching/TryMatchByNameRule.cs
+++ b/Src/FluentAssertions/Equivalency/Matching/TryMatchByNameRule.cs
@@ -1,5 +1,6 @@
 using System.Reflection;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Matching;
 
@@ -8,7 +9,7 @@ namespace FluentAssertions.Equivalency.Matching;
 /// </summary>
 internal class TryMatchByNameRule : IMemberMatchingRule
 {
-    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options)
+    public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options, AssertionChain assertionChain)
     {
         if (options.IncludedProperties != MemberVisibility.None)
         {
diff --git a/Src/FluentAssertions/Equivalency/MultiDimensionalArrayEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/MultiDimensionalArrayEquivalencyStep.cs
index 016a566003..4962f36860 100644
--- a/Src/FluentAssertions/Equivalency/MultiDimensionalArrayEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/MultiDimensionalArrayEquivalencyStep.cs
@@ -18,7 +18,7 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
-        if (AreComparable(comparands, expectationAsArray))
+        if (AreComparable(comparands, expectationAsArray, AssertionChain.GetOrCreate().For(context)))
         {
             if (expectationAsArray.Length == 0)
             {
@@ -36,7 +36,8 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
 
                 IEquivalencyValidationContext itemContext = context.AsCollectionItem<object>(listOfIndices);
 
-                valueChildNodes.AssertEquivalencyOf(new Comparands(subject, expectation, typeof(object)), itemContext);
+                valueChildNodes.AssertEquivalencyOf(new Comparands(subject, expectation, typeof(object)),
+                    itemContext);
             }
             while (digit.Increment());
         }
@@ -52,25 +53,27 @@ private static Digit BuildDigitsRepresentingAllIndices(Array subjectAsArray)
             .Aggregate((Digit)null, (next, rank) => new Digit(subjectAsArray.GetLength(rank), next));
     }
 
-    private static bool AreComparable(Comparands comparands, Array expectationAsArray)
+    private static bool AreComparable(Comparands comparands, Array expectationAsArray, AssertionChain assertionChain)
     {
         return
-            IsArray(comparands.Subject) &&
-            HaveSameRank(comparands.Subject, expectationAsArray) &&
-            HaveSameDimensions(comparands.Subject, expectationAsArray);
+            IsArray(comparands.Subject, assertionChain) &&
+            HaveSameRank(comparands.Subject, expectationAsArray, assertionChain) &&
+            HaveSameDimensions(comparands.Subject, expectationAsArray, assertionChain);
     }
 
-    private static bool IsArray(object type)
+    private static bool IsArray(object type, AssertionChain assertionChain)
     {
-        return AssertionScope.Current
+        assertionChain
             .ForCondition(type is not null)
             .FailWith("Cannot compare a multi-dimensional array to <null>.")
             .Then
             .ForCondition(type is Array)
             .FailWith("Cannot compare a multi-dimensional array to something else.");
+
+        return assertionChain.Succeeded;
     }
 
-    private static bool HaveSameDimensions(object subject, Array expectation)
+    private static bool HaveSameDimensions(object subject, Array expectation, AssertionChain assertionChain)
     {
         bool sameDimensions = true;
 
@@ -79,22 +82,26 @@ private static bool HaveSameDimensions(object subject, Array expectation)
             int actualLength = ((Array)subject).GetLength(dimension);
             int expectedLength = expectation.GetLength(dimension);
 
-            sameDimensions &= AssertionScope.Current
+            assertionChain
                 .ForCondition(expectedLength == actualLength)
                 .FailWith("Expected dimension {0} to contain {1} item(s), but found {2}.", dimension, expectedLength,
                     actualLength);
+
+            sameDimensions &= assertionChain.Succeeded;
         }
 
         return sameDimensions;
     }
 
-    private static bool HaveSameRank(object subject, Array expectation)
+    private static bool HaveSameRank(object subject, Array expectation, AssertionChain assertionChain)
     {
         var subjectAsArray = (Array)subject;
 
-        return AssertionScope.Current
+        assertionChain
             .ForCondition(subjectAsArray.Rank == expectation.Rank)
             .FailWith("Expected {context:array} to have {0} dimension(s), but it has {1}.", expectation.Rank,
                 subjectAsArray.Rank);
+
+        return assertionChain.Succeeded;
     }
 }
diff --git a/Src/FluentAssertions/Equivalency/Node.cs b/Src/FluentAssertions/Equivalency/Node.cs
index 4f264a3d38..96ee51e87f 100644
--- a/Src/FluentAssertions/Equivalency/Node.cs
+++ b/Src/FluentAssertions/Equivalency/Node.cs
@@ -10,11 +10,18 @@ internal class Node : INode
 {
     private static readonly Regex MatchFirstIndex = new(@"^\[[0-9]+\]$");
 
+    private GetSubjectId subjectIdProvider;
+
     private string path;
     private string name;
     private string pathAndName;
+    private string cachedSubjectId;
 
-    public GetSubjectId GetSubjectId { get; protected set; } = () => string.Empty;
+    public GetSubjectId GetSubjectId
+    {
+        get => () => cachedSubjectId ??= subjectIdProvider();
+        protected init => subjectIdProvider = value;
+    }
 
     public Type Type { get; protected set; }
 
@@ -76,7 +83,7 @@ public static INode From<T>(GetSubjectId getSubjectId)
     {
         return new Node
         {
-            GetSubjectId = () => getSubjectId() ?? "root",
+            subjectIdProvider = () => getSubjectId() ?? "root",
             Name = string.Empty,
             Path = string.Empty,
             Type = typeof(T),
diff --git a/Src/FluentAssertions/Equivalency/Steps/AssertionResultSet.cs b/Src/FluentAssertions/Equivalency/Steps/AssertionResultSet.cs
index b1b9b7cfe2..8bde0c02aa 100644
--- a/Src/FluentAssertions/Equivalency/Steps/AssertionResultSet.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/AssertionResultSet.cs
@@ -22,7 +22,7 @@ public void AddSet(object key, string[] failures)
     }
 
     /// <summary>
-    /// Returns  the closest match compared to the set identified by the provided <paramref name="key"/> or
+    /// Returns the closest match compared to the set identified by the provided <paramref name="key"/> or
     /// an empty array if one of the results represents a successful assertion.
     /// </summary>
     /// <remarks>
diff --git a/Src/FluentAssertions/Equivalency/Steps/AssertionRuleEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/AssertionRuleEquivalencyStep.cs
index ce2116a0fe..2a1990786b 100644
--- a/Src/FluentAssertions/Equivalency/Steps/AssertionRuleEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/AssertionRuleEquivalencyStep.cs
@@ -10,15 +10,15 @@ public class AssertionRuleEquivalencyStep<TSubject> : IEquivalencyStep
 {
     private readonly Func<IObjectInfo, bool> predicate;
     private readonly string description;
-    private readonly Action<IAssertionContext<TSubject>> assertion;
+    private readonly Action<IAssertionContext<TSubject>> assertionAction;
     private readonly AutoConversionStep converter = new();
 
     public AssertionRuleEquivalencyStep(
         Expression<Func<IObjectInfo, bool>> predicate,
-        Action<IAssertionContext<TSubject>> assertion)
+        Action<IAssertionContext<TSubject>> assertionAction)
     {
         this.predicate = predicate.Compile();
-        this.assertion = assertion;
+        this.assertionAction = assertionAction;
         description = predicate.ToString();
     }
 
@@ -49,7 +49,6 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             {
                 // Try again after conversion
                 success = ExecuteAssertion(comparands, context);
-
                 if (success)
                 {
                     // If the assertion succeeded after conversion, discard the failures from
@@ -67,30 +66,33 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
     private bool ExecuteAssertion(Comparands comparands, IEquivalencyValidationContext context)
     {
         bool subjectIsNull = comparands.Subject is null;
+        bool expectationIsNull = comparands.Expectation is null;
 
-        bool subjectIsValidType =
-            AssertionScope.Current
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        assertionChain
                 .ForCondition(subjectIsNull || comparands.Subject.GetType().IsSameOrInherits(typeof(TSubject)))
                 .FailWith("Expected " + context.CurrentNode.Description + " from subject to be a {0}{reason}, but found a {1}.",
-                    typeof(TSubject), comparands.Subject?.GetType());
-
-        bool expectationIsNull = comparands.Expectation is null;
-
-        bool expectationIsValidType =
-            AssertionScope.Current
+                    typeof(TSubject), comparands.Subject?.GetType())
+                .Then
                 .ForCondition(expectationIsNull || comparands.Expectation.GetType().IsSameOrInherits(typeof(TSubject)))
                 .FailWith(
                     "Expected " + context.CurrentNode.Description + " from expectation to be a {0}{reason}, but found a {1}.",
                     typeof(TSubject), comparands.Expectation?.GetType());
 
-        if (subjectIsValidType && expectationIsValidType)
+        if (assertionChain.Succeeded)
         {
             if ((subjectIsNull || expectationIsNull) && !CanBeNull<TSubject>())
             {
                 return false;
             }
 
-            assertion(AssertionContext<TSubject>.CreateFrom(comparands, context));
+            // Caller identitification should not get confused about invoking a Should within the assertion action
+            string callerIdentifier = context.CurrentNode.Description;
+            assertionChain.OverrideCallerIdentifier(() => callerIdentifier);
+            assertionChain.ReuseOnce();
+
+            assertionAction(AssertionContext<TSubject>.CreateFrom(comparands, context));
             return true;
         }
 
diff --git a/Src/FluentAssertions/Equivalency/Steps/DictionaryEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/DictionaryEquivalencyStep.cs
index 67dff5dbf2..3aef3ec044 100644
--- a/Src/FluentAssertions/Equivalency/Steps/DictionaryEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/DictionaryEquivalencyStep.cs
@@ -1,6 +1,8 @@
 using System.Collections;
 using System.Diagnostics.CodeAnalysis;
+using FluentAssertions.Common;
 using FluentAssertions.Execution;
+using FluentAssertions.Formatting;
 using static System.FormattableString;
 
 namespace FluentAssertions.Equivalency.Steps;
@@ -8,13 +10,16 @@ namespace FluentAssertions.Equivalency.Steps;
 public class DictionaryEquivalencyStep : EquivalencyStep<IDictionary>
 {
     [SuppressMessage("ReSharper", "PossibleNullReferenceException")]
-    protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
-        IValidateChildNodeEquivalency nested)
+    protected override EquivalencyResult OnHandle(Comparands comparands,
+        IEquivalencyValidationContext context,
+        IValidateChildNodeEquivalency nestedValidator)
     {
         var subject = comparands.Subject as IDictionary;
         var expectation = comparands.Expectation as IDictionary;
 
-        if (PreconditionsAreMet(expectation, subject) && expectation is not null)
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        if (PreconditionsAreMet(expectation, subject, assertionChain) && expectation is not null)
         {
             foreach (object key in expectation.Keys)
             {
@@ -23,8 +28,7 @@ protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalenc
                     context.Tracer.WriteLine(member =>
                         Invariant($"Recursing into dictionary item {key} at {member.Description}"));
 
-                    nested.AssertEquivalencyOf(new Comparands(subject[key], expectation[key], typeof(object)),
-                        context.AsDictionaryItem<object, IDictionary>(key));
+                    nestedValidator.AssertEquivalencyOf(new Comparands(subject[key], expectation[key], typeof(object)), context.AsDictionaryItem<object, IDictionary>(key));
                 }
                 else
                 {
@@ -32,6 +36,7 @@ protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalenc
                         Invariant(
                             $"Comparing dictionary item {key} at {member.Description} between subject and expectation"));
 
+                    assertionChain.WithCallerPostfix($"[{key.ToFormattedString()}]").ReuseOnce();
                     subject[key].Should().Be(expectation[key], context.Reason.FormattedMessage, context.Reason.Arguments);
                 }
             }
@@ -40,32 +45,38 @@ protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalenc
         return EquivalencyResult.EquivalencyProven;
     }
 
-    private static bool PreconditionsAreMet(IDictionary expectation, IDictionary subject)
+    private static bool PreconditionsAreMet(IDictionary expectation, IDictionary subject, AssertionChain assertionChain)
     {
-        return AssertIsDictionary(subject)
-            && AssertEitherIsNotNull(expectation, subject)
-            && AssertSameLength(expectation, subject);
+        return AssertIsDictionary(subject, assertionChain)
+            && AssertEitherIsNotNull(expectation, subject, assertionChain)
+            && AssertSameLength(expectation, subject, assertionChain);
     }
 
-    private static bool AssertEitherIsNotNull(IDictionary expectation, IDictionary subject)
+    private static bool AssertEitherIsNotNull(IDictionary expectation, IDictionary subject, AssertionChain assertionChain)
     {
-        return AssertionScope.Current
+        assertionChain
             .ForCondition((expectation is null && subject is null) || expectation is not null)
             .FailWith("Expected {context:subject} to be {0}{reason}, but found {1}.", null, subject);
+
+        return assertionChain.Succeeded;
     }
 
-    private static bool AssertIsDictionary(IDictionary subject)
+    private static bool AssertIsDictionary(IDictionary subject, AssertionChain assertionChain)
     {
-        return AssertionScope.Current
+        assertionChain
             .ForCondition(subject is not null)
             .FailWith("Expected {context:subject} to be a dictionary, but it is not.");
+
+        return assertionChain.Succeeded;
     }
 
-    private static bool AssertSameLength(IDictionary expectation, IDictionary subject)
+    private static bool AssertSameLength(IDictionary expectation, IDictionary subject, AssertionChain assertionChain)
     {
-        return AssertionScope.Current
+        assertionChain
             .ForCondition(expectation is null || subject.Keys.Count == expectation.Keys.Count)
             .FailWith("Expected {context:subject} to be a dictionary with {0} item(s), but it only contains {1} item(s).",
                 expectation?.Keys.Count, subject?.Keys.Count);
+
+        return assertionChain.Succeeded;
     }
 }
diff --git a/Src/FluentAssertions/Equivalency/Steps/DictionaryInterfaceInfo.cs b/Src/FluentAssertions/Equivalency/Steps/DictionaryInterfaceInfo.cs
index f24ac8a726..e0ca76da14 100644
--- a/Src/FluentAssertions/Equivalency/Steps/DictionaryInterfaceInfo.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/DictionaryInterfaceInfo.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Reflection;
 using FluentAssertions.Common;
-using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Steps;
 
@@ -73,11 +72,8 @@ public static DictionaryInterfaceInfo FindFromWithKey(Type target, string role,
 
         if (suitableDictionaryInterfaces.Length > 1)
         {
-            // SMELL: Code could be written to handle this better, but is it really worth the effort?
-            AssertionScope.Current.FailWith(
+            throw new InvalidOperationException(
                 $"The {role} implements multiple IDictionary interfaces taking a key of {key}. ");
-
-            return null;
         }
 
         if (suitableDictionaryInterfaces.Length == 0)
diff --git a/Src/FluentAssertions/Equivalency/Steps/EnumEqualityStep.cs b/Src/FluentAssertions/Equivalency/Steps/EnumEqualityStep.cs
index a0251192ca..a089bdc445 100644
--- a/Src/FluentAssertions/Equivalency/Steps/EnumEqualityStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/EnumEqualityStep.cs
@@ -18,7 +18,9 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
-        bool succeeded = Execute.Assertion
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        assertionChain
             .ForCondition(comparands.Subject?.GetType().IsEnum == true)
             .BecauseOf(context.Reason)
             .FailWith(() =>
@@ -31,16 +33,16 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
                     comparands.Subject);
             });
 
-        if (succeeded)
+        if (assertionChain.Succeeded)
         {
             switch (context.Options.EnumEquivalencyHandling)
             {
                 case EnumEquivalencyHandling.ByValue:
-                    HandleByValue(comparands, context.Reason);
+                    HandleByValue(assertionChain, comparands, context.Reason);
                     break;
 
                 case EnumEquivalencyHandling.ByName:
-                    HandleByName(comparands, context.Reason);
+                    HandleByName(assertionChain, comparands, context.Reason);
                     break;
 
                 default:
@@ -51,12 +53,12 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
         return EquivalencyResult.EquivalencyProven;
     }
 
-    private static void HandleByValue(Comparands comparands, Reason reason)
+    private static void HandleByValue(AssertionChain assertionChain, Comparands comparands, Reason reason)
     {
         decimal? subjectsUnderlyingValue = ExtractDecimal(comparands.Subject);
         decimal? expectationsUnderlyingValue = ExtractDecimal(comparands.Expectation);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(subjectsUnderlyingValue == expectationsUnderlyingValue)
             .BecauseOf(reason)
             .FailWith(() =>
@@ -69,12 +71,12 @@ private static void HandleByValue(Comparands comparands, Reason reason)
             });
     }
 
-    private static void HandleByName(Comparands comparands, Reason reason)
+    private static void HandleByName(AssertionChain assertionChain, Comparands comparands, Reason reason)
     {
         string subject = comparands.Subject.ToString();
         string expected = comparands.Expectation.ToString();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(subject == expected)
             .BecauseOf(reason)
             .FailWith(() =>
diff --git a/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyStep.cs
index 45fc7d57e1..1b6906ba58 100644
--- a/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyStep.cs
@@ -15,9 +15,11 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
-        if (AssertSubjectIsCollection(comparands.Subject))
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        if (AssertSubjectIsCollection(assertionChain, comparands.Subject))
         {
-            var validator = new EnumerableEquivalencyValidator(valueChildNodes, context)
+            var validator = new EnumerableEquivalencyValidator(assertionChain, valueChildNodes, context)
             {
                 Recursive = context.CurrentNode.IsRoot || context.Options.IsRecursive,
                 OrderingRules = context.Options.OrderingRules
@@ -29,20 +31,20 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
         return EquivalencyResult.EquivalencyProven;
     }
 
-    private static bool AssertSubjectIsCollection(object subject)
+    private static bool AssertSubjectIsCollection(AssertionChain assertionChain, object subject)
     {
-        bool conditionMet = AssertionScope.Current
+        assertionChain
             .ForCondition(subject is not null)
             .FailWith("Expected a collection, but {context:Subject} is <null>.");
 
-        if (conditionMet)
+        if (assertionChain.Succeeded)
         {
-            conditionMet = AssertionScope.Current
+            assertionChain
                 .ForCondition(IsCollection(subject.GetType()))
                 .FailWith("Expected a collection, but {context:Subject} is of a non-collection type.");
         }
 
-        return conditionMet;
+        return assertionChain.Succeeded;
     }
 
     private static bool IsCollection(Type type)
diff --git a/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidator.cs b/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidator.cs
index 3a58151a4c..c2e7d5640f 100644
--- a/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidator.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidator.cs
@@ -16,13 +16,16 @@ internal class EnumerableEquivalencyValidator
 
     #region Private Definitions
 
+    private readonly AssertionChain assertionChain;
     private readonly IValidateChildNodeEquivalency parent;
     private readonly IEquivalencyValidationContext context;
 
     #endregion
 
-    public EnumerableEquivalencyValidator(IValidateChildNodeEquivalency parent, IEquivalencyValidationContext context)
+    public EnumerableEquivalencyValidator(AssertionChain assertionChain, IValidateChildNodeEquivalency parent,
+        IEquivalencyValidationContext context)
     {
+        this.assertionChain = assertionChain;
         this.parent = parent;
         this.context = context;
         Recursive = false;
@@ -54,24 +57,25 @@ public void Execute<T>(object[] subject, T[] expectation)
         }
     }
 
-    private static bool AssertIsNotNull(object expectation, object[] subject)
+    private bool AssertIsNotNull(object expectation, object[] subject)
     {
-        return AssertionScope.Current
+        assertionChain
             .ForCondition(expectation is not null)
-            .FailWith("Expected {context:subject} to be <null>, but found {0}.", new object[] { subject });
+            .FailWith("Expected {context:subject} to be <null>, but found {0}.", [subject]);
+
+        return assertionChain.Succeeded;
     }
 
-    private static Continuation AssertCollectionsHaveSameCount<T>(ICollection<object> subject, ICollection<T> expectation)
+    private bool AssertCollectionsHaveSameCount<T>(ICollection<object> subject, ICollection<T> expectation)
     {
-        return AssertionScope.Current
-            .WithExpectation("Expected {context:subject} to be a collection with {0} item(s){reason}", expectation.Count)
+        assertionChain
             .AssertEitherCollectionIsNotEmpty(subject, expectation)
             .Then
             .AssertCollectionHasEnoughItems(subject, expectation)
             .Then
-            .AssertCollectionHasNotTooManyItems(subject, expectation)
-            .Then
-            .ClearExpectation();
+            .AssertCollectionHasNotTooManyItems(subject, expectation);
+
+        return assertionChain.Succeeded;
     }
 
     private void AssertElementGraphEquivalency<T>(object[] subjects, T[] expectations, INode currentNode)
@@ -101,11 +105,9 @@ private void AssertElementGraphEquivalencyWithStrictOrdering<T>(object[] subject
                     $"Strictly comparing expectation {expectation} at {member.Description} to item with index {index} in {subjects}"));
 
             bool succeeded = StrictlyMatchAgainst(subjects, expectation, index);
-
             if (!succeeded)
             {
                 failedCount++;
-
                 if (failedCount >= FailedItemsFastFailThreshold)
                 {
                     context.Tracer.WriteLine(member =>
@@ -185,7 +187,7 @@ private bool LooselyMatchAgainst<T>(IList<object> subjects, T expectation, int e
 
         foreach (string failure in results.GetTheFailuresForTheSetWithTheFewestFailures(expectationIndex))
         {
-            AssertionScope.Current.AddPreFormattedFailure(failure);
+            assertionChain.AddPreFormattedFailure(failure);
         }
 
         return indexToBeRemoved != -1;
@@ -195,8 +197,7 @@ private string[] TryToMatch<T>(object subject, T expectation, int expectationInd
     {
         using var scope = new AssertionScope();
 
-        parent.AssertEquivalencyOf(new Comparands(subject, expectation, typeof(T)),
-            context.AsCollectionItem<T>(expectationIndex));
+        parent.AssertEquivalencyOf(new Comparands(subject, expectation, typeof(T)), context.AsCollectionItem<T>(expectationIndex));
 
         return scope.Discard();
     }
diff --git a/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidatorExtensions.cs b/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidatorExtensions.cs
index 473811c746..f3f3d00e21 100644
--- a/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidatorExtensions.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/EnumerableEquivalencyValidatorExtensions.cs
@@ -6,38 +6,46 @@ namespace FluentAssertions.Equivalency.Steps;
 
 internal static class EnumerableEquivalencyValidatorExtensions
 {
-    public static Continuation AssertEitherCollectionIsNotEmpty<T>(this IAssertionScope scope, ICollection<object> subject,
+    public static Continuation AssertEitherCollectionIsNotEmpty<T>(this AssertionChain assertionChain,
+        ICollection<object> subject,
         ICollection<T> expectation)
     {
-        return scope
-            .ForCondition(subject.Count > 0 || expectation.Count == 0)
-            .FailWith(", but found an empty collection.")
-            .Then
-            .ForCondition(subject.Count == 0 || expectation.Count > 0)
-            .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s).",
-                subject,
-                subject.Count);
+        return assertionChain
+            .WithExpectation("Expected {context:subject} to be a collection with {0} item(s){reason}", expectation.Count,
+                chain => chain
+                    .ForCondition(subject.Count > 0 || expectation.Count == 0)
+                    .FailWith(", but found an empty collection.")
+                    .Then
+                    .ForCondition(subject.Count == 0 || expectation.Count > 0)
+                    .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s).",
+                        subject,
+                        subject.Count));
     }
 
-    public static Continuation AssertCollectionHasEnoughItems<T>(this IAssertionScope scope, ICollection<object> subject,
+    public static Continuation AssertCollectionHasEnoughItems<T>(this AssertionChain assertionChain, ICollection<object> subject,
         ICollection<T> expectation)
     {
-        return scope
-            .ForCondition(subject.Count >= expectation.Count)
-            .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s) less than{Environment.NewLine}{{2}}.",
-                subject,
-                expectation.Count - subject.Count,
-                expectation);
+        return assertionChain
+            .WithExpectation("Expected {context:subject} to be a collection with {0} item(s){reason}", expectation.Count,
+                chain => chain
+                    .ForCondition(subject.Count >= expectation.Count)
+                    .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s) less than{Environment.NewLine}{{2}}.",
+                        subject,
+                        expectation.Count - subject.Count,
+                        expectation));
     }
 
-    public static Continuation AssertCollectionHasNotTooManyItems<T>(this IAssertionScope scope, ICollection<object> subject,
+    public static Continuation AssertCollectionHasNotTooManyItems<T>(this AssertionChain assertionChain,
+        ICollection<object> subject,
         ICollection<T> expectation)
     {
-        return scope
-            .ForCondition(subject.Count <= expectation.Count)
-            .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s) more than{Environment.NewLine}{{2}}.",
-                subject,
-                subject.Count - expectation.Count,
-                expectation);
+        return assertionChain
+            .WithExpectation("Expected {context:subject} to be a collection with {0} item(s){reason}", expectation.Count,
+                chain => chain
+                    .ForCondition(subject.Count <= expectation.Count)
+                    .FailWith($", but {{0}}{Environment.NewLine}contains {{1}} item(s) more than{Environment.NewLine}{{2}}.",
+                        subject,
+                        subject.Count - expectation.Count,
+                        expectation));
     }
 }
diff --git a/Src/FluentAssertions/Equivalency/Steps/EqualityComparerEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/EqualityComparerEquivalencyStep.cs
index 2ba66b8c9e..6bd954d16b 100644
--- a/Src/FluentAssertions/Equivalency/Steps/EqualityComparerEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/EqualityComparerEquivalencyStep.cs
@@ -29,7 +29,8 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
-        Execute.Assertion
+        AssertionChain.GetOrCreate()
+            .For(context)
             .BecauseOf(context.Reason.FormattedMessage, context.Reason.Arguments)
             .ForCondition(comparands.Subject is T)
             .FailWith("Expected {context:object} to be of type {0}{because}, but found {1}", typeof(T), comparands.Subject)
diff --git a/Src/FluentAssertions/Equivalency/Steps/GenericDictionaryEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/GenericDictionaryEquivalencyStep.cs
index f10a166a19..01b58bb808 100644
--- a/Src/FluentAssertions/Equivalency/Steps/GenericDictionaryEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/GenericDictionaryEquivalencyStep.cs
@@ -11,7 +11,7 @@ public class GenericDictionaryEquivalencyStep : IEquivalencyStep
 {
 #pragma warning disable SA1110 // Allow opening parenthesis on new line to reduce line length
     private static readonly MethodInfo AssertDictionaryEquivalenceMethod =
-        new Action<EquivalencyValidationContext, IValidateChildNodeEquivalency, IEquivalencyOptions,
+        new Action<AssertionChain, EquivalencyValidationContext, IValidateChildNodeEquivalency, IEquivalencyOptions,
                 IDictionary<object, object>, IDictionary<object, object>>
             (AssertDictionaryEquivalence).GetMethodInfo().GetGenericMethodDefinition();
 #pragma warning restore SA1110
@@ -37,10 +37,13 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
-        if (IsNotNull(comparands.Subject)
-            && EnsureSubjectIsOfTheExpectedDictionaryType(comparands, expectedDictionary) is { } actualDictionary)
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        if (IsNotNull(assertionChain, comparands.Subject)
+            && EnsureSubjectIsOfTheExpectedDictionaryType(assertionChain, comparands, expectedDictionary) is { } actualDictionary)
         {
-            AssertDictionaryEquivalence(comparands, context, valueChildNodes, actualDictionary, expectedDictionary);
+            AssertDictionaryEquivalence(comparands, assertionChain, context, valueChildNodes, actualDictionary,
+                expectedDictionary);
         }
 
         return EquivalencyResult.EquivalencyProven;
@@ -57,14 +60,17 @@ private static bool IsNonGenericDictionary(object subject)
             @interface.IsGenericType && @interface.GetGenericTypeDefinition() == typeof(IDictionary<,>));
     }
 
-    private static bool IsNotNull(object subject)
+    private static bool IsNotNull(AssertionChain assertionChain, object subject)
     {
-        return AssertionScope.Current
+        assertionChain
             .ForCondition(subject is not null)
             .FailWith("Expected {context:Subject} not to be {0}{reason}.", new object[] { null });
+
+        return assertionChain.Succeeded;
     }
 
-    private static DictionaryInterfaceInfo EnsureSubjectIsOfTheExpectedDictionaryType(Comparands comparands,
+    private static DictionaryInterfaceInfo EnsureSubjectIsOfTheExpectedDictionaryType(AssertionChain assertionChain,
+        Comparands comparands,
         DictionaryInterfaceInfo expectedDictionary)
     {
         var actualDictionary = DictionaryInterfaceInfo.FindFromWithKey(comparands.Subject.GetType(), "subject",
@@ -78,7 +84,7 @@ private static DictionaryInterfaceInfo EnsureSubjectIsOfTheExpectedDictionaryTyp
 
         if (actualDictionary is null)
         {
-            AssertionScope.Current.FailWith(
+            assertionChain.FailWith(
                 "Expected {context:subject} to be a dictionary or collection of key-value pairs that is keyed to " +
                 $"type {expectedDictionary.Key}.");
         }
@@ -87,7 +93,9 @@ private static DictionaryInterfaceInfo EnsureSubjectIsOfTheExpectedDictionaryTyp
     }
 
     private static void FailWithLengthDifference<TSubjectKey, TSubjectValue, TExpectedKey, TExpectedValue>(
-            IDictionary<TSubjectKey, TSubjectValue> subject, IDictionary<TExpectedKey, TExpectedValue> expectation)
+            IDictionary<TSubjectKey, TSubjectValue> subject,
+            IDictionary<TExpectedKey, TExpectedValue> expectation,
+            AssertionChain assertionChain)
 
         // Type constraint of TExpectedKey is asymmetric in regards to TSubjectKey
         // but it is valid. This constraint is implicitly enforced by the dictionary interface info which is called before
@@ -99,19 +107,18 @@ private static void FailWithLengthDifference<TSubjectKey, TSubjectValue, TExpect
         bool hasMissingKeys = keyDifference.MissingKeys.Count > 0;
         bool hasAdditionalKeys = keyDifference.AdditionalKeys.Count > 0;
 
-        Execute.Assertion
-            .WithExpectation("Expected {context:subject} to be a dictionary with {0} item(s){reason}, ", expectation.Count)
-            .ForCondition(!hasMissingKeys || hasAdditionalKeys)
-            .FailWith("but it misses key(s) {0}", keyDifference.MissingKeys)
-            .Then
-            .ForCondition(hasMissingKeys || !hasAdditionalKeys)
-            .FailWith("but has additional key(s) {0}", keyDifference.AdditionalKeys)
-            .Then
-            .ForCondition(!hasMissingKeys || !hasAdditionalKeys)
-            .FailWith("but it misses key(s) {0} and has additional key(s) {1}", keyDifference.MissingKeys,
-                keyDifference.AdditionalKeys)
-            .Then
-            .ClearExpectation();
+        assertionChain
+            .WithExpectation("Expected {context:subject} to be a dictionary with {0} item(s){reason}, ", expectation.Count,
+                chain => chain
+                    .ForCondition(!hasMissingKeys || hasAdditionalKeys)
+                    .FailWith("but it misses key(s) {0}", keyDifference.MissingKeys)
+                    .Then
+                    .ForCondition(hasMissingKeys || !hasAdditionalKeys)
+                    .FailWith("but has additional key(s) {0}", keyDifference.AdditionalKeys)
+                    .Then
+                    .ForCondition(!hasMissingKeys || !hasAdditionalKeys)
+                    .FailWith("but it misses key(s) {0} and has additional key(s) {1}", keyDifference.MissingKeys,
+                        keyDifference.AdditionalKeys));
     }
 
     private static KeyDifference<TSubjectKey, TExpectedKey> CalculateKeyDifference<TSubjectKey, TSubjectValue, TExpectedKey,
@@ -147,15 +154,18 @@ private static void FailWithLengthDifference<TSubjectKey, TSubjectValue, TExpect
         return new KeyDifference<TSubjectKey, TExpectedKey>(missingKeys, additionalKeys);
     }
 
-    private static void AssertDictionaryEquivalence(Comparands comparands, IEquivalencyValidationContext context,
-        IValidateChildNodeEquivalency parent, DictionaryInterfaceInfo actualDictionary, DictionaryInterfaceInfo expectedDictionary)
+    private static void AssertDictionaryEquivalence(Comparands comparands, AssertionChain assertionChain,
+        IEquivalencyValidationContext context,
+        IValidateChildNodeEquivalency parent, DictionaryInterfaceInfo actualDictionary,
+        DictionaryInterfaceInfo expectedDictionary)
     {
         AssertDictionaryEquivalenceMethod
             .MakeGenericMethod(actualDictionary.Key, actualDictionary.Value, expectedDictionary.Key, expectedDictionary.Value)
-            .Invoke(null, [context, parent, context.Options, comparands.Subject, comparands.Expectation]);
+            .Invoke(null, [assertionChain, context, parent, context.Options, comparands.Subject, comparands.Expectation]);
     }
 
     private static void AssertDictionaryEquivalence<TSubjectKey, TSubjectValue, TExpectedKey, TExpectedValue>(
+        AssertionChain assertionChain,
         EquivalencyValidationContext context,
         IValidateChildNodeEquivalency parent,
         IEquivalencyOptions options,
@@ -165,7 +175,7 @@ private static void AssertDictionaryEquivalence<TSubjectKey, TSubjectValue, TExp
     {
         if (subject.Count != expectation.Count)
         {
-            FailWithLengthDifference(subject, expectation);
+            FailWithLengthDifference(subject, expectation, assertionChain);
         }
         else
         {
@@ -180,18 +190,18 @@ private static void AssertDictionaryEquivalence<TSubjectKey, TSubjectValue, TExp
                         {
                             var nestedComparands = new Comparands(subject[key], expectation[key], typeof(TExpectedValue));
 
-                            parent.AssertEquivalencyOf(nestedComparands,
-                                context.AsDictionaryItem<TExpectedKey, TExpectedValue>(key));
+                            parent.AssertEquivalencyOf(nestedComparands, context.AsDictionaryItem<TExpectedKey, TExpectedValue>(key));
                         }
                     }
                     else
                     {
+                        assertionChain.ReuseOnce();
                         subjectValue.Should().Be(expectation[key], context.Reason.FormattedMessage, context.Reason.Arguments);
                     }
                 }
                 else
                 {
-                    AssertionScope.Current
+                    assertionChain
                         .BecauseOf(context.Reason)
                         .FailWith("Expected {context:subject} to contain key {0}{reason}.", key);
                 }
diff --git a/Src/FluentAssertions/Equivalency/Steps/GenericEnumerableEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/GenericEnumerableEquivalencyStep.cs
index 1ff5fb4148..f7e4e7297f 100644
--- a/Src/FluentAssertions/Equivalency/Steps/GenericEnumerableEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/GenericEnumerableEquivalencyStep.cs
@@ -27,15 +27,17 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
 
         Type[] interfaceTypes = GetIEnumerableInterfaces(expectedType);
 
-        AssertionScope.Current
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        assertionChain
             .ForCondition(interfaceTypes.Length == 1)
             .FailWith(() => new FailReason("{context:Expectation} implements {0}, so cannot determine which one " +
                 "to use for asserting the equivalency of the collection. ",
                 interfaceTypes.Select(type => "IEnumerable<" + type.GetGenericArguments().Single() + ">")));
 
-        if (AssertSubjectIsCollection(comparands.Subject))
+        if (AssertSubjectIsCollection(assertionChain, comparands.Subject))
         {
-            var validator = new EnumerableEquivalencyValidator(valueChildNodes, context)
+            var validator = new EnumerableEquivalencyValidator(assertionChain, valueChildNodes, context)
             {
                 Recursive = context.CurrentNode.IsRoot || context.Options.IsRecursive,
                 OrderingRules = context.Options.OrderingRules
@@ -62,20 +64,20 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
     private static void HandleImpl<T>(EnumerableEquivalencyValidator validator, object[] subject, IEnumerable<T> expectation) =>
         validator.Execute(subject, ToArray(expectation));
 
-    private static bool AssertSubjectIsCollection(object subject)
+    private static bool AssertSubjectIsCollection(AssertionChain assertionChain, object subject)
     {
-        bool conditionMet = AssertionScope.Current
+        assertionChain
             .ForCondition(subject is not null)
             .FailWith("Expected {context:subject} not to be {0}.", new object[] { null });
 
-        if (conditionMet)
+        if (assertionChain.Succeeded)
         {
-            conditionMet = AssertionScope.Current
+            assertionChain
                 .ForCondition(IsCollection(subject.GetType()))
                 .FailWith("Expected {context:subject} to be a collection, but it was a {0}", subject.GetType());
         }
 
-        return conditionMet;
+        return assertionChain.Succeeded;
     }
 
     private static bool IsCollection(Type type)
diff --git a/Src/FluentAssertions/Equivalency/Steps/SimpleEqualityEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/SimpleEqualityEquivalencyStep.cs
index 0e2b955cf4..af3598ec1d 100644
--- a/Src/FluentAssertions/Equivalency/Steps/SimpleEqualityEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/SimpleEqualityEquivalencyStep.cs
@@ -1,3 +1,5 @@
+using FluentAssertions.Execution;
+
 namespace FluentAssertions.Equivalency.Steps;
 
 public class SimpleEqualityEquivalencyStep : IEquivalencyStep
@@ -7,6 +9,10 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
     {
         if (!context.Options.IsRecursive && !context.CurrentNode.IsRoot)
         {
+            AssertionChain.GetOrCreate()
+                .For(context)
+                .ReuseOnce();
+
             comparands.Subject.Should().Be(comparands.Expectation, context.Reason.FormattedMessage, context.Reason.Arguments);
 
             return EquivalencyResult.EquivalencyProven;
diff --git a/Src/FluentAssertions/Equivalency/Steps/StringEqualityEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/StringEqualityEquivalencyStep.cs
index 00a736626c..ec0e70fd24 100644
--- a/Src/FluentAssertions/Equivalency/Steps/StringEqualityEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/StringEqualityEquivalencyStep.cs
@@ -15,21 +15,23 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
-        if (!ValidateAgainstNulls(comparands, context.CurrentNode))
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        if (!ValidateAgainstNulls(assertionChain, comparands, context.CurrentNode))
         {
             return EquivalencyResult.EquivalencyProven;
         }
 
-        bool subjectIsString = ValidateSubjectIsString(comparands, context.CurrentNode);
+        bool subjectIsString = ValidateSubjectIsString(assertionChain, comparands, context.CurrentNode);
 
         if (subjectIsString)
         {
             string subject = (string)comparands.Subject;
             string expectation = (string)comparands.Expectation;
 
+            assertionChain.ReuseOnce();
             subject.Should()
-                .Be(expectation, CreateOptions(context.Options),
-                    context.Reason.FormattedMessage, context.Reason.Arguments);
+                .Be(expectation, CreateOptions(context.Options), context.Reason.FormattedMessage, context.Reason.Arguments);
         }
 
         return EquivalencyResult.EquivalencyProven;
@@ -67,7 +69,7 @@ private static Func<EquivalencyOptions<string>, EquivalencyOptions<string>>
             return o;
         };
 
-    private static bool ValidateAgainstNulls(Comparands comparands, INode currentNode)
+    private static bool ValidateAgainstNulls(AssertionChain assertionChain, Comparands comparands, INode currentNode)
     {
         object expected = comparands.Expectation;
         object subject = comparands.Subject;
@@ -76,7 +78,7 @@ private static bool ValidateAgainstNulls(Comparands comparands, INode currentNod
 
         if (onlyOneNull)
         {
-            AssertionScope.Current.FailWith(
+            assertionChain.FailWith(
                 $"Expected {currentNode.Description} to be {{0}}{{reason}}, but found {{1}}.", expected, subject);
 
             return false;
@@ -85,16 +87,17 @@ private static bool ValidateAgainstNulls(Comparands comparands, INode currentNod
         return true;
     }
 
-    private static bool ValidateSubjectIsString(Comparands comparands, INode currentNode)
+    private static bool ValidateSubjectIsString(AssertionChain assertionChain, Comparands comparands, INode currentNode)
     {
         if (comparands.Subject is string)
         {
             return true;
         }
 
-        return
-            AssertionScope.Current
-                .FailWith($"Expected {currentNode} to be {{0}}, but found {{1}}.",
-                    comparands.RuntimeType, comparands.Subject.GetType());
+        assertionChain.FailWith(
+            $"Expected {currentNode} to be {{0}}, but found {{1}}.",
+            comparands.RuntimeType, comparands.Subject.GetType());
+
+        return assertionChain.Succeeded;
     }
 }
diff --git a/Src/FluentAssertions/Equivalency/Steps/StructuralEqualityEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/StructuralEqualityEquivalencyStep.cs
index 23d022e952..0c43280b73 100644
--- a/Src/FluentAssertions/Equivalency/Steps/StructuralEqualityEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/StructuralEqualityEquivalencyStep.cs
@@ -15,9 +15,11 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
             return EquivalencyResult.ContinueWithNext;
         }
 
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
         if (comparands.Expectation is null)
         {
-            AssertionScope.Current
+            assertionChain
                 .BecauseOf(context.Reason)
                 .FailWith(
                     "Expected {context:subject} to be <null>{reason}, but found {0}.",
@@ -25,7 +27,7 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
         }
         else if (comparands.Subject is null)
         {
-            AssertionScope.Current
+            assertionChain
                 .BecauseOf(context.Reason)
                 .FailWith(
                     "Expected {context:object} to be {0}{reason}, but found {1}.",
@@ -55,7 +57,9 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
     private static void AssertMemberEquality(Comparands comparands, IEquivalencyValidationContext context,
         IValidateChildNodeEquivalency parent, IMember selectedMember, IEquivalencyOptions options)
     {
-        IMember matchingMember = FindMatchFor(selectedMember, context.CurrentNode, comparands.Subject, options);
+        var assertionChain = AssertionChain.GetOrCreate().For(context);
+
+        IMember matchingMember = FindMatchFor(selectedMember, context.CurrentNode, comparands.Subject, options, assertionChain);
 
         if (matchingMember is not null)
         {
@@ -78,11 +82,11 @@ private static void AssertMemberEquality(Comparands comparands, IEquivalencyVali
     }
 
     private static IMember FindMatchFor(IMember selectedMember, INode currentNode, object subject,
-        IEquivalencyOptions config)
+        IEquivalencyOptions config, AssertionChain assertionChain)
     {
         IEnumerable<IMember> query =
             from rule in config.MatchingRules
-            let match = rule.Match(selectedMember, subject, currentNode, config)
+            let match = rule.Match(selectedMember, subject, currentNode, config, assertionChain)
             where match is not null
             select match;
 
diff --git a/Src/FluentAssertions/Equivalency/Steps/ValueTypeEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/ValueTypeEquivalencyStep.cs
index c9270e421b..ee7d1b400d 100644
--- a/Src/FluentAssertions/Equivalency/Steps/ValueTypeEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/ValueTypeEquivalencyStep.cs
@@ -1,4 +1,5 @@
 using System;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Steps;
 
@@ -26,6 +27,10 @@ public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationCon
                 return $"Treating {member.Description} as a value type because {strategyName}.";
             });
 
+            AssertionChain.GetOrCreate()
+                .For(context)
+                .ReuseOnce();
+
             comparands.Subject.Should().Be(comparands.Expectation, context.Reason.FormattedMessage, context.Reason.Arguments);
 
             return EquivalencyResult.EquivalencyProven;
diff --git a/Src/FluentAssertions/Equivalency/Steps/XAttributeEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/XAttributeEquivalencyStep.cs
index 1f960da7b9..c403ed74d9 100644
--- a/Src/FluentAssertions/Equivalency/Steps/XAttributeEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/XAttributeEquivalencyStep.cs
@@ -1,15 +1,19 @@
 using System.Xml.Linq;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Steps;
 
 public class XAttributeEquivalencyStep : EquivalencyStep<XAttribute>
 {
-    protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
-        IValidateChildNodeEquivalency nested)
+    protected override EquivalencyResult OnHandle(Comparands comparands,
+        IEquivalencyValidationContext context,
+        IValidateChildNodeEquivalency nestedValidator)
     {
         var subject = (XAttribute)comparands.Subject;
         var expectation = (XAttribute)comparands.Expectation;
 
+        AssertionChain.GetOrCreate().For(context).ReuseOnce();
+
         subject.Should().Be(expectation, context.Reason.FormattedMessage, context.Reason.Arguments);
 
         return EquivalencyResult.EquivalencyProven;
diff --git a/Src/FluentAssertions/Equivalency/Steps/XDocumentEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/XDocumentEquivalencyStep.cs
index b7556b4788..b88921f45b 100644
--- a/Src/FluentAssertions/Equivalency/Steps/XDocumentEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/XDocumentEquivalencyStep.cs
@@ -1,15 +1,19 @@
 using System.Xml.Linq;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Steps;
 
 public class XDocumentEquivalencyStep : EquivalencyStep<XDocument>
 {
-    protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
-        IValidateChildNodeEquivalency nested)
+    protected override EquivalencyResult OnHandle(Comparands comparands,
+        IEquivalencyValidationContext context,
+        IValidateChildNodeEquivalency nestedValidator)
     {
         var subject = (XDocument)comparands.Subject;
         var expectation = (XDocument)comparands.Expectation;
 
+        AssertionChain.GetOrCreate().For(context).ReuseOnce();
+
         subject.Should().BeEquivalentTo(expectation, context.Reason.FormattedMessage, context.Reason.Arguments);
 
         return EquivalencyResult.EquivalencyProven;
diff --git a/Src/FluentAssertions/Equivalency/Steps/XElementEquivalencyStep.cs b/Src/FluentAssertions/Equivalency/Steps/XElementEquivalencyStep.cs
index 8e01b45938..9ed4e2d503 100644
--- a/Src/FluentAssertions/Equivalency/Steps/XElementEquivalencyStep.cs
+++ b/Src/FluentAssertions/Equivalency/Steps/XElementEquivalencyStep.cs
@@ -1,15 +1,19 @@
 using System.Xml.Linq;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Equivalency.Steps;
 
 public class XElementEquivalencyStep : EquivalencyStep<XElement>
 {
-    protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
-        IValidateChildNodeEquivalency nested)
+    protected override EquivalencyResult OnHandle(Comparands comparands,
+        IEquivalencyValidationContext context,
+        IValidateChildNodeEquivalency nestedValidator)
     {
         var subject = (XElement)comparands.Subject;
         var expectation = (XElement)comparands.Expectation;
 
+        AssertionChain.GetOrCreate().For(context).ReuseOnce();
+
         subject.Should().BeEquivalentTo(expectation, context.Reason.FormattedMessage, context.Reason.Arguments);
 
         return EquivalencyResult.EquivalencyProven;
diff --git a/Src/FluentAssertions/EventRaisingExtensions.cs b/Src/FluentAssertions/EventRaisingExtensions.cs
index 95545d234b..15798cba20 100644
--- a/Src/FluentAssertions/EventRaisingExtensions.cs
+++ b/Src/FluentAssertions/EventRaisingExtensions.cs
@@ -24,15 +24,16 @@ public static IEventRecording WithSender(this IEventRecording eventRecording, ob
     {
         var eventsForSender = new List<OccurredEvent>();
         var otherSenders = new List<object>();
+        var assertion = AssertionChain.GetOrCreate();
 
         foreach (OccurredEvent @event in eventRecording)
         {
-            bool hasSender = Execute.Assertion
+            assertion
                 .ForCondition(@event.Parameters.Length > 0)
                 .FailWith("Expected event from sender {0}, " +
                     $"but event {eventRecording.EventName} does not have any parameters", expectedSender);
 
-            if (hasSender)
+            if (assertion.Succeeded)
             {
                 object sender = @event.Parameters[0];
 
@@ -47,7 +48,7 @@ public static IEventRecording WithSender(this IEventRecording eventRecording, ob
             }
         }
 
-        Execute.Assertion
+        assertion
             .ForCondition(eventsForSender.Count > 0)
             .FailWith("Expected sender {0}, but found {1}.",
                 () => expectedSender,
@@ -84,7 +85,8 @@ public static IEventRecording WithArgs<T>(this IEventRecording eventRecording, E
 
         bool foundMatchingEvent = eventsWithMatchingPredicate.Count > 0;
 
-        Execute.Assertion
+        AssertionChain
+            .GetOrCreate()
             .ForCondition(foundMatchingEvent)
             .FailWith("Expected at least one event with some argument of type <{0}> that matches {1}, but found none.",
                 typeof(T),
@@ -137,7 +139,8 @@ public static IEventRecording WithArgs<T>(this IEventRecording eventRecording, p
 
         if (!foundMatchingEvent)
         {
-            Execute.Assertion
+            AssertionChain
+                .GetOrCreate()
                 .FailWith(
                     "Expected at least one event with some arguments of type <{0}> that pairwise match {1}, but found none.",
                     typeof(T),
diff --git a/Src/FluentAssertions/Events/EventAssertions.cs b/Src/FluentAssertions/Events/EventAssertions.cs
index f7e861deca..6d624bda02 100644
--- a/Src/FluentAssertions/Events/EventAssertions.cs
+++ b/Src/FluentAssertions/Events/EventAssertions.cs
@@ -16,10 +16,12 @@ namespace FluentAssertions.Events;
 public class EventAssertions<T> : ReferenceTypeAssertions<T, EventAssertions<T>>
 {
     private const string PropertyChangedEventName = nameof(INotifyPropertyChanged.PropertyChanged);
+    private readonly AssertionChain assertionChain;
 
-    protected internal EventAssertions(IMonitor<T> monitor)
-        : base(monitor.Subject)
+    protected internal EventAssertions(IMonitor<T> monitor, AssertionChain assertionChain)
+        : base(monitor.Subject, assertionChain)
     {
+        this.assertionChain = assertionChain;
         Monitor = monitor;
     }
 
@@ -47,7 +49,7 @@ public IEventRecording Raise(string eventName, [StringSyntax("CompositeFormat")]
 
         if (!recording.Any())
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected object {0} to raise event {1}{reason}, but it did not.", Monitor.Subject, eventName);
         }
@@ -74,7 +76,7 @@ public void NotRaise(string eventName, [StringSyntax("CompositeFormat")] string
 
         if (events.Any())
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected object {0} to not raise event {1}{reason}, but it did.", Monitor.Subject, eventName);
         }
@@ -104,14 +106,14 @@ public IEventRecording RaisePropertyChangeFor(Expression<Func<T, object>> proper
 
         IEventRecording recording = Monitor.GetRecordingFor(PropertyChangedEventName);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(recording.Any())
             .FailWith(
                 "Expected object {0} to raise event {1} for property {2}{reason}, but it did not raise that event at all.",
                 Monitor.Subject, PropertyChangedEventName, propertyName);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             var actualPropertyNames = recording
                 .SelectMany(@event => @event.Parameters.OfType<PropertyChangedEventArgs>())
@@ -119,7 +121,7 @@ public IEventRecording RaisePropertyChangeFor(Expression<Func<T, object>> proper
                 .Distinct()
                 .ToArray();
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(actualPropertyNames.Contains(propertyName))
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected object {0} to raise event {1} for property {2}{reason}, but it was only raised for {3}.",
@@ -151,7 +153,7 @@ public void NotRaisePropertyChangeFor(Expression<Func<T, object>> propertyExpres
 
         if (propertyName is null)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!recording.Any())
                 .FailWith(
@@ -160,7 +162,7 @@ public void NotRaisePropertyChangeFor(Expression<Func<T, object>> propertyExpres
         }
         else
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!recording.Any(@event => @event.IsAffectingPropertyName(propertyName)))
                 .FailWith(
diff --git a/Src/FluentAssertions/Events/EventMonitor.cs b/Src/FluentAssertions/Events/EventMonitor.cs
index 26ebe0ad29..bcb2efbec6 100644
--- a/Src/FluentAssertions/Events/EventMonitor.cs
+++ b/Src/FluentAssertions/Events/EventMonitor.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Reflection;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Events;
 
@@ -66,7 +67,7 @@ public void Clear()
 
     public EventAssertions<T> Should()
     {
-        return new EventAssertions<T>(this);
+        return new EventAssertions<T>(this, AssertionChain.GetOrCreate());
     }
 
     public IEventRecording GetRecordingFor(string eventName)
diff --git a/Src/FluentAssertions/ExceptionAssertionsExtensions.cs b/Src/FluentAssertions/ExceptionAssertionsExtensions.cs
index 900d1c9b4e..45de65a1a6 100644
--- a/Src/FluentAssertions/ExceptionAssertionsExtensions.cs
+++ b/Src/FluentAssertions/ExceptionAssertionsExtensions.cs
@@ -167,7 +167,8 @@ public static ExceptionAssertions<TException> WithParameterName<TException>(
         params object[] becauseArgs)
         where TException : ArgumentException
     {
-        Execute.Assertion
+        AssertionChain
+            .GetOrCreate()
             .ForCondition(parent.Which.ParamName == paramName)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected exception with parameter name {0}{reason}, but found {1}.", paramName, parent.Which.ParamName);
diff --git a/Src/FluentAssertions/Execution/AssertionChain.cs b/Src/FluentAssertions/Execution/AssertionChain.cs
new file mode 100644
index 0000000000..312034b9e8
--- /dev/null
+++ b/Src/FluentAssertions/Execution/AssertionChain.cs
@@ -0,0 +1,352 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using FluentAssertions.Common;
+
+namespace FluentAssertions.Execution;
+
+public sealed class AssertionChain
+{
+    private readonly Func<AssertionScope> getCurrentScope;
+    private readonly ContextDataDictionary contextData = new();
+    private string fallbackIdentifier = "object";
+    private Func<string> getCallerIdentifier;
+    private Func<string> reason;
+    private bool? succeeded;
+
+    // We need to keep track of this because we don't want the second successful assertion hide the first unsuccessful assertion
+    private Func<string> expectation;
+    private string callerPostfix = string.Empty;
+    private string callerPrefix = string.Empty;
+
+    private static readonly AsyncLocal<AssertionChain> Instance = new();
+
+    /// <summary>
+    /// Ensures that the next call to <see cref="GetOrCreate"/> will reuse the current instance.
+    /// </summary>
+    public void ReuseOnce()
+    {
+        Instance.Value = this;
+    }
+
+    /// <summary>
+    /// Indicates whether the previous assertion in the chain was successful.
+    /// </summary>
+    /// <remarks>
+    /// This property is used internally to determine if subsequent assertions
+    /// should be evaluated based on the result of the previous assertion.
+    /// </remarks>
+    internal bool PreviousAssertionSucceeded { get; private set; } = true;
+
+    /// <summary>
+    /// Indicates whether the caller identifier has been manually overridden.
+    /// </summary>
+    /// <remarks>
+    /// This property is used to track if the caller identifier has been customized using the
+    /// <see cref="OverrideCallerIdentifier"/> method or similar methods that modify the identifier.
+    /// </remarks>
+    public bool HasOverriddenCallerIdentifier { get; private set; }
+
+    /// <summary>
+    /// Either starts a new assertion chain, or, when <see cref="ReuseOnce"/> was called, for once, will return
+    /// an existing instance.
+    /// </summary>
+    public static AssertionChain GetOrCreate()
+    {
+        if (Instance.Value != null)
+        {
+            AssertionChain assertionChain = Instance.Value;
+            Instance.Value = null;
+            return assertionChain;
+        }
+
+        return new AssertionChain(() => AssertionScope.Current,
+            () => FluentAssertions.CallerIdentifier.DetermineCallerIdentity());
+    }
+
+    private AssertionChain(Func<AssertionScope> getCurrentScope, Func<string> getCallerIdentifier)
+    {
+        this.getCurrentScope = getCurrentScope;
+
+        this.getCallerIdentifier = () =>
+        {
+            var scopeName = getCurrentScope().Name();
+            var callerIdentifier = getCallerIdentifier();
+
+            if (scopeName is null)
+            {
+                return callerIdentifier;
+            }
+            else if (callerIdentifier is null)
+            {
+                return scopeName;
+            }
+            else
+            {
+                return $"{scopeName}/{callerIdentifier}";
+            }
+        };
+    }
+
+    /// <summary>
+    /// The effective caller identifier including any prefixes and postfixes configured through
+    /// <see cref="WithCallerPostfix"/> and <see cref="WithCallerPrefix"/>.
+    /// </summary>
+    /// <remarks>
+    /// Can be overridden with <see cref="OverrideCallerIdentifier"/>.
+    /// </remarks>
+    public string CallerIdentifier => callerPrefix + getCallerIdentifier() + callerPostfix;
+
+    /// <summary>
+    /// Adds an explanation of why the assertion is supposed to succeed to the scope.
+    /// </summary>
+    /// <param name="reason">
+    /// An object containing a formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed, as well as zero or more objects to format the placeholders.
+    /// If the phrase does not start with the word <i>because</i>, it is prepended automatically.explaining why the assertion is needed.
+    /// </param>
+    public AssertionChain BecauseOf(Reason reason)
+    {
+        return BecauseOf(reason.FormattedMessage, reason.Arguments);
+    }
+
+    /// <summary>
+    /// Adds an explanation of why the assertion is supposed to succeed to the scope.
+    /// </summary>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+    /// </param>
+    public AssertionChain BecauseOf(string because, params object[] becauseArgs)
+    {
+        reason = () =>
+        {
+            try
+            {
+                string becauseOrEmpty = because ?? string.Empty;
+
+                return becauseArgs?.Length > 0
+                    ? string.Format(CultureInfo.InvariantCulture, becauseOrEmpty, becauseArgs)
+                    : becauseOrEmpty;
+            }
+            catch (FormatException formatException)
+            {
+                return
+                    $"**WARNING** because message '{because}' could not be formatted with string.Format{Environment.NewLine}{formatException.StackTrace}";
+            }
+        };
+
+        return this;
+    }
+
+    public AssertionChain ForCondition(bool condition)
+    {
+        if (PreviousAssertionSucceeded)
+        {
+            succeeded = condition;
+        }
+
+        return this;
+    }
+
+    public AssertionChain ForConstraint(OccurrenceConstraint constraint, int actualOccurrences)
+    {
+        if (PreviousAssertionSucceeded)
+        {
+            constraint.RegisterContextData((key, value) => contextData.Add(
+                new ContextDataDictionary.DataItem(key, value, reportable: false, requiresFormatting: false)));
+
+            succeeded = constraint.Assert(actualOccurrences);
+        }
+
+        return this;
+    }
+
+    public Continuation WithExpectation(string message, object arg1, Action<AssertionChain> chain)
+    {
+        return WithExpectation(message, chain, arg1);
+    }
+
+    public Continuation WithExpectation(string message, object arg1, object arg2, Action<AssertionChain> chain)
+    {
+        return WithExpectation(message, chain, arg1, arg2);
+    }
+
+    public Continuation WithExpectation(string message, Action<AssertionChain> chain)
+    {
+        return WithExpectation(message, chain, []);
+    }
+
+    private Continuation WithExpectation(string message, Action<AssertionChain> chain, params object[] args)
+    {
+        if (PreviousAssertionSucceeded)
+        {
+            expectation = () =>
+            {
+                var formatter = new FailureMessageFormatter(getCurrentScope().FormattingOptions)
+                    .WithReason(reason?.Invoke() ?? string.Empty)
+                    .WithContext(contextData)
+                    .WithIdentifier(CallerIdentifier)
+                    .WithFallbackIdentifier(fallbackIdentifier);
+
+                return formatter.Format(message, args);
+            };
+
+            chain(this);
+
+            expectation = null;
+        }
+
+        return new Continuation(this);
+    }
+
+    public AssertionChain WithDefaultIdentifier(string identifier)
+    {
+        fallbackIdentifier = identifier;
+        return this;
+    }
+
+    public GivenSelector<T> Given<T>(Func<T> selector)
+    {
+        return new GivenSelector<T>(selector, this);
+    }
+
+    internal Continuation FailWithPreFormatted(string formattedFailReason)
+    {
+        return FailWith(() => formattedFailReason);
+    }
+
+    public Continuation FailWith(string message)
+    {
+        return FailWith(() => new FailReason(message));
+    }
+
+    public Continuation FailWith(string message, params object[] args)
+    {
+        return FailWith(() => new FailReason(message, args));
+    }
+
+    public Continuation FailWith(string message, params Func<object>[] argProviders)
+    {
+        return FailWith(
+            () => new FailReason(
+                message,
+                argProviders.Select(a => a()).ToArray()));
+    }
+
+    public Continuation FailWith(Func<FailReason> getFailureReason)
+    {
+        return FailWith(() =>
+        {
+            var formatter = new FailureMessageFormatter(getCurrentScope().FormattingOptions)
+                .WithReason(reason?.Invoke() ?? string.Empty)
+                .WithContext(contextData)
+                .WithIdentifier(CallerIdentifier)
+                .WithFallbackIdentifier(fallbackIdentifier);
+
+            FailReason failReason = getFailureReason();
+
+            return formatter.Format(failReason.Message, failReason.Args);
+        });
+    }
+
+    private Continuation FailWith(Func<string> getFailureReason)
+    {
+        if (PreviousAssertionSucceeded)
+        {
+            PreviousAssertionSucceeded = succeeded is true;
+
+            if (succeeded is not true)
+            {
+                string failure = getFailureReason();
+
+                if (expectation is not null)
+                {
+                    failure = expectation() + failure;
+                }
+
+                getCurrentScope().AddPreFormattedFailure(failure.Capitalize().RemoveTrailingWhitespaceFromLines());
+            }
+        }
+
+        // Reset the state for successive assertions on this object
+        succeeded = null;
+
+        return new Continuation(this);
+    }
+
+    public void OverrideCallerIdentifier(Func<string> getCallerIdentifier)
+    {
+        this.getCallerIdentifier = getCallerIdentifier;
+        HasOverriddenCallerIdentifier = true;
+    }
+
+    public AssertionChain WithCallerPostfix(string postfix)
+    {
+        callerPostfix = postfix;
+        HasOverriddenCallerIdentifier = true;
+
+        return this;
+    }
+
+    public AssertionChain WithCallerPrefix(string prefix)
+    {
+        callerPrefix = prefix;
+        HasOverriddenCallerIdentifier = true;
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds some information to the assertion that will be included in the message
+    /// that is emitted if an assertion fails.
+    /// </summary>
+    public void AddReportable(string key, string value)
+    {
+        getCurrentScope().AddReportable(key, value);
+    }
+
+    /// <summary>
+    /// Adds some information to the assertion that will be included in the message
+    /// that is emitted if an assertion fails. The value is only calculated on failure.
+    /// </summary>
+    public void AddReportable(string key, Func<string> getValue)
+    {
+        getCurrentScope().AddReportable(key, getValue);
+    }
+
+    /// <summary>
+    /// Fluent alternative for <see cref="AddReportable(string,string)"/>
+    /// </summary>
+    public AssertionChain WithReportable(string name, Func<string> content)
+    {
+        getCurrentScope().AddReportable(name, content);
+        return this;
+    }
+
+    /// <summary>
+    /// Registers a failure in the chain that doesn't need any parsing or formatting anymore.
+    /// </summary>
+    internal void AddPreFormattedFailure(string failure)
+    {
+        getCurrentScope().AddPreFormattedFailure(failure);
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether all assertions in the <see cref="AssertionChain"/> have succeeded.
+    /// </summary>
+    public bool Succeeded => PreviousAssertionSucceeded && succeeded is null or true;
+
+    public AssertionChain UsingLineBreaks
+    {
+        get
+        {
+            getCurrentScope().FormattingOptions.UseLineBreaks = true;
+            return this;
+        }
+    }
+}
diff --git a/Src/FluentAssertions/Execution/AssertionScope.cs b/Src/FluentAssertions/Execution/AssertionScope.cs
index 2b70d559c7..a6705b60a6 100644
--- a/Src/FluentAssertions/Execution/AssertionScope.cs
+++ b/Src/FluentAssertions/Execution/AssertionScope.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Linq;
 using System.Text;
 using System.Threading;
@@ -14,60 +11,36 @@ namespace FluentAssertions.Execution;
 /// Represents an implicit or explicit scope within which multiple assertions can be collected.
 /// </summary>
 /// <remarks>
-/// This class is supposed to have a very short lifetime and is not safe to be used in assertions that cross thread-boundaries
+/// This class is supposed to have a very short lifetime and is not safe to be used in assertion that cross thread-boundaries
 /// such as when using <see langword="async"/> or <see langword="await"/>.
 /// </remarks>
-public sealed class AssertionScope : IAssertionScope
+// Remove all assertion logic from this class since it is superseded by the Assertion class
+public sealed class AssertionScope : IDisposable
 {
-    #region Private Definitions
-
     private readonly IAssertionStrategy assertionStrategy;
-    private readonly ContextDataDictionary contextData = new();
+    private static readonly AsyncLocal<AssertionScope> CurrentScope = new();
+    private readonly Func<string> callerIdentityProvider = () => CallerIdentifier.DetermineCallerIdentity();
+    private readonly ContextDataDictionary reportableData = new();
     private readonly StringBuilder tracing = new();
 
-    private Func<string> reason;
-
-    private static readonly AsyncLocal<AssertionScope> CurrentScope = new();
-    private Func<string> callerIdentityProvider = () => CallerIdentifier.DetermineCallerIdentity();
-#pragma warning disable CA2213
     private AssertionScope parent;
-#pragma warning restore CA2213
-    private Func<string> expectation;
-    private string fallbackIdentifier = "object";
-    private bool? succeeded;
-
-    private sealed class DeferredReportable
-    {
-        private readonly Lazy<string> lazyValue;
-
-        public DeferredReportable(Func<string> valueFunc)
-        {
-            lazyValue = new Lazy<string>(valueFunc);
-        }
-
-        public override string ToString() => lazyValue.Value;
-    }
-
-    #endregion
 
     /// <summary>
     /// Starts an unnamed scope within which multiple assertions can be executed
     /// and which will not throw until the scope is disposed.
     /// </summary>
     public AssertionScope()
-        : this(new CollectingAssertionStrategy(), context: null)
+        : this(() => null, new CollectingAssertionStrategy())
     {
-        SetCurrentAssertionScope(this);
     }
 
     /// <summary>
     /// Starts a named scope within which multiple assertions can be executed
     /// and which will not throw until the scope is disposed.
     /// </summary>
-    public AssertionScope(string context)
-        : this(new CollectingAssertionStrategy(), new Lazy<string>(() => context))
+    public AssertionScope(string name)
+        : this(() => name, new CollectingAssertionStrategy())
     {
-        SetCurrentAssertionScope(this);
     }
 
     /// <summary>
@@ -76,19 +49,17 @@ public AssertionScope(string context)
     /// <param name="assertionStrategy">The assertion strategy for this scope.</param>
     /// <exception cref="ArgumentNullException"><paramref name="assertionStrategy"/> is <see langword="null"/>.</exception>
     public AssertionScope(IAssertionStrategy assertionStrategy)
-        : this(assertionStrategy, context: null)
+        : this(() => null, assertionStrategy)
     {
-        SetCurrentAssertionScope(this);
     }
 
     /// <summary>
     /// Starts a named scope within which multiple assertions can be executed
     /// and which will not throw until the scope is disposed.
     /// </summary>
-    public AssertionScope(Lazy<string> context)
-        : this(new CollectingAssertionStrategy(), context)
+    public AssertionScope(Func<string> name)
+        : this(name, new CollectingAssertionStrategy())
     {
-        SetCurrentAssertionScope(this);
     }
 
     /// <summary>
@@ -96,47 +67,52 @@ public AssertionScope(Lazy<string> context)
     /// </summary>
     /// <param name="assertionStrategy">The assertion strategy for this scope.</param>
     /// <exception cref="ArgumentNullException"><paramref name="assertionStrategy"/> is <see langword="null"/>.</exception>
-    private AssertionScope(IAssertionStrategy assertionStrategy, Lazy<string> context)
+    private AssertionScope(Func<string> name, IAssertionStrategy assertionStrategy)
     {
+        parent = CurrentScope.Value;
+        CurrentScope.Value = this;
+
         this.assertionStrategy = assertionStrategy
             ?? throw new ArgumentNullException(nameof(assertionStrategy));
 
-        parent = GetCurrentAssertionScope();
-
         if (parent is not null)
         {
-            contextData.Add(parent.contextData);
-            reason = parent.reason;
+            // Combine the existing Name with the parent.Name if it exists.
+            Name = () =>
+            {
+                var parentName = parent.Name();
+                if (parentName.IsNullOrEmpty())
+                {
+                    return name();
+                }
+                else if (name().IsNullOrEmpty())
+                {
+                    return parentName;
+                }
+                else
+                {
+                    return parentName + "/" + name();
+                }
+            };
+
             callerIdentityProvider = parent.callerIdentityProvider;
             FormattingOptions = parent.FormattingOptions.Clone();
-            Context = JoinContexts(parent.Context, context);
         }
         else
         {
-            Context = context;
+            Name = name;
         }
     }
 
-    private static Lazy<string> JoinContexts(Lazy<string> outer, Lazy<string> inner)
-    {
-        return (outer, inner) switch
-        {
-            (null, null) => null,
-            ({ } a, null) => a,
-            (null, { } b) => b,
-            ({ } a, { } b) => Join(a, b)
-        };
-
-        static Lazy<string> Join(Lazy<string> outer, Lazy<string> inner) =>
-            new(() => outer.Value + "/" + inner.Value);
-    }
-
     /// <summary>
-    /// Gets or sets the context of the current assertion scope, e.g. the path of the object graph
-    /// that is being asserted on. The context is provided by a <see cref="Lazy{String}"/> which
-    /// only gets evaluated when its value is actually needed (in most cases during a failure).
+    /// Gets or sets the name of the current assertion scope, e.g. the path of the object graph
+    /// that is being asserted on.
     /// </summary>
-    public Lazy<string> Context { get; set; }
+    /// <remarks>
+    /// The context is provided by a <see cref="Lazy{String}"/> which
+    /// only gets evaluated when its value is actually needed (in most cases during a failure).
+    /// </remarks>
+    public Func<string> Name { get; }
 
     /// <summary>
     /// Gets the current thread-specific assertion scope.
@@ -146,20 +122,10 @@ public static AssertionScope Current
 #pragma warning disable CA2000 // AssertionScope should not be disposed here
         get
         {
-            return GetCurrentAssertionScope() ?? new AssertionScope(new DefaultAssertionStrategy(), context: null);
+            return CurrentScope.Value ?? new AssertionScope(() => null, new DefaultAssertionStrategy());
         }
 #pragma warning restore CA2000
-        private set => SetCurrentAssertionScope(value);
-    }
-
-    /// <inheritdoc cref="IAssertionScope.UsingLineBreaks"/>
-    public AssertionScope UsingLineBreaks
-    {
-        get
-        {
-            FormattingOptions.UseLineBreaks = true;
-            return this;
-        }
+        private set => CurrentScope.Value = value;
     }
 
     /// <summary>
@@ -167,177 +133,6 @@ public AssertionScope UsingLineBreaks
     /// </summary>
     public FormattingOptions FormattingOptions { get; } = AssertionOptions.FormattingOptions.Clone();
 
-    internal bool Succeeded => succeeded == true;
-
-    /// <summary>
-    /// Adds an explanation of why the assertion is supposed to succeed to the scope.
-    /// </summary>
-    public AssertionScope BecauseOf(Reason reason)
-    {
-        return BecauseOf(reason.FormattedMessage, reason.Arguments);
-    }
-
-    /// <inheritdoc cref="IAssertionScope.BecauseOf(string, object[])"/>
-    public AssertionScope BecauseOf([StringSyntax("CompositeFormat")] string because, params object[] becauseArgs)
-    {
-        reason = () =>
-        {
-            try
-            {
-                string becauseOrEmpty = because ?? string.Empty;
-
-                return becauseArgs?.Length > 0
-                    ? string.Format(CultureInfo.InvariantCulture, becauseOrEmpty, becauseArgs)
-                    : becauseOrEmpty;
-            }
-            catch (FormatException formatException)
-            {
-                return
-                    $"**WARNING** because message '{because}' could not be formatted with string.Format{Environment.NewLine}{formatException.StackTrace}";
-            }
-        };
-
-        return this;
-    }
-
-    /// <inheritdoc cref="IAssertionScope.WithExpectation(string, object[])"/>
-    public AssertionScope WithExpectation(string message, params object[] args)
-    {
-        Func<string> localReason = reason;
-
-        expectation = () =>
-        {
-            var messageBuilder = new MessageBuilder(FormattingOptions);
-            string actualReason = localReason?.Invoke() ?? string.Empty;
-            string identifier = GetIdentifier();
-
-            return messageBuilder.Build(message, args, actualReason, contextData, identifier, fallbackIdentifier);
-        };
-
-        return this;
-    }
-
-    internal void TrackComparands(object subject, object expectation)
-    {
-        contextData.Add(new ContextDataDictionary.DataItem("subject", subject, reportable: false, requiresFormatting: true));
-        contextData.Add(new ContextDataDictionary.DataItem("expectation", expectation, reportable: false, requiresFormatting: true));
-    }
-
-    /// <inheritdoc/>
-    public Continuation ClearExpectation()
-    {
-        expectation = null;
-
-        // SMELL: Isn't this always going to return null? Or this method also called without FailWith (which sets the success state to null)
-        return new Continuation(this, Succeeded);
-    }
-
-    public GivenSelector<T> Given<T>(Func<T> selector)
-    {
-        return new GivenSelector<T>(selector, this, continueAsserting: succeeded != false);
-    }
-
-    /// <inheritdoc cref="IAssertionScope.ForCondition(bool)"/>
-    public AssertionScope ForCondition(bool condition)
-    {
-        succeeded = condition;
-
-        return this;
-    }
-
-    /// <inheritdoc cref="IAssertionScope.ForConstraint(OccurrenceConstraint, int)" />
-    public AssertionScope ForConstraint(OccurrenceConstraint constraint, int actualOccurrences)
-    {
-        constraint.RegisterReportables(this);
-        succeeded = constraint.Assert(actualOccurrences);
-
-        return this;
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(Func<FailReason> failReasonFunc)
-    {
-        return FailWith(() =>
-        {
-            string localReason = reason?.Invoke() ?? string.Empty;
-            var messageBuilder = new MessageBuilder(FormattingOptions);
-            string identifier = GetIdentifier();
-            FailReason failReason = failReasonFunc();
-
-            string result = messageBuilder.Build(failReason.Message, failReason.Args, localReason, contextData, identifier,
-                fallbackIdentifier);
-
-            return result;
-        });
-    }
-
-    internal Continuation FailWithPreFormatted(string formattedFailReason) =>
-        FailWith(() => formattedFailReason);
-
-    private Continuation FailWith(Func<string> failReasonFunc)
-    {
-        try
-        {
-            bool failed = succeeded != true;
-
-            if (failed)
-            {
-                string result = failReasonFunc();
-
-                if (expectation is not null)
-                {
-                    result = expectation() + result;
-                }
-
-                assertionStrategy.HandleFailure(result.Capitalize());
-
-                succeeded = false;
-            }
-
-            return new Continuation(this, continueAsserting: !failed);
-        }
-        finally
-        {
-            succeeded = null;
-        }
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(string message)
-    {
-        return FailWith(() => new FailReason(message));
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(string message, params object[] args)
-    {
-        return FailWith(() => new FailReason(message, args));
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(string message, params Func<object>[] argProviders)
-    {
-        return FailWith(() => new FailReason(message,
-            argProviders.Select(a => a()).ToArray()));
-    }
-
-    private string GetIdentifier()
-    {
-        var identifier = Context?.Value;
-
-        if (string.IsNullOrEmpty(identifier))
-        {
-            identifier = CallerIdentity;
-        }
-
-        return identifier;
-    }
-
-    /// <summary>
-    /// Gets the identity of the caller associated with the current scope.
-    /// </summary>
-    public string CallerIdentity => callerIdentityProvider();
-
     /// <summary>
     /// Adds a pre-formatted failure message to the current scope.
     /// </summary>
@@ -347,38 +142,30 @@ public void AddPreFormattedFailure(string formattedFailureMessage)
     }
 
     /// <summary>
-    /// Adds a block of tracing to the scope for reporting when an assertion fails.
-    /// </summary>
-    public void AppendTracing(string tracingBlock)
-    {
-        tracing.Append(tracingBlock);
-    }
-
-    /// <summary>
-    /// Tracks a keyed object in the current scope that is excluded from the failure message in case an assertion fails.
+    /// Adds some information to the assertion scope that will be included in the message
+    /// that is emitted if an assertion fails.
     /// </summary>
-    public void AddNonReportable(string key, object value)
+    internal void AddReportable(string key, string value)
     {
-        contextData.Add(new ContextDataDictionary.DataItem(key, value, reportable: false, requiresFormatting: false));
+        reportableData.Add(new ContextDataDictionary.DataItem(key, value, reportable: true, requiresFormatting: false));
     }
 
     /// <summary>
     /// Adds some information to the assertion scope that will be included in the message
-    /// that is emitted if an assertion fails.
+    /// that is emitted if an assertion fails. The value is only calculated on failure.
     /// </summary>
-    public void AddReportable(string key, string value)
+    internal void AddReportable(string key, Func<string> valueFunc)
     {
-        contextData.Add(new ContextDataDictionary.DataItem(key, value, reportable: true, requiresFormatting: false));
+        reportableData.Add(new ContextDataDictionary.DataItem(key, new DeferredReportable(valueFunc), reportable: true,
+            requiresFormatting: false));
     }
 
     /// <summary>
-    /// Adds some information to the assertion scope that will be included in the message
-    /// that is emitted if an assertion fails. The value is only calculated on failure.
+    /// Adds a block of tracing to the scope for reporting when an assertion fails.
     /// </summary>
-    public void AddReportable(string key, Func<string> valueFunc)
+    public void AppendTracing(string tracingBlock)
     {
-        contextData.Add(new ContextDataDictionary.DataItem(key, new DeferredReportable(valueFunc), reportable: true,
-            requiresFormatting: false));
+        tracing.Append(tracingBlock);
     }
 
     /// <summary>
@@ -395,18 +182,10 @@ public bool HasFailures()
         return assertionStrategy.FailureMessages.Any();
     }
 
-    /// <summary>
-    /// Gets data associated with the current scope and identified by <paramref name="key"/>.
-    /// </summary>
-    public T Get<T>(string key)
-    {
-        return contextData.Get<T>(key);
-    }
-
     /// <inheritdoc/>
     public void Dispose()
     {
-        SetCurrentAssertionScope(parent);
+        CurrentScope.Value = parent;
 
         if (parent is not null)
         {
@@ -415,67 +194,26 @@ public void Dispose()
                 parent.assertionStrategy.HandleFailure(failureMessage);
             }
 
-            parent.contextData.Add(contextData);
+            parent.reportableData.Add(reportableData);
             parent.AppendTracing(tracing.ToString());
 
             parent = null;
         }
         else
         {
-            IDictionary<string, object> reportable = contextData.GetReportable();
-
             if (tracing.Length > 0)
             {
-                reportable.Add("trace", tracing.ToString());
+                reportableData.Add(new ContextDataDictionary.DataItem("trace", tracing.ToString(), reportable: true, requiresFormatting: false));
             }
 
-            assertionStrategy.ThrowIfAny(reportable);
+            assertionStrategy.ThrowIfAny(reportableData.GetReportable());
         }
     }
 
-    /// <inheritdoc cref="IAssertionScope.WithDefaultIdentifier(string)"/>
-    public AssertionScope WithDefaultIdentifier(string identifier)
+    private sealed class DeferredReportable(Func<string> valueFunc)
     {
-        fallbackIdentifier = identifier;
-        return this;
-    }
-
-    /// <summary>
-    /// Allows the scope to assume that all assertions that happen within this scope are going to
-    /// be initiated by the same caller.
-    /// </summary>
-    public void AssumeSingleCaller()
-    {
-        // Since we know there's only one caller, we don't have to have every assertion determine the caller identity again
-        var provider = new Lazy<string>(() => CallerIdentifier.DetermineCallerIdentity());
-        callerIdentityProvider = () => provider.Value;
-    }
-
-    private static AssertionScope GetCurrentAssertionScope()
-    {
-        return CurrentScope.Value;
-    }
+        private readonly Lazy<string> lazyValue = new(valueFunc);
 
-    private static void SetCurrentAssertionScope(AssertionScope scope)
-    {
-        CurrentScope.Value = scope;
+        public override string ToString() => lazyValue.Value;
     }
-
-    #region Explicit Implementation to support the interface
-
-    IAssertionScope IAssertionScope.ForCondition(bool condition) => ForCondition(condition);
-
-    IAssertionScope IAssertionScope.ForConstraint(OccurrenceConstraint constraint, int actualOccurrences) =>
-        ForConstraint(constraint, actualOccurrences);
-
-    IAssertionScope IAssertionScope.BecauseOf([StringSyntax("CompositeFormat")] string because, params object[] becauseArgs) =>
-        BecauseOf(because, becauseArgs);
-
-    IAssertionScope IAssertionScope.WithExpectation(string message, params object[] args) => WithExpectation(message, args);
-
-    IAssertionScope IAssertionScope.WithDefaultIdentifier(string identifier) => WithDefaultIdentifier(identifier);
-
-    IAssertionScope IAssertionScope.UsingLineBreaks => UsingLineBreaks;
-
-    #endregion
 }
diff --git a/Src/FluentAssertions/Execution/ContextDataDictionary.cs b/Src/FluentAssertions/Execution/ContextDataDictionary.cs
index 8a079f6240..23ebd90548 100644
--- a/Src/FluentAssertions/Execution/ContextDataDictionary.cs
+++ b/Src/FluentAssertions/Execution/ContextDataDictionary.cs
@@ -44,7 +44,6 @@ public void Add(ContextDataDictionary contextDataDictionary)
     public void Add(DataItem item)
     {
         int existingItemIndex = items.FindIndex(i => i.Key == item.Key);
-
         if (existingItemIndex >= 0)
         {
             items[existingItemIndex] = item;
@@ -55,13 +54,7 @@ public void Add(DataItem item)
         }
     }
 
-    public T Get<T>(string key)
-    {
-        DataItem item = items.SingleOrDefault(i => i.Key == key);
-        return (T)(item?.Value ?? default(T));
-    }
-
-    internal class DataItem(string key, object value, bool reportable, bool requiresFormatting)
+    public class DataItem(string key, object value, bool reportable, bool requiresFormatting)
     {
         public string Key { get; } = key;
 
diff --git a/Src/FluentAssertions/Execution/Continuation.cs b/Src/FluentAssertions/Execution/Continuation.cs
index b59ad7f4e7..b2f65e62a3 100644
--- a/Src/FluentAssertions/Execution/Continuation.cs
+++ b/Src/FluentAssertions/Execution/Continuation.cs
@@ -1,35 +1,17 @@
-namespace FluentAssertions.Execution;
+namespace FluentAssertions.Execution;
 
 /// <summary>
 /// Enables chaining multiple assertions on an <see cref="AssertionScope"/>.
 /// </summary>
 public class Continuation
 {
-    private readonly AssertionScope sourceScope;
-    private readonly bool continueAsserting;
-
-    internal Continuation(AssertionScope sourceScope, bool continueAsserting)
+    internal Continuation(AssertionChain parent)
     {
-        this.sourceScope = sourceScope;
-        this.continueAsserting = continueAsserting;
+        Then = parent;
     }
 
     /// <summary>
     /// Continues the assertion chain if the previous assertion was successful.
     /// </summary>
-    public IAssertionScope Then
-    {
-        get
-        {
-            return new ContinuedAssertionScope(sourceScope, continueAsserting);
-        }
-    }
-
-    /// <summary>
-    /// Provides back-wards compatibility for code that expects <see cref="AssertionScope.FailWith(string, object[])"/> to return a boolean.
-    /// </summary>
-    public static implicit operator bool(Continuation continuation)
-    {
-        return continuation.continueAsserting;
-    }
+    public AssertionChain Then { get; }
 }
diff --git a/Src/FluentAssertions/Execution/ContinuationOfGiven.cs b/Src/FluentAssertions/Execution/ContinuationOfGiven.cs
index 47ca54a889..ef42263f3f 100644
--- a/Src/FluentAssertions/Execution/ContinuationOfGiven.cs
+++ b/Src/FluentAssertions/Execution/ContinuationOfGiven.cs
@@ -1,15 +1,12 @@
-namespace FluentAssertions.Execution;
+namespace FluentAssertions.Execution;
 
 /// <summary>
-/// Enables chaining multiple assertions from a <see cref="AssertionScope.Given{T}"/> call.
+/// Enables chaining multiple assertions from a <see cref="AssertionChain.Given{T}"/> call.
 /// </summary>
 public class ContinuationOfGiven<TSubject>
 {
-    private readonly bool succeeded;
-
-    internal ContinuationOfGiven(GivenSelector<TSubject> parent, bool succeeded)
+    internal ContinuationOfGiven(GivenSelector<TSubject> parent)
     {
-        this.succeeded = succeeded;
         Then = parent;
     }
 
@@ -18,11 +15,5 @@ internal ContinuationOfGiven(GivenSelector<TSubject> parent, bool succeeded)
     /// </summary>
     public GivenSelector<TSubject> Then { get; }
 
-    /// <summary>
-    /// Provides back-wards compatibility for code that expects <see cref="AssertionScope.FailWith(string, object[])"/> to return a boolean.
-    /// </summary>
-    public static implicit operator bool(ContinuationOfGiven<TSubject> continuationOfGiven)
-    {
-        return continuationOfGiven.succeeded;
-    }
+    public bool Succeeded => Then.Succeeded;
 }
diff --git a/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs b/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs
deleted file mode 100644
index 1cc2d6dba9..0000000000
--- a/Src/FluentAssertions/Execution/ContinuedAssertionScope.cs
+++ /dev/null
@@ -1,156 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-
-namespace FluentAssertions.Execution;
-
-/// <summary>
-/// Allows chaining multiple assertion scopes together using <see cref="Continuation.Then"/>.
-/// </summary>
-/// <remarks>
-/// If the parent scope has captured a failed assertion,
-/// this class ensures that successive assertions are no longer evaluated.
-/// </remarks>
-public sealed class ContinuedAssertionScope : IAssertionScope
-{
-    private readonly AssertionScope predecessor;
-    private readonly bool continueAsserting;
-
-    internal ContinuedAssertionScope(AssertionScope predecessor, bool continueAsserting)
-    {
-        this.predecessor = predecessor;
-        this.continueAsserting = continueAsserting;
-    }
-
-    /// <inheritdoc/>
-    public GivenSelector<T> Given<T>(Func<T> selector)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.Given(selector);
-        }
-
-        return new GivenSelector<T>(() => default, predecessor, continueAsserting: false);
-    }
-
-    /// <inheritdoc/>
-    public IAssertionScope ForCondition(bool condition)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.ForCondition(condition);
-        }
-
-        return this;
-    }
-
-    /// <inheritdoc />
-    public IAssertionScope ForConstraint(OccurrenceConstraint constraint, int actualOccurrences)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.ForConstraint(constraint, actualOccurrences);
-        }
-
-        return this;
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(string message)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.FailWith(message);
-        }
-
-        return new Continuation(predecessor, continueAsserting: false);
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(string message, params Func<object>[] argProviders)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.FailWith(message, argProviders);
-        }
-
-        return new Continuation(predecessor, continueAsserting: false);
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(Func<FailReason> failReasonFunc)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.FailWith(failReasonFunc);
-        }
-
-        return new Continuation(predecessor, continueAsserting: false);
-    }
-
-    /// <inheritdoc/>
-    public Continuation FailWith(string message, params object[] args)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.FailWith(message, args);
-        }
-
-        return new Continuation(predecessor, continueAsserting: false);
-    }
-
-    /// <inheritdoc/>
-    public IAssertionScope BecauseOf([StringSyntax("CompositeFormat")] string because, params object[] becauseArgs)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.BecauseOf(because, becauseArgs);
-        }
-
-        return this;
-    }
-
-    /// <inheritdoc/>
-    public Continuation ClearExpectation()
-    {
-        predecessor.ClearExpectation();
-
-        return new Continuation(predecessor, continueAsserting);
-    }
-
-    /// <inheritdoc/>
-    public IAssertionScope WithExpectation(string message, params object[] args)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.WithExpectation(message, args);
-        }
-
-        return this;
-    }
-
-    /// <inheritdoc/>
-    public IAssertionScope WithDefaultIdentifier(string identifier)
-    {
-        if (continueAsserting)
-        {
-            return predecessor.WithDefaultIdentifier(identifier);
-        }
-
-        return this;
-    }
-
-    /// <inheritdoc/>
-    public IAssertionScope UsingLineBreaks => predecessor.UsingLineBreaks;
-
-    /// <inheritdoc/>
-    public string[] Discard()
-    {
-        return predecessor.Discard();
-    }
-
-    /// <inheritdoc/>
-    public void Dispose()
-    {
-        predecessor.Dispose();
-    }
-}
diff --git a/Src/FluentAssertions/Execution/Execute.cs b/Src/FluentAssertions/Execution/Execute.cs
deleted file mode 100644
index 9533780cb4..0000000000
--- a/Src/FluentAssertions/Execution/Execute.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using FluentAssertions.Common;
-
-namespace FluentAssertions.Execution;
-
-/// <summary>
-/// Helper class for verifying a condition and/or throwing a test harness specific exception representing an assertion failure.
-/// </summary>
-public static class Execute
-{
-    /// <summary>
-    /// Gets an object that wraps and executes a conditional or unconditional assertion.
-    /// </summary>
-    public static AssertionScope Assertion
-    {
-        get
-        {
-            Services.EnsureInitialized();
-            return AssertionScope.Current;
-        }
-    }
-}
diff --git a/Src/FluentAssertions/Execution/FailReason.cs b/Src/FluentAssertions/Execution/FailReason.cs
index 420f3a2e47..27bab552db 100644
--- a/Src/FluentAssertions/Execution/FailReason.cs
+++ b/Src/FluentAssertions/Execution/FailReason.cs
@@ -1,15 +1,15 @@
 namespace FluentAssertions.Execution;
 
 /// <summary>
-/// Represents assertion fail reason. Contains the message and arguments for message's numbered placeholders.
+/// Represents the assertion fail reason. Contains the message and arguments for message's numbered placeholders.
 /// </summary>
 /// <remarks>
 /// In addition to the numbered <see cref="string.Format(string,object[])"/>-style placeholders, messages may contain a
 /// few specialized placeholders as well. For instance, <em>{reason}</em> will be replaced with the reason of the
-/// assertion as passed to <see cref="AssertionScope.BecauseOf(string, object[])"/>.
+/// assertion as passed to <see cref="AssertionChain.BecauseOf(string, object[])"/>.
 /// <para>
 /// Other named placeholders will be replaced with the <see cref="AssertionScope.Current"/> scope data passed through
-/// <see cref="AssertionScope.AddNonReportable"/> and <see cref="AssertionScope.AddReportable(string,string)"/>.
+/// <see cref="AssertionChain.WithReportable"/>.
 /// </para>
 /// <para>
 /// Finally, a description of the current subject can be passed through the <em>{context:description}</em> placeholder.
diff --git a/Src/FluentAssertions/Execution/MessageBuilder.cs b/Src/FluentAssertions/Execution/FailureMessageFormatter.cs
similarity index 68%
rename from Src/FluentAssertions/Execution/MessageBuilder.cs
rename to Src/FluentAssertions/Execution/FailureMessageFormatter.cs
index 65460111f5..3559ea97b6 100644
--- a/Src/FluentAssertions/Execution/MessageBuilder.cs
+++ b/Src/FluentAssertions/Execution/FailureMessageFormatter.cs
@@ -1,39 +1,87 @@
-#region
-
-using System;
+using System;
 using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using FluentAssertions.Common;
 using FluentAssertions.Formatting;
 
-#endregion
-
 namespace FluentAssertions.Execution;
 
 /// <summary>
 /// Encapsulates expanding the various placeholders supported in a failure message.
 /// </summary>
-internal class MessageBuilder
+internal class FailureMessageFormatter(FormattingOptions formattingOptions)
 {
-    private readonly FormattingOptions formattingOptions;
+    private static readonly char[] Blanks = ['\r', '\n', ' ', '\t'];
+    private string reason;
+    private ContextDataDictionary contextData;
+    private string identifier;
+    private string fallbackIdentifier;
+
+    public FailureMessageFormatter WithReason(string reason)
+    {
+        this.reason = SanitizeReason(reason ?? string.Empty);
+        return this;
+    }
+
+    private static string SanitizeReason(string reason)
+    {
+        if (!string.IsNullOrEmpty(reason))
+        {
+            reason = EnsurePrefix("because", reason);
+            reason = reason.EscapePlaceholders();
+
+            return StartsWithBlank(reason) ? reason : " " + reason;
+        }
 
-    #region Private Definitions
+        return string.Empty;
+    }
+
+    // SMELL: looks way too complex just to retain the leading whitespace
+    private static string EnsurePrefix(string prefix, string text)
+    {
+        string leadingBlanks = ExtractLeadingBlanksFrom(text);
+        string textWithoutLeadingBlanks = text.Substring(leadingBlanks.Length);
+
+        return !textWithoutLeadingBlanks.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)
+            ? leadingBlanks + prefix + " " + textWithoutLeadingBlanks
+            : text;
+    }
+
+    private static string ExtractLeadingBlanksFrom(string text)
+    {
+        string trimmedText = text.TrimStart(Blanks);
+        int leadingBlanksCount = text.Length - trimmedText.Length;
+
+        return text.Substring(0, leadingBlanksCount);
+    }
+
+    private static bool StartsWithBlank(string text)
+    {
+        return text.Length > 0 && Blanks.Contains(text[0]);
+    }
 
-    private readonly char[] blanks = ['\r', '\n', ' ', '\t'];
+    public FailureMessageFormatter WithContext(ContextDataDictionary contextData)
+    {
+        this.contextData = contextData;
+        return this;
+    }
 
-    #endregion
+    public FailureMessageFormatter WithIdentifier(string identifier)
+    {
+        this.identifier = identifier;
+        return this;
+    }
 
-    public MessageBuilder(FormattingOptions formattingOptions)
+    public FailureMessageFormatter WithFallbackIdentifier(string fallbackIdentifier)
     {
-        this.formattingOptions = formattingOptions;
+        this.fallbackIdentifier = fallbackIdentifier;
+        return this;
     }
 
-    // SMELL: Too many parameters.
-    public string Build(string message, object[] messageArgs, string reason, ContextDataDictionary contextData, string identifier,
-        string fallbackIdentifier)
+    public string Format(string message, object[] messageArgs)
     {
-        message = message.Replace("{reason}", SanitizeReason(reason), StringComparison.Ordinal);
+        message = message.Replace("{reason}", reason, StringComparison.Ordinal);
 
         message = SubstituteIdentifier(message, identifier?.EscapePlaceholders(), fallbackIdentifier);
 
@@ -91,7 +139,7 @@ private static string SubstituteContextualTags(string message, ContextDataDictio
 
     private string FormatArgumentPlaceholders(string failureMessage, object[] failureArgs)
     {
-        string[] values = failureArgs.Select(a => Formatter.ToString(a, formattingOptions)).ToArray();
+        object[] values = failureArgs.Select(object (a) => Formatter.ToString(a, formattingOptions)).ToArray();
 
         try
         {
@@ -103,41 +151,4 @@ private string FormatArgumentPlaceholders(string failureMessage, object[] failur
                 $"**WARNING** failure message '{failureMessage}' could not be formatted with string.Format{Environment.NewLine}{formatException.StackTrace}";
         }
     }
-
-    private string SanitizeReason(string reason)
-    {
-        if (!string.IsNullOrEmpty(reason))
-        {
-            reason = EnsurePrefix("because", reason);
-            reason = reason.EscapePlaceholders();
-
-            return StartsWithBlank(reason) ? reason : " " + reason;
-        }
-
-        return string.Empty;
-    }
-
-    // SMELL: looks way too complex just to retain the leading whitespace
-    private string EnsurePrefix(string prefix, string text)
-    {
-        string leadingBlanks = ExtractLeadingBlanksFrom(text);
-        string textWithoutLeadingBlanks = text.Substring(leadingBlanks.Length);
-
-        return !textWithoutLeadingBlanks.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)
-            ? leadingBlanks + prefix + " " + textWithoutLeadingBlanks
-            : text;
-    }
-
-    private string ExtractLeadingBlanksFrom(string text)
-    {
-        string trimmedText = text.TrimStart(blanks);
-        int leadingBlanksCount = text.Length - trimmedText.Length;
-
-        return text.Substring(0, leadingBlanksCount);
-    }
-
-    private bool StartsWithBlank(string text)
-    {
-        return text.Length > 0 && blanks.Contains(text[0]);
-    }
 }
diff --git a/Src/FluentAssertions/Execution/GivenSelector.cs b/Src/FluentAssertions/Execution/GivenSelector.cs
index b2d776fb26..0c2e42798f 100644
--- a/Src/FluentAssertions/Execution/GivenSelector.cs
+++ b/Src/FluentAssertions/Execution/GivenSelector.cs
@@ -1,28 +1,27 @@
-using System;
+using System;
 using System.Linq;
 using FluentAssertions.Common;
 
 namespace FluentAssertions.Execution;
 
 /// <summary>
-/// Represents a chaining object returned from <see cref="AssertionScope.Given{T}"/> to continue the assertion using
+/// Represents a chaining object returned from <see cref="AssertionChain"/> to continue the assertion using
 /// an object returned by a selector.
 /// </summary>
 public class GivenSelector<T>
 {
-    private readonly AssertionScope predecessor;
-    private readonly T subject;
+    private readonly AssertionChain assertionChain;
+    private readonly T selector;
 
-    private bool continueAsserting;
-
-    internal GivenSelector(Func<T> selector, AssertionScope predecessor, bool continueAsserting)
+    internal GivenSelector(Func<T> selector, AssertionChain assertionChain)
     {
-        this.predecessor = predecessor;
-        this.continueAsserting = continueAsserting;
+        this.assertionChain = assertionChain;
 
-        subject = continueAsserting ? selector() : default;
+        this.selector = assertionChain.Succeeded ? selector() : default;
     }
 
+    public bool Succeeded => assertionChain.Succeeded;
+
     /// <summary>
     /// Specify the condition that must be satisfied upon the subject selected through a prior selector.
     /// </summary>
@@ -31,78 +30,47 @@ internal GivenSelector(Func<T> selector, AssertionScope predecessor, bool contin
     /// </param>
     /// <remarks>
     /// The condition will not be evaluated if the prior assertion failed,
-    /// nor will <see cref="FailWith(string, Func{T, object}[])"/> throw any exceptions.
+    /// nor will <see cref="FailWith(string,System.Func{T,object}[])"/> throw any exceptions.
     /// </remarks>
     /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public GivenSelector<T> ForCondition(Func<T, bool> predicate)
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        if (continueAsserting)
+        if (assertionChain.Succeeded)
         {
-            predecessor.ForCondition(predicate(subject));
+            assertionChain.ForCondition(predicate(selector));
         }
 
         return this;
     }
 
-    /// <remarks>
-    /// The <paramref name="selector"/> will not be invoked if the prior assertion failed,
-    /// nor will <see cref="FailWith(string, Func{T,object}[])"/> throw any exceptions.
-    /// </remarks>
-    /// <inheritdoc cref="IAssertionScope.Given{T}"/>
-    /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
     public GivenSelector<TOut> Given<TOut>(Func<T, TOut> selector)
     {
         Guard.ThrowIfArgumentIsNull(selector);
 
-        return new GivenSelector<TOut>(() => selector(subject), predecessor, continueAsserting);
+        return new GivenSelector<TOut>(() => selector(this.selector), assertionChain);
     }
 
-    /// <inheritdoc cref="IAssertionScope.FailWith(string)"/>
     public ContinuationOfGiven<T> FailWith(string message)
     {
         return FailWith(message, Array.Empty<object>());
     }
 
-    /// <remarks>
-    /// <inheritdoc cref="IAssertionScope.FailWith(string, object[])"/>
-    /// The <paramref name="args"/> will not be invoked if the prior assertion failed,
-    /// nor will <see cref="FailWith(string, Func{T,object}[])"/> throw any exceptions.
-    /// </remarks>
-    /// <inheritdoc cref="IAssertionScope.FailWith(string, object[])"/>
     public ContinuationOfGiven<T> FailWith(string message, params Func<T, object>[] args)
     {
-        if (continueAsserting)
+        if (assertionChain.PreviousAssertionSucceeded)
         {
-            object[] mappedArguments = args.Select(a => a(subject)).ToArray();
+            object[] mappedArguments = args.Select(a => a(selector)).ToArray();
             return FailWith(message, mappedArguments);
         }
 
-        return new ContinuationOfGiven<T>(this, succeeded: false);
+        return new ContinuationOfGiven<T>(this);
     }
 
-    /// <remarks>
-    /// <inheritdoc cref="IAssertionScope.FailWith(string, object[])"/>
-    /// The <paramref name="args"/> will not be invoked if the prior assertion failed,
-    /// nor will <see cref="FailWith(string, object[])"/> throw any exceptions.
-    /// </remarks>
-    /// <inheritdoc cref="IAssertionScope.FailWith(string, object[])"/>
     public ContinuationOfGiven<T> FailWith(string message, params object[] args)
     {
-        if (continueAsserting)
-        {
-            continueAsserting = predecessor.FailWith(message, args);
-            return new ContinuationOfGiven<T>(this, continueAsserting);
-        }
-
-        return new ContinuationOfGiven<T>(this, succeeded: false);
-    }
-
-    /// <inheritdoc cref="IAssertionScope.ClearExpectation()"/>
-    public ContinuationOfGiven<T> ClearExpectation()
-    {
-        predecessor.ClearExpectation();
-        return new ContinuationOfGiven<T>(this, continueAsserting);
+        assertionChain.FailWith(message, args);
+        return new ContinuationOfGiven<T>(this);
     }
 }
diff --git a/Src/FluentAssertions/Execution/IAssertionScope.cs b/Src/FluentAssertions/Execution/IAssertionScope.cs
deleted file mode 100644
index d114564ac5..0000000000
--- a/Src/FluentAssertions/Execution/IAssertionScope.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-
-namespace FluentAssertions.Execution;
-
-public interface IAssertionScope : IDisposable
-{
-    /// <summary>
-    /// Allows to safely select the subject for successive assertions.
-    /// </summary>
-    /// <paramref name="selector">
-    /// Selector which result is passed to successive calls to <see cref="ForCondition"/>.
-    /// </paramref>
-    GivenSelector<T> Given<T>(Func<T> selector);
-
-    /// <summary>
-    /// Specify the condition that must be satisfied.
-    /// </summary>
-    /// <param name="condition">
-    /// If <see langword="true"/> the assertion will be treated as successful and no exceptions will be thrown.
-    /// </param>
-    IAssertionScope ForCondition(bool condition);
-
-    /// <summary>
-    /// Makes assertion fail when <paramref name="actualOccurrences"/> does not match <paramref name="constraint"/>.
-    /// <para>
-    /// The occurrence description in natural language could then be inserted in failure message by using
-    /// <em>{expectedOccurrence}</em> placeholder in message parameters of <see cref="FailWith(string, object[])"/> and its
-    /// overloaded versions.
-    /// </para>
-    /// </summary>
-    /// <param name="constraint"><see cref="OccurrenceConstraint"/> defining the number of expected occurrences.</param>
-    /// <param name="actualOccurrences">The number of actual occurrences.</param>
-    IAssertionScope ForConstraint(OccurrenceConstraint constraint, int actualOccurrences);
-
-    /// <summary>
-    /// Sets the failure message when the assertion is not met, or completes the failure message set to a prior call to
-    /// <see cref="AssertionScope.WithExpectation"/>.
-    /// </summary>
-    /// <remarks>
-    /// Messages may contain a few specialized placeholders. For instance, <em>{reason}</em> will be replaced with the reason
-    /// of the assertion as passed to <see cref="AssertionScope.BecauseOf(string, object[])"/>.
-    /// <para>
-    /// Other named placeholders will be replaced with the <see cref="AssertionScope.Current"/> scope data passed through
-    /// <see cref="AssertionScope.AddNonReportable"/> and <see cref="AssertionScope.AddReportable(string,string)"/>.
-    /// </para>
-    /// <para>
-    /// Finally, a description of the current subject can be passed through the <em>{context:description}</em> placeholder.
-    /// This is used in the message if no explicit context is specified through the <see cref="AssertionScope"/> constructor.
-    /// </para>
-    /// <para>
-    /// If an expectation was set through a prior call to <see cref="AssertionScope.WithExpectation"/>, then the failure
-    /// message is appended to that expectation.
-    /// </para>
-    /// </remarks>
-    /// <param name="message">The format string that represents the failure message.</param>
-    Continuation FailWith(string message);
-
-    /// <summary>
-    /// Sets the failure message when the assertion is not met, or completes the failure message set to a prior call to
-    /// <see cref="AssertionScope.WithExpectation"/>.
-    /// <paramref name="failReasonFunc"/> will not be called unless the assertion is not met.
-    /// </summary>
-    /// <param name="failReasonFunc">Function returning <see cref="FailReason"/> object on demand. Called only when the assertion is not met.</param>
-    Continuation FailWith(Func<FailReason> failReasonFunc);
-
-    /// <summary>
-    /// Sets the failure message when the assertion is not met, or completes the failure message set to a prior call to
-    /// <see cref="AssertionScope.WithExpectation"/>.
-    /// </summary>
-    /// <remarks>
-    /// In addition to the numbered <see cref="string.Format(string,object[])"/>-style placeholders, messages may contain a
-    /// few specialized placeholders as well. For instance, <em>{reason}</em> will be replaced with the reason of the
-    /// assertion as passed to <see cref="AssertionScope.BecauseOf(string, object[])"/>.
-    /// <para>
-    /// Other named placeholders will be replaced with the <see cref="AssertionScope.Current"/> scope data passed through
-    /// <see cref="AssertionScope.AddNonReportable"/> and <see cref="AssertionScope.AddReportable(string, string)"/>.
-    /// </para>
-    /// <para>
-    /// Finally, a description of the current subject can be passed through the <em>{context:description}</em> placeholder.
-    /// This is used in the message if no explicit context is specified through the <see cref="AssertionScope"/> constructor.
-    /// </para>
-    /// <para>
-    /// Note that only 10 <paramref name="args"/> are supported in combination with a <em>{reason}</em>.
-    /// </para>
-    /// <para>
-    /// If an expectation was set through a prior call to <see cref="AssertionScope.WithExpectation"/>, then the failure
-    /// message is appended to that expectation.
-    /// </para>
-    /// </remarks>
-    /// <param name="message">The format string that represents the failure message.</param>
-    /// <param name="args">Optional arguments to any numbered placeholders.</param>
-    Continuation FailWith(string message, params object[] args);
-
-    /// <summary>
-    /// Sets the failure message when the assertion is not met, or completes the failure message set to a prior call to
-    /// <see cref="AssertionScope.WithExpectation"/>,
-    /// but postpones evaluation of the formatting arguments until the assertion really fails.
-    /// </summary>
-    /// <remarks>
-    /// In addition to the numbered <see cref="string.Format(string,object[])"/>-style placeholders, messages may contain a
-    /// few specialized placeholders as well. For instance, <em>{reason}</em> will be replaced with the reason of the
-    /// assertion as passed to <see cref="AssertionScope.BecauseOf(string, object[])"/>.
-    /// <para>
-    /// Other named placeholders will be replaced with the <see cref="AssertionScope.Current"/> scope data passed through
-    /// <see cref="AssertionScope.AddNonReportable"/> and <see cref="AssertionScope.AddReportable(string,string)"/>.
-    /// </para>
-    /// <para>
-    /// Finally, a description of the current subject can be passed through the <em>{context:description}</em> placeholder.
-    /// This is used in the message if no explicit context is specified through the <see cref="AssertionScope"/> constructor.
-    /// </para>
-    /// <para>
-    /// Note that only 10 <paramref name="argProviders"/> are supported in combination with a <em>{reason}</em>.
-    /// </para>
-    /// <para>
-    /// If an expectation was set through a prior call to <see cref="AssertionScope.WithExpectation"/>, then the failure
-    /// message is appended to that expectation.
-    /// </para>
-    /// </remarks>
-    /// <param name="message">The format string that represents the failure message.</param>
-    /// <param name="argProviders">Optional lazily evaluated arguments to any numbered placeholders</param>
-    public Continuation FailWith(string message, params Func<object>[] argProviders);
-
-    /// <summary>
-    /// Specify the reason why you expect the condition to be <see langword="true"/>.
-    /// </summary>
-    /// <param name="because">
-    /// A formatted phrase compatible with <see cref="string.Format(string,object[])"/> explaining why the condition should
-    /// be satisfied. If the phrase does not start with the word <em>because</em>, it is prepended to the message.
-    /// <para>
-    /// If the format of <paramref name="because"/> or <paramref name="becauseArgs"/> is not compatible with
-    /// <see cref="string.Format(string,object[])"/>, then a warning message is returned instead.
-    /// </para>
-    /// </param>
-    /// <param name="becauseArgs">
-    /// Zero or more values to use for filling in any <see cref="string.Format(string,object[])"/> compatible placeholders.
-    /// </param>
-    IAssertionScope BecauseOf([StringSyntax("CompositeFormat")] string because, params object[] becauseArgs);
-
-    /// <summary>
-    /// Clears the expectation set by <see cref="WithExpectation"/>.
-    /// </summary>
-    // SMELL: It would be better to give the expectation an explicit scope, but that would be a breaking change.
-    Continuation ClearExpectation();
-
-    /// <summary>
-    /// Sets the expectation part of the failure message when the assertion is not met.
-    /// </summary>
-    /// <remarks>
-    /// In addition to the numbered <see cref="string.Format(string,object[])"/>-style placeholders, messages may contain a
-    /// few specialized placeholders as well. For instance, <em>{reason}</em> will be replaced with the reason of the
-    /// assertion as passed to <see cref="AssertionScope.BecauseOf(string, object[])"/>.
-    /// <para>
-    /// Other named placeholders will be replaced with the <see cref="AssertionScope.Current"/> scope data passed through
-    /// <see cref="AssertionScope.AddNonReportable"/> and <see cref="AssertionScope.AddReportable(string,string)"/>.
-    /// </para>
-    /// <para>
-    /// Finally, a description of the current subject can be passed through the <em>{context:description}</em> placeholder.
-    /// This is used in the message if no explicit context is specified through the <see cref="AssertionScope"/> constructor.
-    /// </para>
-    /// <para>
-    /// Note that only 10 <paramref name="args"/> are supported in combination with a <em>{reason}</em>.
-    /// </para>
-    /// </remarks>
-    /// <param name="message">The format string that represents the failure message.</param>
-    /// <param name="args">Optional arguments to any numbered placeholders.</param>
-    IAssertionScope WithExpectation(string message, params object[] args);
-
-    /// <summary>
-    /// Defines the name of the subject in case this cannot be extracted from the source code.
-    /// </summary>
-    IAssertionScope WithDefaultIdentifier(string identifier);
-
-    /// <summary>
-    /// Forces the formatters, that support it, to add the necessary line breaks.
-    /// </summary>
-    /// <remarks>
-    /// This is just shorthand for modifying the <see cref="AssertionScope.FormattingOptions"/> property.
-    /// </remarks>
-    IAssertionScope UsingLineBreaks { get; }
-
-    /// <summary>
-    /// Discards and returns the failures that happened up to now.
-    /// </summary>
-    string[] Discard();
-}
diff --git a/Src/FluentAssertions/Formatting/FormattedObjectGraph.cs b/Src/FluentAssertions/Formatting/FormattedObjectGraph.cs
index 3f5ba3550e..e86f2185b4 100644
--- a/Src/FluentAssertions/Formatting/FormattedObjectGraph.cs
+++ b/Src/FluentAssertions/Formatting/FormattedObjectGraph.cs
@@ -15,13 +15,19 @@ namespace FluentAssertions.Formatting;
 /// to the maximum number of lines provided through its constructor. It will throw
 /// a <see cref="MaxLinesExceededException"/> if the number of lines exceeds the maximum.
 /// </remarks>
-public class FormattedObjectGraph(int maxLines)
+public class FormattedObjectGraph
 {
+    private readonly int maxLines;
     private readonly List<string> lines = [];
     private readonly StringBuilder lineBuilder = new();
     private int indentation;
     private string lineBuilderWhitespace = string.Empty;
 
+    public FormattedObjectGraph(int maxLines)
+    {
+        this.maxLines = maxLines;
+    }
+
     /// <summary>
     /// The number of spaces that should be used by every indentation level.
     /// </summary>
@@ -93,13 +99,14 @@ private void InsertInitialNewLine()
 
     private void FlushCurrentLine()
     {
-        if (lineBuilder.Length > 0)
+        string line = lineBuilder.ToString().TrimEnd();
+        if (line.Length > 0)
         {
-            AppendWithoutExceedingMaximumLines($"{lineBuilderWhitespace}{lineBuilder}");
-
-            lineBuilder.Clear();
-            lineBuilderWhitespace = Whitespace;
+            AppendWithoutExceedingMaximumLines(lineBuilderWhitespace + line);
         }
+
+        lineBuilder.Clear();
+        lineBuilderWhitespace = Whitespace;
     }
 
     private void AppendWithoutExceedingMaximumLines(string line)
diff --git a/Src/FluentAssertions/Formatting/Formatter.cs b/Src/FluentAssertions/Formatting/Formatter.cs
index d61ea84f9f..4ac3f13bfd 100644
--- a/Src/FluentAssertions/Formatting/Formatter.cs
+++ b/Src/FluentAssertions/Formatting/Formatter.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using FluentAssertions.Common;
-using FluentAssertions.Equivalency;
 using FluentAssertions.Equivalency.Execution;
 using FluentAssertions.Execution;
 using FluentAssertions.Xml;
@@ -27,6 +26,7 @@ public static class Formatter
         new XElementValueFormatter(),
         new XAttributeValueFormatter(),
         new PropertyInfoFormatter(),
+        new MethodInfoFormatter(),
         new NullValueFormatter(),
         new GuidValueFormatter(),
         new DateTimeOffsetValueFormatter(),
@@ -214,7 +214,7 @@ public bool TryPush(string path, object value)
 
             string fullPath = GetFullPath();
             var reference = new ObjectReference(value, fullPath);
-            return !tracker.IsCyclicReference(reference, CyclicReferenceHandling.Ignore);
+            return !tracker.IsCyclicReference(reference);
         }
 
         private string GetFullPath() => string.Join(".", pathStack.Reverse());
diff --git a/Src/FluentAssertions/Formatting/MethodInfoFormatter.cs b/Src/FluentAssertions/Formatting/MethodInfoFormatter.cs
new file mode 100644
index 0000000000..6e40cfdf8e
--- /dev/null
+++ b/Src/FluentAssertions/Formatting/MethodInfoFormatter.cs
@@ -0,0 +1,40 @@
+using System.Reflection;
+
+namespace FluentAssertions.Formatting;
+
+public class MethodInfoFormatter : IValueFormatter
+{
+    /// <summary>
+    /// Indicates whether the current <see cref="IValueFormatter"/> can handle the specified <paramref name="value"/>.
+    /// </summary>
+    /// <param name="value">The value for which to create a <see cref="string"/>.</param>
+    /// <returns>
+    /// <see langword="true"/> if the current <see cref="IValueFormatter"/> can handle the specified value; otherwise, <see langword="false"/>.
+    /// </returns>
+    public bool CanHandle(object value)
+    {
+        return value is MethodInfo;
+    }
+
+    public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
+    {
+        var method = (MethodInfo)value;
+        if (method is null)
+        {
+            formattedGraph.AddFragment("<null>");
+        }
+        else if (method.IsSpecialName && method.Name == "op_Implicit")
+        {
+            formattedGraph.AddFragment($"implicit operator {method.ReturnType.Name}({method.GetParameters()[0].ParameterType.Name})");
+        }
+        else if (method.IsSpecialName && method.Name == "op_Explicit")
+        {
+            formattedGraph.AddFragment(
+                $"explicit operator {method.ReturnType.Name}({method.GetParameters()[0].ParameterType.Name})");
+        }
+        else
+        {
+            formattedGraph.AddFragment($"{method!.DeclaringType!.Name + "." + method.Name}");
+        }
+    }
+}
diff --git a/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs b/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs
index c9746c2901..4ec7de86e0 100644
--- a/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs
+++ b/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs
@@ -18,6 +18,13 @@ public bool CanHandle(object value)
 
     public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
     {
-        formattedGraph.AddFragment(((PropertyInfo)value).Name);
+        if (value is not PropertyInfo property)
+        {
+            formattedGraph.AddFragment("<null>");
+        }
+        else
+        {
+            formattedGraph.AddFragment($"{property.DeclaringType?.Name ?? string.Empty}.{property.Name}");
+        }
     }
 }
diff --git a/Src/FluentAssertions/Numeric/ByteAssertions.cs b/Src/FluentAssertions/Numeric/ByteAssertions.cs
index 6467e86f5d..ccd7399bcf 100644
--- a/Src/FluentAssertions/Numeric/ByteAssertions.cs
+++ b/Src/FluentAssertions/Numeric/ByteAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class ByteAssertions : NumericAssertions<byte>
 {
-    internal ByteAssertions(byte value)
-        : base(value)
+    internal ByteAssertions(byte value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/ComparableTypeAssertions.cs b/Src/FluentAssertions/Numeric/ComparableTypeAssertions.cs
index 805812df65..3a40a75be1 100644
--- a/Src/FluentAssertions/Numeric/ComparableTypeAssertions.cs
+++ b/Src/FluentAssertions/Numeric/ComparableTypeAssertions.cs
@@ -16,8 +16,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 public class ComparableTypeAssertions<T> : ComparableTypeAssertions<T, ComparableTypeAssertions<T>>
 {
-    public ComparableTypeAssertions(IComparable<T> value)
-        : base(value)
+    public ComparableTypeAssertions(IComparable<T> value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -30,10 +30,12 @@ public class ComparableTypeAssertions<T, TAssertions> : ReferenceTypeAssertions<
     where TAssertions : ComparableTypeAssertions<T, TAssertions>
 {
     private const int Equal = 0;
+    private readonly AssertionChain assertionChain;
 
-    public ComparableTypeAssertions(IComparable<T> value)
-        : base(value)
+    public ComparableTypeAssertions(IComparable<T> value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -51,7 +53,7 @@ public ComparableTypeAssertions(IComparable<T> value)
     /// </param>
     public AndConstraint<TAssertions> Be(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Equals(Subject, expected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to be equal to {0}{reason}, but found {1}.", expected, Subject);
@@ -112,7 +114,7 @@ public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expe
         EquivalencyOptions<TExpectation> options = config(AssertionOptions.CloneDefaults<TExpectation>());
 
         var context = new EquivalencyValidationContext(
-            Node.From<TExpectation>(() => AssertionScope.Current.CallerIdentity), options)
+            Node.From<TExpectation>(() => CurrentAssertionChain.CallerIdentifier), options)
         {
             Reason = new Reason(because, becauseArgs),
             TraceWriter = options.TraceWriter
@@ -145,7 +147,7 @@ public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expe
     /// </param>
     public AndConstraint<TAssertions> NotBe(T unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Equals(Subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:object} to be equal to {0}{reason}.", unexpected);
@@ -169,7 +171,7 @@ public AndConstraint<TAssertions> NotBe(T unexpected, [StringSyntax("CompositeFo
     /// </param>
     public AndConstraint<TAssertions> BeRankedEquallyTo(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(expected) == Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} {0} to be ranked as equal to {1}{reason}.", Subject, expected);
@@ -193,7 +195,7 @@ public AndConstraint<TAssertions> BeRankedEquallyTo(T expected, [StringSyntax("C
     /// </param>
     public AndConstraint<TAssertions> NotBeRankedEquallyTo(T unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(unexpected) != Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} {0} not to be ranked as equal to {1}{reason}.", Subject, unexpected);
@@ -216,7 +218,7 @@ public AndConstraint<TAssertions> NotBeRankedEquallyTo(T unexpected, [StringSynt
     /// </param>
     public AndConstraint<TAssertions> BeLessThan(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(expected) < Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} {0} to be less than {1}{reason}.", Subject, expected);
@@ -239,7 +241,7 @@ public AndConstraint<TAssertions> BeLessThan(T expected, [StringSyntax("Composit
     /// </param>
     public AndConstraint<TAssertions> BeLessThanOrEqualTo(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(expected) <= Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} {0} to be less than or equal to {1}{reason}.", Subject, expected);
@@ -262,7 +264,7 @@ public AndConstraint<TAssertions> BeLessThanOrEqualTo(T expected, [StringSyntax(
     /// </param>
     public AndConstraint<TAssertions> BeGreaterThan(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(expected) > Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} {0} to be greater than {1}{reason}.", Subject, expected);
@@ -285,7 +287,7 @@ public AndConstraint<TAssertions> BeGreaterThan(T expected, [StringSyntax("Compo
     /// </param>
     public AndConstraint<TAssertions> BeGreaterThanOrEqualTo(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(expected) >= Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} {0} to be greater than or equal to {1}{reason}.", Subject, expected);
@@ -315,7 +317,7 @@ public AndConstraint<TAssertions> BeGreaterThanOrEqualTo(T expected, [StringSynt
     public AndConstraint<TAssertions> BeInRange(T minimumValue, T maximumValue,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.CompareTo(minimumValue) >= Equal && Subject.CompareTo(maximumValue) <= Equal)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to be between {0} and {1}{reason}, but found {2}.",
@@ -346,7 +348,7 @@ public AndConstraint<TAssertions> BeInRange(T minimumValue, T maximumValue,
     public AndConstraint<TAssertions> NotBeInRange(T minimumValue, T maximumValue,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!(Subject.CompareTo(minimumValue) >= Equal && Subject.CompareTo(maximumValue) <= Equal))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to not be between {0} and {1}{reason}, but found {2}.",
@@ -382,7 +384,7 @@ public AndConstraint<TAssertions> BeOneOf(params T[] validValues)
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<T> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Any(val => Equals(Subject, val)))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to be one of {0}{reason}, but found {1}.", validValues, Subject);
diff --git a/Src/FluentAssertions/Numeric/DecimalAssertions.cs b/Src/FluentAssertions/Numeric/DecimalAssertions.cs
index 0b0d91bf00..aa31679f46 100644
--- a/Src/FluentAssertions/Numeric/DecimalAssertions.cs
+++ b/Src/FluentAssertions/Numeric/DecimalAssertions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -10,8 +11,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class DecimalAssertions : NumericAssertions<decimal>
 {
-    internal DecimalAssertions(decimal value)
-        : base(value)
+    internal DecimalAssertions(decimal value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/DoubleAssertions.cs b/Src/FluentAssertions/Numeric/DoubleAssertions.cs
index d8395924b5..0596191408 100644
--- a/Src/FluentAssertions/Numeric/DoubleAssertions.cs
+++ b/Src/FluentAssertions/Numeric/DoubleAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class DoubleAssertions : NumericAssertions<double>
 {
-    internal DoubleAssertions(double value)
-        : base(value)
+    internal DoubleAssertions(double value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/Int16Assertions.cs b/Src/FluentAssertions/Numeric/Int16Assertions.cs
index d4391d4115..7d7b9c2102 100644
--- a/Src/FluentAssertions/Numeric/Int16Assertions.cs
+++ b/Src/FluentAssertions/Numeric/Int16Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class Int16Assertions : NumericAssertions<short>
 {
-    internal Int16Assertions(short value)
-        : base(value)
+    internal Int16Assertions(short value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/Int32Assertions.cs b/Src/FluentAssertions/Numeric/Int32Assertions.cs
index 44baf64bd6..cfcb25f472 100644
--- a/Src/FluentAssertions/Numeric/Int32Assertions.cs
+++ b/Src/FluentAssertions/Numeric/Int32Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class Int32Assertions : NumericAssertions<int>
 {
-    internal Int32Assertions(int value)
-        : base(value)
+    internal Int32Assertions(int value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/Int64Assertions.cs b/Src/FluentAssertions/Numeric/Int64Assertions.cs
index b3f4cd8650..c733dd294e 100644
--- a/Src/FluentAssertions/Numeric/Int64Assertions.cs
+++ b/Src/FluentAssertions/Numeric/Int64Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class Int64Assertions : NumericAssertions<long>
 {
-    internal Int64Assertions(long value)
-        : base(value)
+    internal Int64Assertions(long value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableByteAssertions.cs b/Src/FluentAssertions/Numeric/NullableByteAssertions.cs
index 42001910fc..9fa6a4c4f0 100644
--- a/Src/FluentAssertions/Numeric/NullableByteAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableByteAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableByteAssertions : NullableNumericAssertions<byte>
 {
-    internal NullableByteAssertions(byte? value)
-        : base(value)
+    internal NullableByteAssertions(byte? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableDecimalAssertions.cs b/Src/FluentAssertions/Numeric/NullableDecimalAssertions.cs
index 3a2897eb16..d5b27880c6 100644
--- a/Src/FluentAssertions/Numeric/NullableDecimalAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableDecimalAssertions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -10,8 +11,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableDecimalAssertions : NullableNumericAssertions<decimal>
 {
-    internal NullableDecimalAssertions(decimal? value)
-        : base(value)
+    internal NullableDecimalAssertions(decimal? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableDoubleAssertions.cs b/Src/FluentAssertions/Numeric/NullableDoubleAssertions.cs
index 62c2c34a42..97af5f97bc 100644
--- a/Src/FluentAssertions/Numeric/NullableDoubleAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableDoubleAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableDoubleAssertions : NullableNumericAssertions<double>
 {
-    internal NullableDoubleAssertions(double? value)
-        : base(value)
+    internal NullableDoubleAssertions(double? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableInt16Assertions.cs b/Src/FluentAssertions/Numeric/NullableInt16Assertions.cs
index 89c5cc65d2..802d0c864d 100644
--- a/Src/FluentAssertions/Numeric/NullableInt16Assertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableInt16Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableInt16Assertions : NullableNumericAssertions<short>
 {
-    internal NullableInt16Assertions(short? value)
-        : base(value)
+    internal NullableInt16Assertions(short? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableInt32Assertions.cs b/Src/FluentAssertions/Numeric/NullableInt32Assertions.cs
index 67636c9ddf..7b2400568f 100644
--- a/Src/FluentAssertions/Numeric/NullableInt32Assertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableInt32Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableInt32Assertions : NullableNumericAssertions<int>
 {
-    internal NullableInt32Assertions(int? value)
-        : base(value)
+    internal NullableInt32Assertions(int? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableInt64Assertions.cs b/Src/FluentAssertions/Numeric/NullableInt64Assertions.cs
index 4630361178..1e5e04d386 100644
--- a/Src/FluentAssertions/Numeric/NullableInt64Assertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableInt64Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableInt64Assertions : NullableNumericAssertions<long>
 {
-    internal NullableInt64Assertions(long? value)
-        : base(value)
+    internal NullableInt64Assertions(long? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableNumericAssertions.cs b/Src/FluentAssertions/Numeric/NullableNumericAssertions.cs
index 5443d7f0a3..88af8fc2b3 100644
--- a/Src/FluentAssertions/Numeric/NullableNumericAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableNumericAssertions.cs
@@ -11,8 +11,8 @@ namespace FluentAssertions.Numeric;
 public class NullableNumericAssertions<T> : NullableNumericAssertions<T, NullableNumericAssertions<T>>
     where T : struct, IComparable<T>
 {
-    public NullableNumericAssertions(T? value)
-        : base(value)
+    public NullableNumericAssertions(T? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -22,9 +22,12 @@ public class NullableNumericAssertions<T, TAssertions> : NumericAssertions<T, TA
     where T : struct, IComparable<T>
     where TAssertions : NullableNumericAssertions<T, TAssertions>
 {
-    public NullableNumericAssertions(T? value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public NullableNumericAssertions(T? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -39,7 +42,7 @@ public NullableNumericAssertions(T? value)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected a value{reason}.");
@@ -74,7 +77,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect a value{reason}, but found {0}.", Subject);
@@ -116,7 +119,7 @@ public AndConstraint<TAssertions> Match(Expression<Func<T?, bool>> predicate,
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(predicate.Compile()(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected value to match {0}{reason}, but found {1}.", predicate, Subject);
diff --git a/Src/FluentAssertions/Numeric/NullableSByteAssertions.cs b/Src/FluentAssertions/Numeric/NullableSByteAssertions.cs
index 76967bc17e..e83e756404 100644
--- a/Src/FluentAssertions/Numeric/NullableSByteAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableSByteAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableSByteAssertions : NullableNumericAssertions<sbyte>
 {
-    internal NullableSByteAssertions(sbyte? value)
-        : base(value)
+    internal NullableSByteAssertions(sbyte? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableSingleAssertions.cs b/Src/FluentAssertions/Numeric/NullableSingleAssertions.cs
index fbcdaa919d..3a82df8969 100644
--- a/Src/FluentAssertions/Numeric/NullableSingleAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableSingleAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableSingleAssertions : NullableNumericAssertions<float>
 {
-    internal NullableSingleAssertions(float? value)
-        : base(value)
+    internal NullableSingleAssertions(float? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableUInt16Assertions.cs b/Src/FluentAssertions/Numeric/NullableUInt16Assertions.cs
index 97aad47a07..0df417d5e2 100644
--- a/Src/FluentAssertions/Numeric/NullableUInt16Assertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableUInt16Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableUInt16Assertions : NullableNumericAssertions<ushort>
 {
-    internal NullableUInt16Assertions(ushort? value)
-        : base(value)
+    internal NullableUInt16Assertions(ushort? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableUInt32Assertions.cs b/Src/FluentAssertions/Numeric/NullableUInt32Assertions.cs
index abf8f69801..69b94a8086 100644
--- a/Src/FluentAssertions/Numeric/NullableUInt32Assertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableUInt32Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableUInt32Assertions : NullableNumericAssertions<uint>
 {
-    internal NullableUInt32Assertions(uint? value)
-        : base(value)
+    internal NullableUInt32Assertions(uint? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NullableUInt64Assertions.cs b/Src/FluentAssertions/Numeric/NullableUInt64Assertions.cs
index 1a2e44c3a7..6c36e3b703 100644
--- a/Src/FluentAssertions/Numeric/NullableUInt64Assertions.cs
+++ b/Src/FluentAssertions/Numeric/NullableUInt64Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class NullableUInt64Assertions : NullableNumericAssertions<ulong>
 {
-    internal NullableUInt64Assertions(ulong? value)
-        : base(value)
+    internal NullableUInt64Assertions(ulong? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/NumericAssertions.cs b/Src/FluentAssertions/Numeric/NumericAssertions.cs
index 81cf130b6f..ea1ffac010 100644
--- a/Src/FluentAssertions/Numeric/NumericAssertions.cs
+++ b/Src/FluentAssertions/Numeric/NumericAssertions.cs
@@ -16,8 +16,8 @@ namespace FluentAssertions.Numeric;
 public class NumericAssertions<T> : NumericAssertions<T, NumericAssertions<T>>
     where T : struct, IComparable<T>
 {
-    public NumericAssertions(T value)
-        : base(value)
+    public NumericAssertions(T value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -32,14 +32,15 @@ public class NumericAssertions<T, TAssertions>
     where T : struct, IComparable<T>
     where TAssertions : NumericAssertions<T, TAssertions>
 {
-    public NumericAssertions(T value)
-        : this((T?)value)
+    public NumericAssertions(T value, AssertionChain assertionChain)
+        : this((T?)value, assertionChain)
     {
     }
 
-    private protected NumericAssertions(T? value)
+    private protected NumericAssertions(T? value, AssertionChain assertionChain)
     {
         Subject = value;
+        CurrentAssertionChain = assertionChain;
     }
 
     public T? Subject { get; }
@@ -57,7 +58,7 @@ private protected NumericAssertions(T? value)
     /// </param>
     public AndConstraint<TAssertions> Be(T expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject?.CompareTo(expected) == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be {0}{reason}, but found {1}" + GenerateDifferenceMessage(expected), expected,
@@ -79,7 +80,7 @@ public AndConstraint<TAssertions> Be(T expected, [StringSyntax("CompositeFormat"
     /// </param>
     public AndConstraint<TAssertions> Be(T? expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(expected is { } value ? Subject?.CompareTo(value) == 0 : !Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be {0}{reason}, but found {1}" + GenerateDifferenceMessage(expected), expected,
@@ -101,7 +102,7 @@ public AndConstraint<TAssertions> Be(T? expected, [StringSyntax("CompositeFormat
     /// </param>
     public AndConstraint<TAssertions> NotBe(T unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject?.CompareTo(unexpected) != 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be {0}{reason}.", unexpected);
@@ -122,7 +123,7 @@ public AndConstraint<TAssertions> NotBe(T unexpected, [StringSyntax("CompositeFo
     /// </param>
     public AndConstraint<TAssertions> NotBe(T? unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(unexpected is { } value ? Subject?.CompareTo(value) != 0 : Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be {0}{reason}.", unexpected);
@@ -142,7 +143,7 @@ public AndConstraint<TAssertions> NotBe(T? unexpected, [StringSyntax("CompositeF
     /// </param>
     public AndConstraint<TAssertions> BePositive([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject?.CompareTo(default) > 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be positive{reason}, but found {0}.", Subject);
@@ -162,7 +163,7 @@ public AndConstraint<TAssertions> BePositive([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> BeNegative([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is { } value && !IsNaN(value) && value.CompareTo(default) < 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be negative{reason}, but found {0}.", Subject);
@@ -188,7 +189,7 @@ public AndConstraint<TAssertions> BeLessThan(T expected, [StringSyntax("Composit
             throw new ArgumentException("A value can never be less than NaN", nameof(expected));
         }
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is { } value && !IsNaN(value) && value.CompareTo(expected) < 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be less than {0}{reason}, but found {1}" + GenerateDifferenceMessage(expected),
@@ -216,7 +217,7 @@ public AndConstraint<TAssertions> BeLessThanOrEqualTo(T expected,
             throw new ArgumentException("A value can never be less than or equal to NaN", nameof(expected));
         }
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is { } value && !IsNaN(value) && value.CompareTo(expected) <= 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -245,7 +246,7 @@ public AndConstraint<TAssertions> BeGreaterThan(T expected,
             throw new ArgumentException("A value can never be greater than NaN", nameof(expected));
         }
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject?.CompareTo(expected) > 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -274,7 +275,7 @@ public AndConstraint<TAssertions> BeGreaterThanOrEqualTo(T expected,
             throw new ArgumentException("A value can never be greater than or equal to a NaN", nameof(expected));
         }
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject?.CompareTo(expected) >= 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -311,7 +312,7 @@ public AndConstraint<TAssertions> BeInRange(T minimumValue, T maximumValue,
             throw new ArgumentException("A range cannot begin or end with NaN");
         }
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is { } value && value.CompareTo(minimumValue) >= 0 && value.CompareTo(maximumValue) <= 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be between {0} and {1}{reason}, but found {2}.",
@@ -347,7 +348,7 @@ public AndConstraint<TAssertions> NotBeInRange(T minimumValue, T maximumValue,
             throw new ArgumentException("A range cannot begin or end with NaN");
         }
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is { } value && !(value.CompareTo(minimumValue) >= 0 && value.CompareTo(maximumValue) <= 0))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to not be between {0} and {1}{reason}, but found {2}.",
@@ -383,7 +384,7 @@ public AndConstraint<TAssertions> BeOneOf(params T[] validValues)
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<T> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is { } value && validValues.Contains(value))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be one of {0}{reason}, but found {1}.", validValues, Subject);
@@ -441,12 +442,12 @@ public AndConstraint<TAssertions> NotBeOfType(Type unexpectedType, [StringSyntax
     {
         Guard.ThrowIfArgumentIsNull(unexpectedType);
 
-        bool success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected type not to be " + unexpectedType + "{reason}, but found <null>.");
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
             Subject.GetType().Should().NotBe(unexpectedType, because, becauseArgs);
         }
@@ -473,7 +474,7 @@ public AndConstraint<TAssertions> Match(Expression<Func<T, bool>> predicate,
     {
         Guard.ThrowIfArgumentIsNull(predicate);
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(predicate.Compile()((T)Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to match {0}{reason}, but found {1}.", predicate.Body, Subject);
@@ -510,4 +511,6 @@ private string GenerateDifferenceMessage(T? expected)
         var difference = CalculateDifferenceForFailureMessage(subject, expectedValue);
         return difference is null ? noDifferenceMessage : $" (difference of {difference}).";
     }
+
+    public AssertionChain CurrentAssertionChain { get; }
 }
diff --git a/Src/FluentAssertions/Numeric/SByteAssertions.cs b/Src/FluentAssertions/Numeric/SByteAssertions.cs
index f0f19c4cda..7ac217e8a3 100644
--- a/Src/FluentAssertions/Numeric/SByteAssertions.cs
+++ b/Src/FluentAssertions/Numeric/SByteAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class SByteAssertions : NumericAssertions<sbyte>
 {
-    internal SByteAssertions(sbyte value)
-        : base(value)
+    internal SByteAssertions(sbyte value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/SingleAssertions.cs b/Src/FluentAssertions/Numeric/SingleAssertions.cs
index 6a11220314..2276b01334 100644
--- a/Src/FluentAssertions/Numeric/SingleAssertions.cs
+++ b/Src/FluentAssertions/Numeric/SingleAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class SingleAssertions : NumericAssertions<float>
 {
-    internal SingleAssertions(float value)
-        : base(value)
+    internal SingleAssertions(float value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/UInt16Assertions.cs b/Src/FluentAssertions/Numeric/UInt16Assertions.cs
index b067a2a085..c1672f1482 100644
--- a/Src/FluentAssertions/Numeric/UInt16Assertions.cs
+++ b/Src/FluentAssertions/Numeric/UInt16Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class UInt16Assertions : NumericAssertions<ushort>
 {
-    internal UInt16Assertions(ushort value)
-        : base(value)
+    internal UInt16Assertions(ushort value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/UInt32Assertions.cs b/Src/FluentAssertions/Numeric/UInt32Assertions.cs
index ecd089901d..49bcaad48f 100644
--- a/Src/FluentAssertions/Numeric/UInt32Assertions.cs
+++ b/Src/FluentAssertions/Numeric/UInt32Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class UInt32Assertions : NumericAssertions<uint>
 {
-    internal UInt32Assertions(uint value)
-        : base(value)
+    internal UInt32Assertions(uint value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/Numeric/UInt64Assertions.cs b/Src/FluentAssertions/Numeric/UInt64Assertions.cs
index f45d9f35d4..3060a1c012 100644
--- a/Src/FluentAssertions/Numeric/UInt64Assertions.cs
+++ b/Src/FluentAssertions/Numeric/UInt64Assertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Numeric;
 
@@ -9,8 +10,8 @@ namespace FluentAssertions.Numeric;
 [DebuggerNonUserCode]
 internal class UInt64Assertions : NumericAssertions<ulong>
 {
-    internal UInt64Assertions(ulong value)
-        : base(value)
+    internal UInt64Assertions(ulong value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 
diff --git a/Src/FluentAssertions/NumericAssertionsExtensions.cs b/Src/FluentAssertions/NumericAssertionsExtensions.cs
index a2ab750506..20d3b9e6fe 100644
--- a/Src/FluentAssertions/NumericAssertionsExtensions.cs
+++ b/Src/FluentAssertions/NumericAssertionsExtensions.cs
@@ -49,8 +49,9 @@ public static AndConstraint<NumericAssertions<sbyte>> BeCloseTo(this NumericAsse
             maxValue = sbyte.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue, because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<sbyte>>(parent);
     }
@@ -91,8 +92,9 @@ public static AndConstraint<NumericAssertions<byte>> BeCloseTo(this NumericAsser
             maxValue = byte.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<byte>>(parent);
     }
@@ -133,8 +135,10 @@ public static AndConstraint<NumericAssertions<short>> BeCloseTo(this NumericAsse
             maxValue = short.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<short>>(parent);
     }
@@ -175,8 +179,10 @@ public static AndConstraint<NumericAssertions<ushort>> BeCloseTo(this NumericAss
             maxValue = ushort.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<ushort>>(parent);
     }
@@ -217,7 +223,10 @@ public static AndConstraint<NumericAssertions<int>> BeCloseTo(this NumericAssert
             maxValue = int.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue,
+            because,
             becauseArgs);
 
         return new AndConstraint<NumericAssertions<int>>(parent);
@@ -259,8 +268,11 @@ public static AndConstraint<NumericAssertions<uint>> BeCloseTo(this NumericAsser
             maxValue = uint.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(
+            parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<uint>>(parent);
     }
@@ -290,8 +302,10 @@ public static AndConstraint<NumericAssertions<long>> BeCloseTo(this NumericAsser
         long minValue = GetMinValue(nearbyValue, delta);
         long maxValue = GetMaxValue(nearbyValue, delta);
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<long>>(parent);
     }
@@ -332,17 +346,19 @@ public static AndConstraint<NumericAssertions<ulong>> BeCloseTo(this NumericAsse
             maxValue = ulong.MaxValue;
         }
 
-        FailIfValueOutsideBounds(minValue <= actualValue && actualValue <= maxValue, nearbyValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueOutsideBounds(parent.CurrentAssertionChain,
+            minValue <= actualValue && actualValue <= maxValue,
+            nearbyValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<ulong>>(parent);
     }
 
-    private static void FailIfValueOutsideBounds<TValue, TDelta>(bool valueWithinBounds,
+    private static void FailIfValueOutsideBounds<TValue, TDelta>(AssertionChain assertionChain, bool valueWithinBounds,
         TValue nearbyValue, TDelta delta, TValue actualValue,
         [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(valueWithinBounds)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be within {0} from {1}{reason}, but found {2}.",
@@ -389,8 +405,10 @@ public static AndConstraint<NumericAssertions<sbyte>> NotBeCloseTo(this NumericA
             maxValue = sbyte.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<sbyte>>(parent);
     }
@@ -431,8 +449,11 @@ public static AndConstraint<NumericAssertions<byte>> NotBeCloseTo(this NumericAs
             maxValue = byte.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(
+            parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<byte>>(parent);
     }
@@ -473,8 +494,11 @@ public static AndConstraint<NumericAssertions<short>> NotBeCloseTo(this NumericA
             maxValue = short.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(
+            parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<short>>(parent);
     }
@@ -515,8 +539,10 @@ public static AndConstraint<NumericAssertions<ushort>> NotBeCloseTo(this Numeric
             maxValue = ushort.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<ushort>>(parent);
     }
@@ -557,8 +583,11 @@ public static AndConstraint<NumericAssertions<int>> NotBeCloseTo(this NumericAss
             maxValue = int.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(
+            parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<int>>(parent);
     }
@@ -599,8 +628,10 @@ public static AndConstraint<NumericAssertions<uint>> NotBeCloseTo(this NumericAs
             maxValue = uint.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<uint>>(parent);
     }
@@ -630,8 +661,10 @@ public static AndConstraint<NumericAssertions<long>> NotBeCloseTo(this NumericAs
         long minValue = GetMinValue(distantValue, delta);
         long maxValue = GetMaxValue(distantValue, delta);
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
-            becauseArgs);
+        FailIfValueInsideBounds(parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue),
+            distantValue, delta, actualValue,
+            because, becauseArgs);
 
         return new AndConstraint<NumericAssertions<long>>(parent);
     }
@@ -672,18 +705,23 @@ public static AndConstraint<NumericAssertions<ulong>> NotBeCloseTo(this NumericA
             maxValue = ulong.MaxValue;
         }
 
-        FailIfValueInsideBounds(!(minValue <= actualValue && actualValue <= maxValue), distantValue, delta, actualValue, because,
+        FailIfValueInsideBounds(parent.CurrentAssertionChain,
+            !(minValue <= actualValue && actualValue <= maxValue), distantValue,
+            delta,
+            actualValue,
+            because,
             becauseArgs);
 
         return new AndConstraint<NumericAssertions<ulong>>(parent);
     }
 
     private static void FailIfValueInsideBounds<TValue, TDelta>(
+        AssertionChain assertionChain,
         bool valueOutsideBounds,
         TValue distantValue, TDelta delta, TValue actualValue,
         [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(valueOutsideBounds)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be within {0} from {1}{reason}, but found {2}.",
@@ -718,15 +756,17 @@ public static AndConstraint<NullableNumericAssertions<float>> BeApproximately(th
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        bool success = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(parent.Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was <null>.", expectedValue,
                 precision);
 
-        if (success)
+        if (assertion.Succeeded)
         {
-            var nonNullableAssertions = new SingleAssertions(parent.Subject.Value);
+            var nonNullableAssertions = new SingleAssertions(parent.Subject.Value, assertion);
             nonNullableAssertions.BeApproximately(expectedValue, precision, because, becauseArgs);
         }
 
@@ -763,13 +803,15 @@ public static AndConstraint<NullableNumericAssertions<float>> BeApproximately(th
             return new AndConstraint<NullableNumericAssertions<float>>(parent);
         }
 
-        bool succeeded = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(expectedValue is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was {2}.", expectedValue, precision,
                 parent.Subject);
 
-        if (succeeded)
+        if (assertion.Succeeded)
         {
             // ReSharper disable once PossibleInvalidOperationException
             parent.BeApproximately(expectedValue.Value, precision, because, becauseArgs);
@@ -852,15 +894,17 @@ public static AndConstraint<NullableNumericAssertions<double>> BeApproximately(t
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        bool success = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(parent.Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was <null>.", expectedValue,
                 precision);
 
-        if (success)
+        if (assertion.Succeeded)
         {
-            var nonNullableAssertions = new DoubleAssertions(parent.Subject.Value);
+            var nonNullableAssertions = new DoubleAssertions(parent.Subject.Value, assertion);
             BeApproximately(nonNullableAssertions, expectedValue, precision, because, becauseArgs);
         }
 
@@ -897,13 +941,15 @@ public static AndConstraint<NullableNumericAssertions<double>> BeApproximately(t
             return new AndConstraint<NullableNumericAssertions<double>>(parent);
         }
 
-        bool succeeded = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(expectedValue is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was {2}.", expectedValue, precision,
                 parent.Subject);
 
-        if (succeeded)
+        if (assertion.Succeeded)
         {
             // ReSharper disable once PossibleInvalidOperationException
             parent.BeApproximately(expectedValue.Value, precision, because, becauseArgs);
@@ -987,15 +1033,17 @@ public static AndConstraint<NullableNumericAssertions<decimal>> BeApproximately(
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        bool success = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(parent.Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was <null>.", expectedValue,
                 precision);
 
-        if (success)
+        if (assertion.Succeeded)
         {
-            var nonNullableAssertions = new DecimalAssertions(parent.Subject.Value);
+            var nonNullableAssertions = new DecimalAssertions(parent.Subject.Value, assertion);
             BeApproximately(nonNullableAssertions, expectedValue, precision, because, becauseArgs);
         }
 
@@ -1033,13 +1081,15 @@ public static AndConstraint<NullableNumericAssertions<decimal>> BeApproximately(
             return new AndConstraint<NullableNumericAssertions<decimal>>(parent);
         }
 
-        bool succeeded = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(expectedValue is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was {2}.", expectedValue, precision,
                 parent.Subject);
 
-        if (succeeded)
+        if (assertion.Succeeded)
         {
             // ReSharper disable once PossibleInvalidOperationException
             parent.BeApproximately(expectedValue.Value, precision, because, becauseArgs);
@@ -1086,7 +1136,9 @@ private static void FailIfDifferenceOutsidePrecision<T>(
         [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
         where T : struct, IComparable<T>
     {
-        Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(differenceWithinPrecision)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {1} +/- {2}{reason}, but {0} differed by {3}.",
@@ -1123,7 +1175,7 @@ public static AndConstraint<NullableNumericAssertions<float>> NotBeApproximately
 
         if (parent.Subject is not null)
         {
-            var nonNullableAssertions = new SingleAssertions(parent.Subject.Value);
+            var nonNullableAssertions = new SingleAssertions(parent.Subject.Value, parent.CurrentAssertionChain);
             nonNullableAssertions.NotBeApproximately(unexpectedValue, precision, because, becauseArgs);
         }
 
@@ -1160,13 +1212,15 @@ public static AndConstraint<NullableNumericAssertions<float>> NotBeApproximately
             return new AndConstraint<NullableNumericAssertions<float>>(parent);
         }
 
-        bool succeeded = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(parent.Subject is not null && unexpectedValue is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to not approximate {0} +/- {1}{reason}, but it was {2}.", unexpectedValue,
                 precision, parent.Subject);
 
-        if (succeeded)
+        if (assertion.Succeeded)
         {
             // ReSharper disable once PossibleInvalidOperationException
             parent.NotBeApproximately(unexpectedValue.Value, precision, because, becauseArgs);
@@ -1252,7 +1306,7 @@ public static AndConstraint<NullableNumericAssertions<double>> NotBeApproximatel
 
         if (parent.Subject is not null)
         {
-            var nonNullableAssertions = new DoubleAssertions(parent.Subject.Value);
+            var nonNullableAssertions = new DoubleAssertions(parent.Subject.Value, parent.CurrentAssertionChain);
             nonNullableAssertions.NotBeApproximately(unexpectedValue, precision, because, becauseArgs);
         }
 
@@ -1290,13 +1344,15 @@ public static AndConstraint<NullableNumericAssertions<double>> NotBeApproximatel
             return new AndConstraint<NullableNumericAssertions<double>>(parent);
         }
 
-        bool succeeded = Execute.Assertion
+        AssertionChain assertionChain = parent.CurrentAssertionChain;
+
+        assertionChain
             .ForCondition(parent.Subject is not null && unexpectedValue is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to not approximate {0} +/- {1}{reason}, but it was {2}.", unexpectedValue,
                 precision, parent.Subject);
 
-        if (succeeded)
+        if (assertionChain.Succeeded)
         {
             // ReSharper disable once PossibleInvalidOperationException
             parent.NotBeApproximately(unexpectedValue.Value, precision, because, becauseArgs);
@@ -1382,7 +1438,7 @@ public static AndConstraint<NullableNumericAssertions<decimal>> NotBeApproximate
 
         if (parent.Subject is not null)
         {
-            var nonNullableAssertions = new DecimalAssertions(parent.Subject.Value);
+            var nonNullableAssertions = new DecimalAssertions(parent.Subject.Value, parent.CurrentAssertionChain);
             NotBeApproximately(nonNullableAssertions, unexpectedValue, precision, because, becauseArgs);
         }
 
@@ -1420,13 +1476,15 @@ public static AndConstraint<NullableNumericAssertions<decimal>> NotBeApproximate
             return new AndConstraint<NullableNumericAssertions<decimal>>(parent);
         }
 
-        bool succeeded = Execute.Assertion
+        var assertion = parent.CurrentAssertionChain;
+
+        assertion
             .ForCondition(parent.Subject is not null && unexpectedValue is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to not approximate {0} +/- {1}{reason}, but it was {2}.", unexpectedValue,
                 precision, parent.Subject);
 
-        if (succeeded)
+        if (assertion.Succeeded)
         {
             // ReSharper disable once PossibleInvalidOperationException
             parent.NotBeApproximately(unexpectedValue.Value, precision, because, becauseArgs);
@@ -1473,7 +1531,7 @@ private static void FailIfDifferenceWithinPrecision<T>(
         [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
         where T : struct, IComparable<T>
     {
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(differenceOutsidePrecision)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to not approximate {1} +/- {2}{reason}, but {0} only differed by {3}.",
@@ -1500,7 +1558,7 @@ public static AndConstraint<NumericAssertions<float>> BeNaN(this NumericAssertio
     {
         float actualValue = parent.Subject.Value;
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(float.IsNaN(actualValue))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be NaN{reason}, but found {0}.", actualValue);
@@ -1524,7 +1582,7 @@ public static AndConstraint<NumericAssertions<double>> BeNaN(this NumericAsserti
     {
         double actualValue = parent.Subject.Value;
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(double.IsNaN(actualValue))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be NaN{reason}, but found {0}.", actualValue);
@@ -1548,7 +1606,7 @@ public static AndConstraint<NullableNumericAssertions<float>> BeNaN(this Nullabl
     {
         float? actualValue = parent.Subject;
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(actualValue is { } value && float.IsNaN(value))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be NaN{reason}, but found {0}.", actualValue);
@@ -1572,7 +1630,7 @@ public static AndConstraint<NullableNumericAssertions<double>> BeNaN(this Nullab
     {
         double? actualValue = parent.Subject;
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(actualValue is { } value && double.IsNaN(value))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to be NaN{reason}, but found {0}.", actualValue);
@@ -1600,7 +1658,7 @@ public static AndConstraint<NumericAssertions<float>> NotBeNaN(this NumericAsser
     {
         float actualValue = parent.Subject.Value;
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(!float.IsNaN(actualValue))
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be NaN{reason}.");
@@ -1624,7 +1682,7 @@ public static AndConstraint<NumericAssertions<double>> NotBeNaN(this NumericAsse
     {
         double actualValue = parent.Subject.Value;
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(!double.IsNaN(actualValue))
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be NaN{reason}.");
@@ -1649,7 +1707,7 @@ public static AndConstraint<NullableNumericAssertions<float>> NotBeNaN(this Null
         float? actualValue = parent.Subject;
         bool actualValueIsNaN = actualValue is { } value && float.IsNaN(value);
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(!actualValueIsNaN)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be NaN{reason}.");
@@ -1674,7 +1732,7 @@ public static AndConstraint<NullableNumericAssertions<double>> NotBeNaN(this Nul
         double? actualValue = parent.Subject;
         bool actualValueIsNaN = actualValue is { } value && double.IsNaN(value);
 
-        Execute.Assertion
+        parent.CurrentAssertionChain
             .ForCondition(!actualValueIsNaN)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:value} to be NaN{reason}.");
@@ -1687,6 +1745,7 @@ public static AndConstraint<NullableNumericAssertions<double>> NotBeNaN(this Nul
     private static long GetMinValue(long value, ulong delta)
     {
         long minValue;
+
         if (delta <= (ulong.MaxValue / 2))
         {
             minValue = value - (long)delta;
@@ -1711,6 +1770,7 @@ private static long GetMinValue(long value, ulong delta)
     private static long GetMaxValue(long value, ulong delta)
     {
         long maxValue;
+
         if (delta <= (ulong.MaxValue / 2))
         {
             maxValue = value + (long)delta;
diff --git a/Src/FluentAssertions/ObjectAssertionsExtensions.cs b/Src/FluentAssertions/ObjectAssertionsExtensions.cs
index 7819357665..5f93f280fa 100644
--- a/Src/FluentAssertions/ObjectAssertionsExtensions.cs
+++ b/Src/FluentAssertions/ObjectAssertionsExtensions.cs
@@ -5,7 +5,6 @@
 using System.Xml.Serialization;
 using FluentAssertions.Common;
 using FluentAssertions.Equivalency;
-using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 
 namespace FluentAssertions;
@@ -66,7 +65,7 @@ public static AndConstraint<ObjectAssertions> BeDataContractSerializable<T>(this
         }
         catch (Exception exc)
         {
-            Execute.Assertion
+            assertions.CurrentAssertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {0} to be serializable{reason}, but serialization failed with:"
                     + Environment.NewLine + Environment.NewLine + "{1}.",
@@ -110,7 +109,7 @@ public static AndConstraint<ObjectAssertions> BeXmlSerializable(this ObjectAsser
         }
         catch (Exception exc)
         {
-            Execute.Assertion
+            assertions.CurrentAssertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {0} to be serializable{reason}, but serialization failed with:"
                     + Environment.NewLine + Environment.NewLine + "{1}.",
diff --git a/Src/FluentAssertions/OccurrenceConstraint.cs b/Src/FluentAssertions/OccurrenceConstraint.cs
index 1f93dd0f13..347df0b750 100644
--- a/Src/FluentAssertions/OccurrenceConstraint.cs
+++ b/Src/FluentAssertions/OccurrenceConstraint.cs
@@ -1,6 +1,5 @@
 using System;
 using FluentAssertions.Common;
-using FluentAssertions.Execution;
 
 namespace FluentAssertions;
 
@@ -22,8 +21,8 @@ protected OccurrenceConstraint(int expectedCount)
 
     internal abstract bool Assert(int actual);
 
-    internal void RegisterReportables(AssertionScope scope)
+    internal void RegisterContextData(Action<string, object> register)
     {
-        scope.AddReportable("expectedOccurrence", $"{Mode} {ExpectedCount.Times()}");
+        register("expectedOccurrence", $"{Mode} {ExpectedCount.Times()}");
     }
 }
diff --git a/Src/FluentAssertions/Primitives/BooleanAssertions.cs b/Src/FluentAssertions/Primitives/BooleanAssertions.cs
index 1adcba679f..4932df3e13 100644
--- a/Src/FluentAssertions/Primitives/BooleanAssertions.cs
+++ b/Src/FluentAssertions/Primitives/BooleanAssertions.cs
@@ -12,8 +12,8 @@ namespace FluentAssertions.Primitives;
 public class BooleanAssertions
     : BooleanAssertions<BooleanAssertions>
 {
-    public BooleanAssertions(bool? value)
-        : base(value)
+    public BooleanAssertions(bool? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -27,8 +27,11 @@ public BooleanAssertions(bool? value)
 public class BooleanAssertions<TAssertions>
     where TAssertions : BooleanAssertions<TAssertions>
 {
-    public BooleanAssertions(bool? value)
+    private readonly AssertionChain assertionChain;
+
+    public BooleanAssertions(bool? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -49,7 +52,7 @@ public BooleanAssertions(bool? value)
     /// </param>
     public AndConstraint<TAssertions> BeFalse([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == false)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:boolean} to be {0}{reason}, but found {1}.", false, Subject);
@@ -69,7 +72,7 @@ public AndConstraint<TAssertions> BeFalse([StringSyntax("CompositeFormat")] stri
     /// </param>
     public AndConstraint<TAssertions> BeTrue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == true)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:boolean} to be {0}{reason}, but found {1}.", true, Subject);
@@ -88,9 +91,10 @@ public AndConstraint<TAssertions> BeTrue([StringSyntax("CompositeFormat")] strin
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> Be(bool expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Be(bool expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:boolean} to be {0}{reason}, but found {1}.", expected, Subject);
@@ -109,9 +113,10 @@ public AndConstraint<TAssertions> Be(bool expected, [StringSyntax("CompositeForm
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndConstraint<TAssertions> NotBe(bool unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBe(bool unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:boolean} not to be {0}{reason}, but found {1}.", unexpected, Subject);
@@ -136,16 +141,15 @@ public AndConstraint<TAssertions> Imply(bool consequent,
     {
         bool? antecedent = Subject;
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(antecedent is not null)
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:antecedent} ({0}) to imply consequent ({1}){reason}, ", antecedent, consequent)
-            .FailWith("but found null.")
-            .Then
-            .ForCondition(!antecedent.Value || consequent)
-            .FailWith("but it did not.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:antecedent} ({0}) to imply consequent ({1}){reason}, ", antecedent, consequent,
+                chain => chain
+                    .FailWith("but found null.")
+                    .Then
+                    .ForCondition(!antecedent.Value || consequent)
+                    .FailWith("but it did not."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
diff --git a/Src/FluentAssertions/Primitives/DateOnlyAssertions.cs b/Src/FluentAssertions/Primitives/DateOnlyAssertions.cs
index 5adc26841c..c5e57b5d73 100644
--- a/Src/FluentAssertions/Primitives/DateOnlyAssertions.cs
+++ b/Src/FluentAssertions/Primitives/DateOnlyAssertions.cs
@@ -15,8 +15,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class DateOnlyAssertions : DateOnlyAssertions<DateOnlyAssertions>
 {
-    public DateOnlyAssertions(DateOnly? value)
-        : base(value)
+    public DateOnlyAssertions(DateOnly? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -30,8 +30,11 @@ public DateOnlyAssertions(DateOnly? value)
 public class DateOnlyAssertions<TAssertions>
     where TAssertions : DateOnlyAssertions<TAssertions>
 {
-    public DateOnlyAssertions(DateOnly? value)
+    private readonly AssertionChain assertionChain;
+
+    public DateOnlyAssertions(DateOnly? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -51,9 +54,10 @@ public DateOnlyAssertions(DateOnly? value)
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> Be(DateOnly expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Be(DateOnly expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be {0}{reason}, but found {1}.",
@@ -73,9 +77,10 @@ public AndConstraint<TAssertions> Be(DateOnly expected, [StringSyntax("Composite
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> Be(DateOnly? expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Be(DateOnly? expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be {0}{reason}, but found {1}.",
@@ -98,7 +103,7 @@ public AndConstraint<TAssertions> Be(DateOnly? expected, [StringSyntax("Composit
     public AndConstraint<TAssertions> NotBe(DateOnly unexpected, [StringSyntax("CompositeFormat")] string because = "",
         params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} not to be {0}{reason}, but it is.", unexpected);
@@ -120,7 +125,7 @@ public AndConstraint<TAssertions> NotBe(DateOnly unexpected, [StringSyntax("Comp
     public AndConstraint<TAssertions> NotBe(DateOnly? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} not to be {0}{reason}, but it is.", unexpected);
@@ -142,7 +147,7 @@ public AndConstraint<TAssertions> NotBe(DateOnly? unexpected,
     public AndConstraint<TAssertions> BeBefore(DateOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be before {0}{reason}, but found {1}.", expected,
@@ -182,7 +187,7 @@ public AndConstraint<TAssertions> NotBeBefore(DateOnly unexpected,
     public AndConstraint<TAssertions> BeOnOrBefore(DateOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject <= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be on or before {0}{reason}, but found {1}.", expected,
@@ -222,7 +227,7 @@ public AndConstraint<TAssertions> NotBeOnOrBefore(DateOnly unexpected,
     public AndConstraint<TAssertions> BeAfter(DateOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject > expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be after {0}{reason}, but found {1}.", expected,
@@ -262,7 +267,7 @@ public AndConstraint<TAssertions> NotBeAfter(DateOnly unexpected,
     public AndConstraint<TAssertions> BeOnOrAfter(DateOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject >= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be on or after {0}{reason}, but found {1}.", expected,
@@ -299,18 +304,17 @@ public AndConstraint<TAssertions> NotBeOnOrAfter(DateOnly unexpected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveYear(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveYear(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the year part of {context:the date} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found <null>.")
-            .Then
-            .ForCondition(Subject.Value.Year == expected)
-            .FailWith(", but found {0}.", Subject.Value.Year)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the year part of {context:the date} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found <null>.")
+                .Then
+                .ForCondition(Subject.Value.Year == expected)
+                .FailWith(", but found {0}.", Subject.Value.Year));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -326,9 +330,10 @@ public AndConstraint<TAssertions> HaveYear(int expected, [StringSyntax("Composit
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveYear(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveYear(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject.HasValue)
             .FailWith("Did not expect the year part of {context:the date} to be {0}{reason}, but found a <null> DateOnly.",
@@ -352,18 +357,17 @@ public AndConstraint<TAssertions> NotHaveYear(int unexpected, [StringSyntax("Com
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveMonth(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveMonth(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the month part of {context:the date} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateOnly.")
-            .Then
-            .ForCondition(Subject.Value.Month == expected)
-            .FailWith(", but found {0}.", Subject.Value.Month)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the month part of {context:the date} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateOnly.")
+                .Then
+                .ForCondition(Subject.Value.Month == expected)
+                .FailWith(", but found {0}.", Subject.Value.Month));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -379,18 +383,17 @@ public AndConstraint<TAssertions> HaveMonth(int expected, [StringSyntax("Composi
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveMonth(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveMonth(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the month part of {context:the date} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateOnly.")
-            .Then
-            .ForCondition(Subject.Value.Month != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the month part of {context:the date} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateOnly.")
+                .Then
+                .ForCondition(Subject.Value.Month != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -406,18 +409,17 @@ public AndConstraint<TAssertions> NotHaveMonth(int unexpected, [StringSyntax("Co
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveDay(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveDay(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the day part of {context:the date} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateOnly.")
-            .Then
-            .ForCondition(Subject.Value.Day == expected)
-            .FailWith(", but found {0}.", Subject.Value.Day)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the day part of {context:the date} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateOnly.")
+                .Then
+                .ForCondition(Subject.Value.Day == expected)
+                .FailWith(", but found {0}.", Subject.Value.Day));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -433,18 +435,17 @@ public AndConstraint<TAssertions> HaveDay(int expected, [StringSyntax("Composite
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveDay(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveDay(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the day part of {context:the date} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateOnly.")
-            .Then
-            .ForCondition(Subject.Value.Day != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the day part of {context:the date} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateOnly.")
+                .Then
+                .ForCondition(Subject.Value.Day != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -484,7 +485,8 @@ public AndConstraint<TAssertions> BeOneOf(params DateOnly[] validValues)
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateOnly> validValues, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateOnly> validValues,
+        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         return BeOneOf(validValues.Cast<DateOnly?>(), because, becauseArgs);
     }
@@ -505,7 +507,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateOnly> validValues, [St
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateOnly?> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date} to be one of {0}{reason}, but found {1}.", validValues, Subject);
diff --git a/Src/FluentAssertions/Primitives/DateTimeAssertions.cs b/Src/FluentAssertions/Primitives/DateTimeAssertions.cs
index 63effadf47..b1f7ffa01a 100644
--- a/Src/FluentAssertions/Primitives/DateTimeAssertions.cs
+++ b/Src/FluentAssertions/Primitives/DateTimeAssertions.cs
@@ -18,8 +18,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class DateTimeAssertions : DateTimeAssertions<DateTimeAssertions>
 {
-    public DateTimeAssertions(DateTime? value)
-        : base(value)
+    public DateTimeAssertions(DateTime? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -37,8 +37,11 @@ public DateTimeAssertions(DateTime? value)
 public class DateTimeAssertions<TAssertions>
     where TAssertions : DateTimeAssertions<TAssertions>
 {
-    public DateTimeAssertions(DateTime? value)
+    private readonly AssertionChain assertionChain;
+
+    public DateTimeAssertions(DateTime? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -58,9 +61,10 @@ public DateTimeAssertions(DateTime? value)
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> Be(DateTime expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Be(DateTime expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date and time} to be {0}{reason}, but found {1}.",
@@ -80,9 +84,10 @@ public AndConstraint<TAssertions> Be(DateTime expected, [StringSyntax("Composite
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> Be(DateTime? expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> Be(DateTime? expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date and time} to be {0}{reason}, but found {1}.",
@@ -105,7 +110,7 @@ public AndConstraint<TAssertions> Be(DateTime? expected, [StringSyntax("Composit
     public AndConstraint<TAssertions> NotBe(DateTime unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date and time} not to be {0}{reason}, but it is.", unexpected);
@@ -127,7 +132,7 @@ public AndConstraint<TAssertions> NotBe(DateTime unexpected,
     public AndConstraint<TAssertions> NotBe(DateTime? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date and time} not to be {0}{reason}, but it is.", unexpected);
@@ -170,16 +175,15 @@ public AndConstraint<TAssertions> BeCloseTo(DateTime nearbyTime, TimeSpan precis
 
         TimeSpan? difference = (Subject - nearbyTime)?.Duration();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:the date and time} to be within {0} from {1}{reason}", precision, nearbyTime)
-            .ForCondition(Subject is not null)
-            .FailWith(", but found <null>.")
-            .Then
-            .ForCondition(Subject >= minimumValue && Subject <= maximumValue)
-            .FailWith(", but {0} was off by {1}.", Subject, difference)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:the date and time} to be within {0} from {1}{reason}", precision, nearbyTime,
+                chain => chain
+                    .ForCondition(Subject is not null)
+                    .FailWith(", but found <null>.")
+                    .Then
+                    .ForCondition(Subject >= minimumValue && Subject <= maximumValue)
+                    .FailWith(", but {0} was off by {1}.", Subject, difference));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -217,7 +221,7 @@ public AndConstraint<TAssertions> NotBeCloseTo(DateTime distantTime, TimeSpan pr
         long distanceToMaxInTicks = (DateTime.MaxValue - distantTime).Ticks;
         DateTime maximumValue = distantTime.AddTicks(Math.Min(precision.Ticks, distanceToMaxInTicks));
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < minimumValue || Subject > maximumValue)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -242,7 +246,7 @@ public AndConstraint<TAssertions> NotBeCloseTo(DateTime distantTime, TimeSpan pr
     public AndConstraint<TAssertions> BeBefore(DateTime expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be before {0}{reason}, but found {1}.", expected,
@@ -282,7 +286,7 @@ public AndConstraint<TAssertions> NotBeBefore(DateTime unexpected,
     public AndConstraint<TAssertions> BeOnOrBefore(DateTime expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject <= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be on or before {0}{reason}, but found {1}.", expected,
@@ -322,7 +326,7 @@ public AndConstraint<TAssertions> NotBeOnOrBefore(DateTime unexpected,
     public AndConstraint<TAssertions> BeAfter(DateTime expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject > expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be after {0}{reason}, but found {1}.", expected,
@@ -362,7 +366,7 @@ public AndConstraint<TAssertions> NotBeAfter(DateTime unexpected,
     public AndConstraint<TAssertions> BeOnOrAfter(DateTime expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject >= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be on or after {0}{reason}, but found {1}.", expected,
@@ -399,18 +403,17 @@ public AndConstraint<TAssertions> NotBeOnOrAfter(DateTime unexpected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveYear(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveYear(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the year part of {context:the date} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found <null>.")
-            .Then
-            .ForCondition(Subject.Value.Year == expected)
-            .FailWith(", but found {0}.", Subject.Value.Year)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the year part of {context:the date} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found <null>.")
+                .Then
+                .ForCondition(Subject.Value.Year == expected)
+                .FailWith(", but found {0}.", Subject.Value.Year));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -426,9 +429,10 @@ public AndConstraint<TAssertions> HaveYear(int expected, [StringSyntax("Composit
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveYear(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveYear(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject.HasValue)
             .FailWith("Did not expect the year part of {context:the date} to be {0}{reason}, but found a <null> DateTime.",
@@ -452,18 +456,17 @@ public AndConstraint<TAssertions> NotHaveYear(int unexpected, [StringSyntax("Com
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveMonth(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveMonth(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the month part of {context:the date} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Month == expected)
-            .FailWith(", but found {0}.", Subject.Value.Month)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the month part of {context:the date} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Month == expected)
+                .FailWith(", but found {0}.", Subject.Value.Month));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -479,18 +482,17 @@ public AndConstraint<TAssertions> HaveMonth(int expected, [StringSyntax("Composi
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveMonth(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveMonth(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the month part of {context:the date} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Month != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the month part of {context:the date} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Month != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -506,18 +508,17 @@ public AndConstraint<TAssertions> NotHaveMonth(int unexpected, [StringSyntax("Co
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveDay(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveDay(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the day part of {context:the date} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Day == expected)
-            .FailWith(", but found {0}.", Subject.Value.Day)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the day part of {context:the date} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Day == expected)
+                .FailWith(", but found {0}.", Subject.Value.Day));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -533,18 +534,17 @@ public AndConstraint<TAssertions> HaveDay(int expected, [StringSyntax("Composite
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveDay(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveDay(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the day part of {context:the date} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Day != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the day part of {context:the date} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Day != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -560,18 +560,17 @@ public AndConstraint<TAssertions> NotHaveDay(int unexpected, [StringSyntax("Comp
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveHour(int expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveHour(int expected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the hour part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Hour == expected)
-            .FailWith(", but found {0}.", Subject.Value.Hour)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the hour part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Hour == expected)
+                .FailWith(", but found {0}.", Subject.Value.Hour));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -587,18 +586,17 @@ public AndConstraint<TAssertions> HaveHour(int expected, [StringSyntax("Composit
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveHour(int unexpected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveHour(int unexpected, [StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the hour part of {context:the time} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.", unexpected)
-            .Then
-            .ForCondition(Subject.Value.Hour != unexpected)
-            .FailWith(", but it was.", unexpected, Subject.Value.Hour)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the hour part of {context:the time} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.", unexpected)
+                .Then
+                .ForCondition(Subject.Value.Hour != unexpected)
+                .FailWith(", but it was.", unexpected, Subject.Value.Hour));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -617,16 +615,14 @@ public AndConstraint<TAssertions> NotHaveHour(int unexpected, [StringSyntax("Com
     public AndConstraint<TAssertions> HaveMinute(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the minute part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Minute == expected)
-            .FailWith(", but found {0}.", Subject.Value.Minute)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the minute part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Minute == expected)
+                .FailWith(", but found {0}.", Subject.Value.Minute));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -645,16 +641,14 @@ public AndConstraint<TAssertions> HaveMinute(int expected,
     public AndConstraint<TAssertions> NotHaveMinute(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the minute part of {context:the time} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.", unexpected)
-            .Then
-            .ForCondition(Subject.Value.Minute != unexpected)
-            .FailWith(", but it was.", unexpected, Subject.Value.Minute)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the minute part of {context:the time} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.", unexpected)
+                .Then
+                .ForCondition(Subject.Value.Minute != unexpected)
+                .FailWith(", but it was.", unexpected, Subject.Value.Minute));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -673,16 +667,14 @@ public AndConstraint<TAssertions> NotHaveMinute(int unexpected,
     public AndConstraint<TAssertions> HaveSecond(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the seconds part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Second == expected)
-            .FailWith(", but found {0}.", Subject.Value.Second)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the seconds part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Second == expected)
+                .FailWith(", but found {0}.", Subject.Value.Second));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -701,16 +693,14 @@ public AndConstraint<TAssertions> HaveSecond(int expected,
     public AndConstraint<TAssertions> NotHaveSecond(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the seconds part of {context:the time} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Second != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the seconds part of {context:the time} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Second != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -724,7 +714,8 @@ public AndConstraint<TAssertions> NotHaveSecond(int unexpected,
     /// </param>
     public DateTimeRangeAssertions<TAssertions> BeMoreThan(TimeSpan timeSpan)
     {
-        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.MoreThan, timeSpan);
+        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject, TimeSpanCondition.MoreThan,
+            timeSpan);
     }
 
     /// <summary>
@@ -737,7 +728,8 @@ public DateTimeRangeAssertions<TAssertions> BeMoreThan(TimeSpan timeSpan)
     /// </param>
     public DateTimeRangeAssertions<TAssertions> BeAtLeast(TimeSpan timeSpan)
     {
-        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.AtLeast, timeSpan);
+        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject, TimeSpanCondition.AtLeast,
+            timeSpan);
     }
 
     /// <summary>
@@ -749,7 +741,8 @@ public DateTimeRangeAssertions<TAssertions> BeAtLeast(TimeSpan timeSpan)
     /// </param>
     public DateTimeRangeAssertions<TAssertions> BeExactly(TimeSpan timeSpan)
     {
-        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.Exactly, timeSpan);
+        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject, TimeSpanCondition.Exactly,
+            timeSpan);
     }
 
     /// <summary>
@@ -761,7 +754,8 @@ public DateTimeRangeAssertions<TAssertions> BeExactly(TimeSpan timeSpan)
     /// </param>
     public DateTimeRangeAssertions<TAssertions> BeWithin(TimeSpan timeSpan)
     {
-        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.Within, timeSpan);
+        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject, TimeSpanCondition.Within,
+            timeSpan);
     }
 
     /// <summary>
@@ -773,7 +767,8 @@ public DateTimeRangeAssertions<TAssertions> BeWithin(TimeSpan timeSpan)
     /// </param>
     public DateTimeRangeAssertions<TAssertions> BeLessThan(TimeSpan timeSpan)
     {
-        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.LessThan, timeSpan);
+        return new DateTimeRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject, TimeSpanCondition.LessThan,
+            timeSpan);
     }
 
     /// <summary>
@@ -792,16 +787,15 @@ public AndConstraint<TAssertions> BeSameDateAs(DateTime expected,
     {
         DateTime expectedDate = expected.Date;
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the date part of {context:the date and time} to be {0}{reason}", expectedDate)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.", expectedDate)
-            .Then
-            .ForCondition(Subject.Value.Date == expectedDate)
-            .FailWith(", but found {1}.", expectedDate, Subject.Value)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the date part of {context:the date and time} to be {0}{reason}", expectedDate,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith(", but found a <null> DateTime.", expectedDate)
+                    .Then
+                    .ForCondition(Subject.Value.Date == expectedDate)
+                    .FailWith(", but found {1}.", expectedDate, Subject.Value));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -822,16 +816,15 @@ public AndConstraint<TAssertions> NotBeSameDateAs(DateTime unexpected,
     {
         DateTime unexpectedDate = unexpected.Date;
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the date part of {context:the date and time} to be {0}{reason}", unexpectedDate)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Date != unexpectedDate)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the date part of {context:the date and time} to be {0}{reason}", unexpectedDate,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith(", but found a <null> DateTime.")
+                    .Then
+                    .ForCondition(Subject.Value.Date != unexpectedDate)
+                    .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -893,7 +886,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateTime> validValues,
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateTime?> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:date and time} to be one of {0}{reason}, but found {1}.", validValues, Subject);
@@ -917,16 +910,14 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateTime?> validValues,
     public AndConstraint<TAssertions> BeIn(DateTimeKind expectedKind,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:the date and time} to be in " + expectedKind + "{reason}")
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(Subject.Value.Kind == expectedKind)
-            .FailWith(", but found " + Subject.Value.Kind + ".")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:the date and time} to be in " + expectedKind + "{reason}", chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(Subject.Value.Kind == expectedKind)
+                .FailWith(", but found " + Subject.Value.Kind + "."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -947,17 +938,15 @@ public AndConstraint<TAssertions> BeIn(DateTimeKind expectedKind,
     public AndConstraint<TAssertions> NotBeIn(DateTimeKind unexpectedKind,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect {context:the date and time} to be in " + unexpectedKind + "{reason}")
-            .Given(() => Subject)
-            .ForCondition(subject => subject.HasValue)
-            .FailWith(", but found a <null> DateTime.")
-            .Then
-            .ForCondition(subject => subject.GetValueOrDefault().Kind != unexpectedKind)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect {context:the date and time} to be in " + unexpectedKind + "{reason}", chain => chain
+                .Given(() => Subject)
+                .ForCondition(subject => subject.HasValue)
+                .FailWith(", but found a <null> DateTime.")
+                .Then
+                .ForCondition(subject => subject.GetValueOrDefault().Kind != unexpectedKind)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
diff --git a/Src/FluentAssertions/Primitives/DateTimeOffsetAssertions.cs b/Src/FluentAssertions/Primitives/DateTimeOffsetAssertions.cs
index 35a03100c1..83d27c8ad0 100644
--- a/Src/FluentAssertions/Primitives/DateTimeOffsetAssertions.cs
+++ b/Src/FluentAssertions/Primitives/DateTimeOffsetAssertions.cs
@@ -19,8 +19,8 @@ namespace FluentAssertions.Primitives;
 public class DateTimeOffsetAssertions
     : DateTimeOffsetAssertions<DateTimeOffsetAssertions>
 {
-    public DateTimeOffsetAssertions(DateTimeOffset? value)
-        : base(value)
+    public DateTimeOffsetAssertions(DateTimeOffset? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -38,8 +38,11 @@ public DateTimeOffsetAssertions(DateTimeOffset? value)
 public class DateTimeOffsetAssertions<TAssertions>
     where TAssertions : DateTimeOffsetAssertions<TAssertions>
 {
-    public DateTimeOffsetAssertions(DateTimeOffset? value)
+    private readonly AssertionChain assertionChain;
+
+    public DateTimeOffsetAssertions(DateTimeOffset? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -62,17 +65,15 @@ public DateTimeOffsetAssertions(DateTimeOffset? value)
     public AndConstraint<TAssertions> Be(DateTimeOffset expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .WithExpectation("Expected {context:the date and time} to represent the same point in time as {0}{reason}, ",
-                expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject == expected)
-            .FailWith("but {0} does not.", Subject)
-            .Then
-            .ClearExpectation();
+                expected, chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith("but found a <null> DateTimeOffset.")
+                    .Then
+                    .ForCondition(Subject == expected)
+                    .FailWith("but {0} does not.", Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -93,24 +94,21 @@ public AndConstraint<TAssertions> Be(DateTimeOffset? expected,
     {
         if (!expected.HasValue)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject.HasValue)
                 .FailWith("Expected {context:the date and time} to be <null>{reason}, but it was {0}.", Subject);
         }
         else
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .WithExpectation("Expected {context:the date and time} to represent the same point in time as {0}{reason}, ",
-                    expected)
-                .ForCondition(Subject.HasValue)
-                .FailWith("but found a <null> DateTimeOffset.")
-                .Then
-                .ForCondition(Subject == expected)
-                .FailWith("but {0} does not.", Subject)
-                .Then
-                .ClearExpectation();
+                    expected, chain => chain.ForCondition(Subject.HasValue)
+                        .FailWith("but found a <null> DateTimeOffset.")
+                        .Then
+                        .ForCondition(Subject == expected)
+                        .FailWith("but {0} does not.", Subject));
         }
 
         return new AndConstraint<TAssertions>((TAssertions)this);
@@ -130,7 +128,7 @@ public AndConstraint<TAssertions> Be(DateTimeOffset? expected,
     public AndConstraint<TAssertions> NotBe(DateTimeOffset unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -154,7 +152,7 @@ public AndConstraint<TAssertions> NotBe(DateTimeOffset unexpected,
     public AndConstraint<TAssertions> NotBe(DateTimeOffset? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -178,16 +176,14 @@ public AndConstraint<TAssertions> NotBe(DateTimeOffset? unexpected,
     public AndConstraint<TAssertions> BeExactly(DateTimeOffset expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:the date and time} to be exactly {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.EqualsExact(expected))
-            .FailWith("but it was {0}.", Subject)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:the date and time} to be exactly {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.EqualsExact(expected))
+                .FailWith("but it was {0}.", Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -209,23 +205,21 @@ public AndConstraint<TAssertions> BeExactly(DateTimeOffset? expected,
     {
         if (!expected.HasValue)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject.HasValue)
                 .FailWith("Expected {context:the date and time} to be <null>{reason}, but it was {0}.", Subject);
         }
         else
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected {context:the date and time} to be exactly {0}{reason}, ", expected)
-                .ForCondition(Subject.HasValue)
-                .FailWith("but found a <null> DateTimeOffset.")
-                .Then
-                .ForCondition(Subject.Value.EqualsExact(expected.Value))
-                .FailWith("but it was {0}.", Subject)
-                .Then
-                .ClearExpectation();
+                .WithExpectation("Expected {context:the date and time} to be exactly {0}{reason}, ", expected, chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith("but found a <null> DateTimeOffset.")
+                    .Then
+                    .ForCondition(Subject.Value.EqualsExact(expected.Value))
+                    .FailWith("but it was {0}.", Subject));
         }
 
         return new AndConstraint<TAssertions>((TAssertions)this);
@@ -246,7 +240,7 @@ public AndConstraint<TAssertions> BeExactly(DateTimeOffset? expected,
     public AndConstraint<TAssertions> NotBeExactly(DateTimeOffset unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject?.EqualsExact(unexpected) != true)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:the date and time} to be exactly {0}{reason}, but it was.", unexpected);
@@ -268,7 +262,7 @@ public AndConstraint<TAssertions> NotBeExactly(DateTimeOffset unexpected,
     public AndConstraint<TAssertions> NotBeExactly(DateTimeOffset? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!((Subject == null && unexpected == null) ||
                 (Subject != null && unexpected != null && Subject.Value.EqualsExact(unexpected.Value))))
             .BecauseOf(because, becauseArgs)
@@ -312,16 +306,15 @@ public AndConstraint<TAssertions> BeCloseTo(DateTimeOffset nearbyTime, TimeSpan
 
         TimeSpan? difference = (Subject - nearbyTime)?.Duration();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:the date and time} to be within {0} from {1}{reason}", precision, nearbyTime)
-            .ForCondition(Subject is not null)
-            .FailWith(", but found <null>.")
-            .Then
-            .ForCondition(Subject >= minimumValue && Subject <= maximumValue)
-            .FailWith(", but {0} was off by {1}.", Subject, difference)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:the date and time} to be within {0} from {1}{reason}", precision, nearbyTime,
+                chain => chain
+                    .ForCondition(Subject is not null)
+                    .FailWith(", but found <null>.")
+                    .Then
+                    .ForCondition(Subject >= minimumValue && Subject <= maximumValue)
+                    .FailWith(", but {0} was off by {1}.", Subject, difference));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -359,7 +352,7 @@ public AndConstraint<TAssertions> NotBeCloseTo(DateTimeOffset distantTime, TimeS
         long distanceToMaxInTicks = (DateTimeOffset.MaxValue - distantTime).Ticks;
         DateTimeOffset maximumValue = distantTime.AddTicks(Math.Min(precision.Ticks, distanceToMaxInTicks));
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < minimumValue || Subject > maximumValue)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -384,7 +377,7 @@ public AndConstraint<TAssertions> NotBeCloseTo(DateTimeOffset distantTime, TimeS
     public AndConstraint<TAssertions> BeBefore(DateTimeOffset expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be before {0}{reason}, but it was {1}.", expected,
@@ -424,7 +417,7 @@ public AndConstraint<TAssertions> NotBeBefore(DateTimeOffset unexpected,
     public AndConstraint<TAssertions> BeOnOrBefore(DateTimeOffset expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject <= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be on or before {0}{reason}, but it was {1}.", expected,
@@ -464,7 +457,7 @@ public AndConstraint<TAssertions> NotBeOnOrBefore(DateTimeOffset unexpected,
     public AndConstraint<TAssertions> BeAfter(DateTimeOffset expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject > expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be after {0}{reason}, but it was {1}.", expected,
@@ -504,7 +497,7 @@ public AndConstraint<TAssertions> NotBeAfter(DateTimeOffset unexpected,
     public AndConstraint<TAssertions> BeOnOrAfter(DateTimeOffset expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject >= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be on or after {0}{reason}, but it was {1}.", expected,
@@ -544,16 +537,14 @@ public AndConstraint<TAssertions> NotBeOnOrAfter(DateTimeOffset unexpected,
     public AndConstraint<TAssertions> HaveYear(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the year part of {context:the date} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Year == expected)
-            .FailWith("but it was {0}.", Subject.Value.Year)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the year part of {context:the date} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Year == expected)
+                .FailWith("but it was {0}.", Subject.Value.Year));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -572,16 +563,14 @@ public AndConstraint<TAssertions> HaveYear(int expected,
     public AndConstraint<TAssertions> NotHaveYear(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the year part of {context:the date} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Year != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the year part of {context:the date} to be {0}{reason}, ", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Year != unexpected)
+                .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -600,16 +589,14 @@ public AndConstraint<TAssertions> NotHaveYear(int unexpected,
     public AndConstraint<TAssertions> HaveMonth(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the month part of {context:the date} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Month == expected)
-            .FailWith("but it was {0}.", Subject.Value.Month)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the month part of {context:the date} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Month == expected)
+                .FailWith("but it was {0}.", Subject.Value.Month));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -628,16 +615,14 @@ public AndConstraint<TAssertions> HaveMonth(int expected,
     public AndConstraint<TAssertions> NotHaveMonth(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the month part of {context:the date} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Month != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the month part of {context:the date} to be {0}{reason}, ", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Month != unexpected)
+                .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -656,16 +641,14 @@ public AndConstraint<TAssertions> NotHaveMonth(int unexpected,
     public AndConstraint<TAssertions> HaveDay(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the day part of {context:the date} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Day == expected)
-            .FailWith("but it was {0}.", Subject.Value.Day)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the day part of {context:the date} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Day == expected)
+                .FailWith("but it was {0}.", Subject.Value.Day));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -684,16 +667,14 @@ public AndConstraint<TAssertions> HaveDay(int expected,
     public AndConstraint<TAssertions> NotHaveDay(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the day part of {context:the date} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Day != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the day part of {context:the date} to be {0}{reason}, ", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Day != unexpected)
+                .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -712,16 +693,14 @@ public AndConstraint<TAssertions> NotHaveDay(int unexpected,
     public AndConstraint<TAssertions> HaveHour(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the hour part of {context:the time} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Hour == expected)
-            .FailWith("but it was {0}.", Subject.Value.Hour)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the hour part of {context:the time} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Hour == expected)
+                .FailWith("but it was {0}.", Subject.Value.Hour));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -740,16 +719,14 @@ public AndConstraint<TAssertions> HaveHour(int expected,
     public AndConstraint<TAssertions> NotHaveHour(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the hour part of {context:the time} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Hour != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the hour part of {context:the time} to be {0}{reason}, ", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Hour != unexpected)
+                .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -768,16 +745,14 @@ public AndConstraint<TAssertions> NotHaveHour(int unexpected,
     public AndConstraint<TAssertions> HaveMinute(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the minute part of {context:the time} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Minute == expected)
-            .FailWith("but it was {0}.", Subject.Value.Minute)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the minute part of {context:the time} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Minute == expected)
+                .FailWith("but it was {0}.", Subject.Value.Minute));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -796,16 +771,15 @@ public AndConstraint<TAssertions> HaveMinute(int expected,
     public AndConstraint<TAssertions> NotHaveMinute(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the minute part of {context:the time} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Minute != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the minute part of {context:the time} to be {0}{reason}, ", unexpected,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith("but found a <null> DateTimeOffset.")
+                    .Then
+                    .ForCondition(Subject.Value.Minute != unexpected)
+                    .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -824,16 +798,14 @@ public AndConstraint<TAssertions> NotHaveMinute(int unexpected,
     public AndConstraint<TAssertions> HaveSecond(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the seconds part of {context:the time} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Second == expected)
-            .FailWith("but it was {0}.", Subject.Value.Second)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the seconds part of {context:the time} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Second == expected)
+                .FailWith("but it was {0}.", Subject.Value.Second));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -852,16 +824,15 @@ public AndConstraint<TAssertions> HaveSecond(int expected,
     public AndConstraint<TAssertions> NotHaveSecond(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the seconds part of {context:the time} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Second != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the seconds part of {context:the time} to be {0}{reason}, ", unexpected,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith("but found a <null> DateTimeOffset.")
+                    .Then
+                    .ForCondition(Subject.Value.Second != unexpected)
+                    .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -880,16 +851,14 @@ public AndConstraint<TAssertions> NotHaveSecond(int unexpected,
     public AndConstraint<TAssertions> HaveOffset(TimeSpan expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the offset of {context:the date} to be {0}{reason}, ", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Offset == expected)
-            .FailWith("but it was {0}.", Subject.Value.Offset)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the offset of {context:the date} to be {0}{reason}, ", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Offset == expected)
+                .FailWith("but it was {0}.", Subject.Value.Offset));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -908,16 +877,14 @@ public AndConstraint<TAssertions> HaveOffset(TimeSpan expected,
     public AndConstraint<TAssertions> NotHaveOffset(TimeSpan unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the offset of {context:the date} to be {0}{reason}, ", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Offset != unexpected)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the offset of {context:the date} to be {0}{reason}, ", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith("but found a <null> DateTimeOffset.")
+                .Then
+                .ForCondition(Subject.Value.Offset != unexpected)
+                .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -931,7 +898,8 @@ public AndConstraint<TAssertions> NotHaveOffset(TimeSpan unexpected,
     /// </param>
     public DateTimeOffsetRangeAssertions<TAssertions> BeMoreThan(TimeSpan timeSpan)
     {
-        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.MoreThan, timeSpan);
+        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject,
+            TimeSpanCondition.MoreThan, timeSpan);
     }
 
     /// <summary>
@@ -944,7 +912,8 @@ public DateTimeOffsetRangeAssertions<TAssertions> BeMoreThan(TimeSpan timeSpan)
     /// </param>
     public DateTimeOffsetRangeAssertions<TAssertions> BeAtLeast(TimeSpan timeSpan)
     {
-        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.AtLeast, timeSpan);
+        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject,
+            TimeSpanCondition.AtLeast, timeSpan);
     }
 
     /// <summary>
@@ -956,7 +925,8 @@ public DateTimeOffsetRangeAssertions<TAssertions> BeAtLeast(TimeSpan timeSpan)
     /// </param>
     public DateTimeOffsetRangeAssertions<TAssertions> BeExactly(TimeSpan timeSpan)
     {
-        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.Exactly, timeSpan);
+        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject,
+            TimeSpanCondition.Exactly, timeSpan);
     }
 
     /// <summary>
@@ -968,7 +938,8 @@ public DateTimeOffsetRangeAssertions<TAssertions> BeExactly(TimeSpan timeSpan)
     /// </param>
     public DateTimeOffsetRangeAssertions<TAssertions> BeWithin(TimeSpan timeSpan)
     {
-        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.Within, timeSpan);
+        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject,
+            TimeSpanCondition.Within, timeSpan);
     }
 
     /// <summary>
@@ -980,7 +951,8 @@ public DateTimeOffsetRangeAssertions<TAssertions> BeWithin(TimeSpan timeSpan)
     /// </param>
     public DateTimeOffsetRangeAssertions<TAssertions> BeLessThan(TimeSpan timeSpan)
     {
-        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, Subject, TimeSpanCondition.LessThan, timeSpan);
+        return new DateTimeOffsetRangeAssertions<TAssertions>((TAssertions)this, assertionChain, Subject,
+            TimeSpanCondition.LessThan, timeSpan);
     }
 
     /// <summary>
@@ -999,16 +971,15 @@ public AndConstraint<TAssertions> BeSameDateAs(DateTimeOffset expected,
     {
         DateTime expectedDate = expected.Date;
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the date part of {context:the date and time} to be {0}{reason}, ", expectedDate)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.", expectedDate)
-            .Then
-            .ForCondition(Subject.Value.Date == expectedDate)
-            .FailWith("but it was {0}.", Subject.Value.Date)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the date part of {context:the date and time} to be {0}{reason}, ", expectedDate,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith("but found a <null> DateTimeOffset.", expectedDate)
+                    .Then
+                    .ForCondition(Subject.Value.Date == expectedDate)
+                    .FailWith("but it was {0}.", Subject.Value.Date));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1029,16 +1000,15 @@ public AndConstraint<TAssertions> NotBeSameDateAs(DateTimeOffset unexpected,
     {
         DateTime unexpectedDate = unexpected.Date;
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the date part of {context:the date and time} to be {0}{reason}, ", unexpectedDate)
-            .ForCondition(Subject.HasValue)
-            .FailWith("but found a <null> DateTimeOffset.")
-            .Then
-            .ForCondition(Subject.Value.Date != unexpectedDate)
-            .FailWith("but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the date part of {context:the date and time} to be {0}{reason}, ", unexpectedDate,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith("but found a <null> DateTimeOffset.")
+                    .Then
+                    .ForCondition(Subject.Value.Date != unexpectedDate)
+                    .FailWith("but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -1100,7 +1070,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateTimeOffset> validValue
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<DateTimeOffset?> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be one of {0}{reason}, but it was {1}.", validValues, Subject);
diff --git a/Src/FluentAssertions/Primitives/DateTimeOffsetRangeAssertions.cs b/Src/FluentAssertions/Primitives/DateTimeOffsetRangeAssertions.cs
index deea7a999e..964b73c9db 100644
--- a/Src/FluentAssertions/Primitives/DateTimeOffsetRangeAssertions.cs
+++ b/Src/FluentAssertions/Primitives/DateTimeOffsetRangeAssertions.cs
@@ -23,6 +23,7 @@ public class DateTimeOffsetRangeAssertions<TAssertions>
     #region Private Definitions
 
     private readonly TAssertions parentAssertions;
+    private readonly AssertionChain assertionChain;
     private readonly TimeSpanPredicate predicate;
 
     private readonly Dictionary<TimeSpanCondition, TimeSpanPredicate> predicates = new()
@@ -39,11 +40,13 @@ public class DateTimeOffsetRangeAssertions<TAssertions>
 
     #endregion
 
-    protected internal DateTimeOffsetRangeAssertions(TAssertions parentAssertions, DateTimeOffset? subject,
+    protected internal DateTimeOffsetRangeAssertions(TAssertions parentAssertions, AssertionChain assertionChain,
+        DateTimeOffset? subject,
         TimeSpanCondition condition,
         TimeSpan timeSpan)
     {
         this.parentAssertions = parentAssertions;
+        this.assertionChain = assertionChain;
         this.subject = subject;
         this.timeSpan = timeSpan;
 
@@ -66,17 +69,17 @@ protected internal DateTimeOffsetRangeAssertions(TAssertions parentAssertions, D
     public AndConstraint<TAssertions> Before(DateTimeOffset target,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be " + predicate.DisplayText +
                 " {0} before {1}{reason}, but found a <null> DateTime.", timeSpan, target);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             TimeSpan actual = target - subject.Value;
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(predicate.IsMatchedBy(actual, timeSpan))
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -104,17 +107,17 @@ public AndConstraint<TAssertions> Before(DateTimeOffset target,
     public AndConstraint<TAssertions> After(DateTimeOffset target,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the date and time} to be " + predicate.DisplayText +
                 " {0} after {1}{reason}, but found a <null> DateTime.", timeSpan, target);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             TimeSpan actual = subject.Value - target;
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(predicate.IsMatchedBy(actual, timeSpan))
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
diff --git a/Src/FluentAssertions/Primitives/DateTimeRangeAssertions.cs b/Src/FluentAssertions/Primitives/DateTimeRangeAssertions.cs
index c6976b51bc..6192cfa16b 100644
--- a/Src/FluentAssertions/Primitives/DateTimeRangeAssertions.cs
+++ b/Src/FluentAssertions/Primitives/DateTimeRangeAssertions.cs
@@ -23,6 +23,7 @@ public class DateTimeRangeAssertions<TAssertions>
     #region Private Definitions
 
     private readonly TAssertions parentAssertions;
+    private readonly AssertionChain assertionChain;
     private readonly TimeSpanPredicate predicate;
 
     private readonly Dictionary<TimeSpanCondition, TimeSpanPredicate> predicates = new()
@@ -39,11 +40,13 @@ public class DateTimeRangeAssertions<TAssertions>
 
     #endregion
 
-    protected internal DateTimeRangeAssertions(TAssertions parentAssertions, DateTime? subject,
+    protected internal DateTimeRangeAssertions(TAssertions parentAssertions, AssertionChain assertionChain,
+        DateTime? subject,
         TimeSpanCondition condition,
         TimeSpan timeSpan)
     {
         this.parentAssertions = parentAssertions;
+        this.assertionChain = assertionChain;
         this.subject = subject;
         this.timeSpan = timeSpan;
 
@@ -66,18 +69,18 @@ protected internal DateTimeRangeAssertions(TAssertions parentAssertions, DateTim
     public AndConstraint<TAssertions> Before(DateTime target,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected date and/or time {0} to be " + predicate.DisplayText +
                 " {1} before {2}{reason}, but found a <null> DateTime.",
                 subject, timeSpan, target);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             TimeSpan actual = target - subject.Value;
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(predicate.IsMatchedBy(actual, timeSpan))
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -105,18 +108,18 @@ public AndConstraint<TAssertions> Before(DateTime target,
     public AndConstraint<TAssertions> After(DateTime target,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected date and/or time {0} to be " + predicate.DisplayText +
                 " {1} after {2}{reason}, but found a <null> DateTime.",
                 subject, timeSpan, target);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             TimeSpan actual = subject.Value - target;
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(predicate.IsMatchedBy(actual, timeSpan))
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
diff --git a/Src/FluentAssertions/Primitives/EnumAssertions.cs b/Src/FluentAssertions/Primitives/EnumAssertions.cs
index 69d8b110ef..b740b3c7d3 100644
--- a/Src/FluentAssertions/Primitives/EnumAssertions.cs
+++ b/Src/FluentAssertions/Primitives/EnumAssertions.cs
@@ -15,8 +15,8 @@ namespace FluentAssertions.Primitives;
 public class EnumAssertions<TEnum> : EnumAssertions<TEnum, EnumAssertions<TEnum>>
     where TEnum : struct, Enum
 {
-    public EnumAssertions(TEnum subject)
-        : base(subject)
+    public EnumAssertions(TEnum subject, AssertionChain assertionChain)
+        : base(subject, assertionChain)
     {
     }
 }
@@ -30,13 +30,16 @@ public class EnumAssertions<TEnum, TAssertions>
     where TEnum : struct, Enum
     where TAssertions : EnumAssertions<TEnum, TAssertions>
 {
-    public EnumAssertions(TEnum subject)
-        : this((TEnum?)subject)
+    private readonly AssertionChain assertionChain;
+
+    public EnumAssertions(TEnum subject, AssertionChain assertionChain)
+        : this((TEnum?)subject, assertionChain)
     {
     }
 
-    private protected EnumAssertions(TEnum? value)
+    private protected EnumAssertions(TEnum? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -56,7 +59,7 @@ private protected EnumAssertions(TEnum? value)
     public AndConstraint<TAssertions> Be(TEnum expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject?.Equals(expected) == true)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to be {0}{reason}, but found {1}.",
@@ -79,7 +82,7 @@ public AndConstraint<TAssertions> Be(TEnum expected,
     public AndConstraint<TAssertions> Be(TEnum? expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Nullable.Equals(Subject, expected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to be {0}{reason}, but found {1}.",
@@ -102,7 +105,7 @@ public AndConstraint<TAssertions> Be(TEnum? expected,
     public AndConstraint<TAssertions> NotBe(TEnum unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject?.Equals(unexpected) != true)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} not to be {0}{reason}, but it is.", unexpected);
@@ -124,7 +127,7 @@ public AndConstraint<TAssertions> NotBe(TEnum unexpected,
     public AndConstraint<TAssertions> NotBe(TEnum? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Nullable.Equals(Subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} not to be {0}{reason}, but it is.", unexpected);
@@ -142,18 +145,17 @@ public AndConstraint<TAssertions> NotBe(TEnum? unexpected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> BeDefined([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> BeDefined([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:the enum} to be defined in {0}{reason}, ", typeof(TEnum))
-            .ForCondition(Subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .ForCondition(Enum.IsDefined(typeof(TEnum), Subject))
-            .FailWith("but it is not.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:the enum} to be defined in {0}{reason}, ", typeof(TEnum), chain => chain
+                .ForCondition(Subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .ForCondition(Enum.IsDefined(typeof(TEnum), Subject))
+                .FailWith("but it is not."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -168,18 +170,17 @@ public AndConstraint<TAssertions> BeDefined([StringSyntax("CompositeFormat")] st
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotBeDefined([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeDefined([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect {context:the enum} to be defined in {0}{reason}, ", typeof(TEnum))
-            .ForCondition(Subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .ForCondition(!Enum.IsDefined(typeof(TEnum), Subject))
-            .FailWith("but it is.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect {context:the enum} to be defined in {0}{reason}, ", typeof(TEnum), chain => chain
+                .ForCondition(Subject is not null)
+                .FailWith("but found <null>.")
+                .Then
+                .ForCondition(!Enum.IsDefined(typeof(TEnum), Subject))
+                .FailWith("but it is."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -198,7 +199,7 @@ public AndConstraint<TAssertions> NotBeDefined([StringSyntax("CompositeFormat")]
     public AndConstraint<TAssertions> HaveValue(decimal expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is { } value && GetValue(value) == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to have value {0}{reason}, but found {1}.",
@@ -221,7 +222,7 @@ public AndConstraint<TAssertions> HaveValue(decimal expected,
     public AndConstraint<TAssertions> NotHaveValue(decimal unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!(Subject is { } value && GetValue(value) == unexpected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to not have value {0}{reason}, but found {1}.",
@@ -245,7 +246,7 @@ public AndConstraint<TAssertions> HaveSameValueAs<T>(T expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where T : struct, Enum
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is { } value && GetValue(value) == GetValue(expected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to have same value as {0}{reason}, but found {1}.",
@@ -269,7 +270,7 @@ public AndConstraint<TAssertions> NotHaveSameValueAs<T>(T unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where T : struct, Enum
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!(Subject is { } value && GetValue(value) == GetValue(unexpected)))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to not have same value as {0}{reason}, but found {1}.",
@@ -293,7 +294,7 @@ public AndConstraint<TAssertions> HaveSameNameAs<T>(T expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where T : struct, Enum
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is { } value && GetName(value) == GetName(expected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to have same name as {0}{reason}, but found {1}.",
@@ -317,7 +318,7 @@ public AndConstraint<TAssertions> NotHaveSameNameAs<T>(T unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where T : struct, Enum
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!(Subject is { } value && GetName(value) == GetName(unexpected)))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to not have same name as {0}{reason}, but found {1}.",
@@ -340,7 +341,7 @@ public AndConstraint<TAssertions> NotHaveSameNameAs<T>(T unexpected,
     public AndConstraint<TAssertions> HaveFlag(TEnum expectedFlag,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject?.HasFlag(expectedFlag) == true)
             .FailWith("Expected {context:the enum} to have flag {0}{reason}, but found {1}.", expectedFlag, Subject);
@@ -362,7 +363,7 @@ public AndConstraint<TAssertions> HaveFlag(TEnum expectedFlag,
     public AndConstraint<TAssertions> NotHaveFlag(TEnum unexpectedFlag,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject?.HasFlag(unexpectedFlag) != true)
             .FailWith("Expected {context:the enum} to not have flag {0}{reason}.", unexpectedFlag);
@@ -389,7 +390,7 @@ public AndConstraint<TAssertions> Match(Expression<Func<TEnum?, bool>> predicate
     {
         Guard.ThrowIfArgumentIsNull(predicate, nameof(predicate), "Cannot match an enum against a <null> predicate.");
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(predicate.Compile()(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:the enum} to match {1}{reason}, but found {0}.", Subject, predicate.Body);
@@ -432,7 +433,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<TEnum> validValues,
         Guard.ThrowIfArgumentIsEmpty(validValues, nameof(validValues),
             "Cannot assert that an enum is one of an empty list of enums");
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:the enum} to be one of {0}{reason}, but found <null>", validValues)
             .Then
diff --git a/Src/FluentAssertions/Primitives/GuidAssertions.cs b/Src/FluentAssertions/Primitives/GuidAssertions.cs
index 648faa7964..d30fe808df 100644
--- a/Src/FluentAssertions/Primitives/GuidAssertions.cs
+++ b/Src/FluentAssertions/Primitives/GuidAssertions.cs
@@ -11,8 +11,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class GuidAssertions : GuidAssertions<GuidAssertions>
 {
-    public GuidAssertions(Guid? value)
-        : base(value)
+    public GuidAssertions(Guid? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -26,8 +26,11 @@ public GuidAssertions(Guid? value)
 public class GuidAssertions<TAssertions>
     where TAssertions : GuidAssertions<TAssertions>
 {
-    public GuidAssertions(Guid? value)
+    private readonly AssertionChain assertionChain;
+
+    public GuidAssertions(Guid? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -50,7 +53,7 @@ public GuidAssertions(Guid? value)
     /// </param>
     public AndConstraint<TAssertions> BeEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == Guid.Empty)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:Guid} to be empty{reason}, but found {0}.", Subject);
@@ -70,7 +73,7 @@ public AndConstraint<TAssertions> BeEmpty([StringSyntax("CompositeFormat")] stri
     /// </param>
     public AndConstraint<TAssertions> NotBeEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is { } value && value != Guid.Empty)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:Guid} to be empty{reason}.");
@@ -119,7 +122,7 @@ public AndConstraint<TAssertions> Be(string expected,
     public AndConstraint<TAssertions> Be(Guid expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:Guid} to be {0}{reason}, but found {1}.", expected, Subject);
@@ -164,7 +167,7 @@ public AndConstraint<TAssertions> NotBe(string unexpected,
     public AndConstraint<TAssertions> NotBe(Guid unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:Guid} to be {0}{reason}.", Subject);
diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs
index f688e7a32f..e483ac43b7 100644
--- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs
+++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs
@@ -12,8 +12,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class HttpResponseMessageAssertions : HttpResponseMessageAssertions<HttpResponseMessageAssertions>
 {
-    public HttpResponseMessageAssertions(HttpResponseMessage value)
-        : base(value)
+    public HttpResponseMessageAssertions(HttpResponseMessage value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -25,9 +25,12 @@ public HttpResponseMessageAssertions(HttpResponseMessage value)
 public class HttpResponseMessageAssertions<TAssertions> : ObjectAssertions<HttpResponseMessage, TAssertions>
     where TAssertions : HttpResponseMessageAssertions<TAssertions>
 {
-    protected HttpResponseMessageAssertions(HttpResponseMessage value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    protected HttpResponseMessageAssertions(HttpResponseMessage value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -42,14 +45,14 @@ protected HttpResponseMessageAssertions(HttpResponseMessage value)
     /// </param>
     public AndConstraint<TAssertions> BeSuccessful([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but HttpResponseMessage was <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject!.IsSuccessStatusCode)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but found {0}.", Subject.StatusCode);
@@ -70,14 +73,14 @@ public AndConstraint<TAssertions> BeSuccessful([StringSyntax("CompositeFormat")]
     /// </param>
     public AndConstraint<TAssertions> BeRedirection([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but HttpResponseMessage was <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition((int)Subject!.StatusCode is >= 300 and <= 399)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but found {0}.", Subject.StatusCode);
@@ -98,14 +101,14 @@ public AndConstraint<TAssertions> BeRedirection([StringSyntax("CompositeFormat")
     /// </param>
     public AndConstraint<TAssertions> HaveError([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode to be an error{reason}, but HttpResponseMessage was <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(IsClientError() || IsServerError())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode to be an error{reason}, but found {0}.", Subject.StatusCode);
@@ -126,14 +129,14 @@ public AndConstraint<TAssertions> HaveError([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> HaveClientError([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but HttpResponseMessage was <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(IsClientError())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but found {0}.", Subject.StatusCode);
@@ -154,14 +157,14 @@ public AndConstraint<TAssertions> HaveClientError([StringSyntax("CompositeFormat
     /// </param>
     public AndConstraint<TAssertions> HaveServerError([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but HttpResponseMessage was <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(IsServerError())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but found {0}.", Subject.StatusCode);
@@ -184,14 +187,14 @@ public AndConstraint<TAssertions> HaveServerError([StringSyntax("CompositeFormat
     public AndConstraint<TAssertions> HaveStatusCode(HttpStatusCode expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode to be {0}{reason}, but HttpResponseMessage was <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject!.StatusCode == expected)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode to be {0}{reason}, but found {1}.", expected, Subject.StatusCode);
@@ -214,14 +217,14 @@ public AndConstraint<TAssertions> HaveStatusCode(HttpStatusCode expected,
     public AndConstraint<TAssertions> NotHaveStatusCode(HttpStatusCode unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected HttpStatusCode not to be {0}{reason}, but HttpResponseMessage was <null>.", unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject!.StatusCode != unexpected)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected HttpStatusCode not to be {0}{reason}, but found {1}.", unexpected, Subject.StatusCode);
diff --git a/Src/FluentAssertions/Primitives/IStringComparisonStrategy.cs b/Src/FluentAssertions/Primitives/IStringComparisonStrategy.cs
index da95c7ccbb..6dffb8b1f4 100644
--- a/Src/FluentAssertions/Primitives/IStringComparisonStrategy.cs
+++ b/Src/FluentAssertions/Primitives/IStringComparisonStrategy.cs
@@ -15,5 +15,5 @@ internal interface IStringComparisonStrategy
     /// <summary>
     /// Asserts that the <paramref name="subject"/> matches the <paramref name="expected"/> value.
     /// </summary>
-    void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected);
+    void ValidateAgainstMismatch(AssertionChain assertionChain, string subject, string expected);
 }
diff --git a/Src/FluentAssertions/Primitives/NullableBooleanAssertions.cs b/Src/FluentAssertions/Primitives/NullableBooleanAssertions.cs
index 6b5954d946..0a856363fa 100644
--- a/Src/FluentAssertions/Primitives/NullableBooleanAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableBooleanAssertions.cs
@@ -10,8 +10,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableBooleanAssertions : NullableBooleanAssertions<NullableBooleanAssertions>
 {
-    public NullableBooleanAssertions(bool? value)
-        : base(value)
+    public NullableBooleanAssertions(bool? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -23,9 +23,12 @@ public NullableBooleanAssertions(bool? value)
 public class NullableBooleanAssertions<TAssertions> : BooleanAssertions<TAssertions>
     where TAssertions : NullableBooleanAssertions<TAssertions>
 {
-    public NullableBooleanAssertions(bool? value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public NullableBooleanAssertions(bool? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -40,7 +43,7 @@ public NullableBooleanAssertions(bool? value)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected a value{reason}.");
@@ -75,7 +78,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect a value{reason}, but found {0}.", Subject);
@@ -112,7 +115,7 @@ public AndConstraint<TAssertions> BeNull([StringSyntax("CompositeFormat")] strin
     public AndConstraint<TAssertions> Be(bool? expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {0}{reason}, but found {1}.", expected, Subject);
@@ -134,7 +137,7 @@ public AndConstraint<TAssertions> Be(bool? expected,
     public AndConstraint<TAssertions> NotBe(bool? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable boolean} not to be {0}{reason}, but found {1}.", unexpected, Subject);
@@ -154,7 +157,7 @@ public AndConstraint<TAssertions> NotBe(bool? unexpected,
     /// </param>
     public AndConstraint<TAssertions> NotBeFalse([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not false)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable boolean} not to be {0}{reason}, but found {1}.", false, Subject);
@@ -174,7 +177,7 @@ public AndConstraint<TAssertions> NotBeFalse([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> NotBeTrue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not true)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable boolean} not to be {0}{reason}, but found {1}.", true, Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableDateOnlyAssertions.cs b/Src/FluentAssertions/Primitives/NullableDateOnlyAssertions.cs
index b4733fbf01..ecdde62a34 100644
--- a/Src/FluentAssertions/Primitives/NullableDateOnlyAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableDateOnlyAssertions.cs
@@ -13,8 +13,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableDateOnlyAssertions : NullableDateOnlyAssertions<NullableDateOnlyAssertions>
 {
-    public NullableDateOnlyAssertions(DateOnly? value)
-        : base(value)
+    public NullableDateOnlyAssertions(DateOnly? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -26,9 +26,12 @@ public NullableDateOnlyAssertions(DateOnly? value)
 public class NullableDateOnlyAssertions<TAssertions> : DateOnlyAssertions<TAssertions>
     where TAssertions : NullableDateOnlyAssertions<TAssertions>
 {
-    public NullableDateOnlyAssertions(DateOnly? value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public NullableDateOnlyAssertions(DateOnly? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -43,7 +46,7 @@ public NullableDateOnlyAssertions(DateOnly? value)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable date} to have a value{reason}, but found {0}.", Subject);
@@ -78,7 +81,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:nullable date} to have a value{reason}, but found {0}.", Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableDateTimeAssertions.cs b/Src/FluentAssertions/Primitives/NullableDateTimeAssertions.cs
index 2f897eeaa0..d7b8f1bc13 100644
--- a/Src/FluentAssertions/Primitives/NullableDateTimeAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableDateTimeAssertions.cs
@@ -15,8 +15,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableDateTimeAssertions : NullableDateTimeAssertions<NullableDateTimeAssertions>
 {
-    public NullableDateTimeAssertions(DateTime? expected)
-        : base(expected)
+    public NullableDateTimeAssertions(DateTime? expected, AssertionChain assertionChain)
+        : base(expected, assertionChain)
     {
     }
 }
@@ -31,9 +31,12 @@ public NullableDateTimeAssertions(DateTime? expected)
 public class NullableDateTimeAssertions<TAssertions> : DateTimeAssertions<TAssertions>
     where TAssertions : NullableDateTimeAssertions<TAssertions>
 {
-    public NullableDateTimeAssertions(DateTime? expected)
-        : base(expected)
+    private readonly AssertionChain assertionChain;
+
+    public NullableDateTimeAssertions(DateTime? expected, AssertionChain assertionChain)
+        : base(expected, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -48,7 +51,7 @@ public NullableDateTimeAssertions(DateTime? expected)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable date and time} to have a value{reason}, but found {0}.", Subject);
@@ -83,7 +86,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:nullable date and time} to have a value{reason}, but found {0}.", Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableDateTimeOffsetAssertions.cs b/Src/FluentAssertions/Primitives/NullableDateTimeOffsetAssertions.cs
index 48553d4ada..3508fb2f36 100644
--- a/Src/FluentAssertions/Primitives/NullableDateTimeOffsetAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableDateTimeOffsetAssertions.cs
@@ -15,8 +15,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableDateTimeOffsetAssertions : NullableDateTimeOffsetAssertions<NullableDateTimeOffsetAssertions>
 {
-    public NullableDateTimeOffsetAssertions(DateTimeOffset? expected)
-        : base(expected)
+    public NullableDateTimeOffsetAssertions(DateTimeOffset? expected, AssertionChain assertionChain)
+        : base(expected, assertionChain)
     {
     }
 }
@@ -32,9 +32,12 @@ public NullableDateTimeOffsetAssertions(DateTimeOffset? expected)
 public class NullableDateTimeOffsetAssertions<TAssertions> : DateTimeOffsetAssertions<TAssertions>
     where TAssertions : NullableDateTimeOffsetAssertions<TAssertions>
 {
-    public NullableDateTimeOffsetAssertions(DateTimeOffset? expected)
-        : base(expected)
+    private readonly AssertionChain assertionChain;
+
+    public NullableDateTimeOffsetAssertions(DateTimeOffset? expected, AssertionChain assertionChain)
+        : base(expected, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -49,7 +52,7 @@ public NullableDateTimeOffsetAssertions(DateTimeOffset? expected)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:variable} to have a value{reason}, but found {0}", Subject);
@@ -85,7 +88,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "",
         params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:variable} to have a value{reason}, but found {0}", Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableEnumAssertions.cs b/Src/FluentAssertions/Primitives/NullableEnumAssertions.cs
index 85f2ce95e6..7096c1ab53 100644
--- a/Src/FluentAssertions/Primitives/NullableEnumAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableEnumAssertions.cs
@@ -10,8 +10,8 @@ namespace FluentAssertions.Primitives;
 public class NullableEnumAssertions<TEnum> : NullableEnumAssertions<TEnum, NullableEnumAssertions<TEnum>>
     where TEnum : struct, Enum
 {
-    public NullableEnumAssertions(TEnum? subject)
-        : base(subject)
+    public NullableEnumAssertions(TEnum? subject, AssertionChain assertionChain)
+        : base(subject, assertionChain)
     {
     }
 }
@@ -23,9 +23,12 @@ public class NullableEnumAssertions<TEnum, TAssertions> : EnumAssertions<TEnum,
     where TEnum : struct, Enum
     where TAssertions : NullableEnumAssertions<TEnum, TAssertions>
 {
-    public NullableEnumAssertions(TEnum? subject)
-        : base(subject)
+    private readonly AssertionChain assertionChain;
+
+    public NullableEnumAssertions(TEnum? subject, AssertionChain assertionChain)
+        : base(subject, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -40,12 +43,12 @@ public NullableEnumAssertions(TEnum? subject)
     /// </param>
     public AndWhichConstraint<TAssertions, TEnum> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable enum} to have a value{reason}, but found {0}.", Subject);
 
-        return new AndWhichConstraint<TAssertions, TEnum>((TAssertions)this, Subject.GetValueOrDefault());
+        return new AndWhichConstraint<TAssertions, TEnum>((TAssertions)this, Subject.GetValueOrDefault(), assertionChain, ".Value");
     }
 
     /// <summary>
@@ -75,7 +78,7 @@ public AndWhichConstraint<TAssertions, TEnum> NotBeNull([StringSyntax("Composite
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:nullable enum} to have a value{reason}, but found {0}.", Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableGuidAssertions.cs b/Src/FluentAssertions/Primitives/NullableGuidAssertions.cs
index 45c26f7915..1eea1e758b 100644
--- a/Src/FluentAssertions/Primitives/NullableGuidAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableGuidAssertions.cs
@@ -11,8 +11,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableGuidAssertions : NullableGuidAssertions<NullableGuidAssertions>
 {
-    public NullableGuidAssertions(Guid? value)
-        : base(value)
+    public NullableGuidAssertions(Guid? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -24,9 +24,12 @@ public NullableGuidAssertions(Guid? value)
 public class NullableGuidAssertions<TAssertions> : GuidAssertions<TAssertions>
     where TAssertions : NullableGuidAssertions<TAssertions>
 {
-    public NullableGuidAssertions(Guid? value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public NullableGuidAssertions(Guid? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -41,7 +44,7 @@ public NullableGuidAssertions(Guid? value)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected a value{reason}.");
@@ -76,7 +79,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect a value{reason}, but found {0}.", Subject);
@@ -112,7 +115,7 @@ public AndConstraint<TAssertions> BeNull([StringSyntax("CompositeFormat")] strin
     /// </param>
     public AndConstraint<TAssertions> Be(Guid? expected, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:Guid} to be {0}{reason}, but found {1}.", expected, Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableSimpleTimeSpanAssertions.cs b/Src/FluentAssertions/Primitives/NullableSimpleTimeSpanAssertions.cs
index da52304bd1..03ffb3d9bd 100644
--- a/Src/FluentAssertions/Primitives/NullableSimpleTimeSpanAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableSimpleTimeSpanAssertions.cs
@@ -15,8 +15,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableSimpleTimeSpanAssertions : NullableSimpleTimeSpanAssertions<NullableSimpleTimeSpanAssertions>
 {
-    public NullableSimpleTimeSpanAssertions(TimeSpan? value)
-        : base(value)
+    public NullableSimpleTimeSpanAssertions(TimeSpan? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -32,9 +32,12 @@ public NullableSimpleTimeSpanAssertions(TimeSpan? value)
 public class NullableSimpleTimeSpanAssertions<TAssertions> : SimpleTimeSpanAssertions<TAssertions>
     where TAssertions : NullableSimpleTimeSpanAssertions<TAssertions>
 {
-    public NullableSimpleTimeSpanAssertions(TimeSpan? value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public NullableSimpleTimeSpanAssertions(TimeSpan? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -49,7 +52,7 @@ public NullableSimpleTimeSpanAssertions(TimeSpan? value)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected a value{reason}.");
@@ -84,7 +87,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect a value{reason}, but found {0}.", Subject);
@@ -121,7 +124,7 @@ public AndConstraint<TAssertions> BeNull([StringSyntax("CompositeFormat")] strin
     public AndConstraint<TAssertions> Be(TimeSpan? expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {0}{reason}, but found {1}.", expected, Subject);
diff --git a/Src/FluentAssertions/Primitives/NullableTimeOnlyAssertions.cs b/Src/FluentAssertions/Primitives/NullableTimeOnlyAssertions.cs
index d0235efee0..8e6ede5140 100644
--- a/Src/FluentAssertions/Primitives/NullableTimeOnlyAssertions.cs
+++ b/Src/FluentAssertions/Primitives/NullableTimeOnlyAssertions.cs
@@ -13,8 +13,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class NullableTimeOnlyAssertions : NullableTimeOnlyAssertions<NullableTimeOnlyAssertions>
 {
-    public NullableTimeOnlyAssertions(TimeOnly? value)
-        : base(value)
+    public NullableTimeOnlyAssertions(TimeOnly? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -26,9 +26,12 @@ public NullableTimeOnlyAssertions(TimeOnly? value)
 public class NullableTimeOnlyAssertions<TAssertions> : TimeOnlyAssertions<TAssertions>
     where TAssertions : NullableTimeOnlyAssertions<TAssertions>
 {
-    public NullableTimeOnlyAssertions(TimeOnly? value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public NullableTimeOnlyAssertions(TimeOnly? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -43,7 +46,7 @@ public NullableTimeOnlyAssertions(TimeOnly? value)
     /// </param>
     public AndConstraint<TAssertions> HaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:nullable time} to have a value{reason}, but found {0}.", Subject);
@@ -78,7 +81,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     /// </param>
     public AndConstraint<TAssertions> NotHaveValue([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Subject.HasValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:nullable time} to have a value{reason}, but found {0}.", Subject);
diff --git a/Src/FluentAssertions/Primitives/ObjectAssertions.cs b/Src/FluentAssertions/Primitives/ObjectAssertions.cs
index d6bdccfab0..9c536c3d66 100644
--- a/Src/FluentAssertions/Primitives/ObjectAssertions.cs
+++ b/Src/FluentAssertions/Primitives/ObjectAssertions.cs
@@ -13,9 +13,12 @@ namespace FluentAssertions.Primitives;
 /// </summary>
 public class ObjectAssertions : ObjectAssertions<object, ObjectAssertions>
 {
-    public ObjectAssertions(object value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public ObjectAssertions(object value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -38,7 +41,7 @@ public AndConstraint<ObjectAssertions> Be<TExpectation>(TExpectation expected, I
     {
         Guard.ThrowIfArgumentIsNull(comparer);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is TExpectation subject && comparer.Equals(subject, expected))
             .WithDefaultIdentifier(Identifier)
@@ -68,7 +71,7 @@ public AndConstraint<ObjectAssertions> NotBe<TExpectation>(TExpectation unexpect
     {
         Guard.ThrowIfArgumentIsNull(comparer);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not TExpectation subject || !comparer.Equals(subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -102,7 +105,7 @@ public AndConstraint<ObjectAssertions> BeOneOf<TExpectation>(IEnumerable<TExpect
         Guard.ThrowIfArgumentIsNull(validValues);
         Guard.ThrowIfArgumentIsNull(comparer);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is TExpectation subject && validValues.Contains(subject, comparer))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to be one of {0}{reason}, but found {1}.", validValues, Subject);
@@ -119,9 +122,12 @@ public AndConstraint<ObjectAssertions> BeOneOf<TExpectation>(IEnumerable<TExpect
 public class ObjectAssertions<TSubject, TAssertions> : ReferenceTypeAssertions<TSubject, TAssertions>
     where TAssertions : ObjectAssertions<TSubject, TAssertions>
 {
-    public ObjectAssertions(TSubject value)
-        : base(value)
+    private readonly AssertionChain assertionChain;
+
+    public ObjectAssertions(TSubject value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -138,12 +144,11 @@ public ObjectAssertions(TSubject value)
     public AndConstraint<TAssertions> Be(TSubject expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(ObjectExtensions.GetComparer<TSubject>()(Subject, expected))
             .WithDefaultIdentifier(Identifier)
-            .FailWith("Expected {context} to be {0}{reason}, but found {1}.", expected,
-                Subject);
+            .FailWith("Expected {context} to be {0}{reason}, but found {1}.", expected, Subject);
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -168,7 +173,7 @@ public AndConstraint<TAssertions> Be(TSubject expected, IEqualityComparer<TSubje
     {
         Guard.ThrowIfArgumentIsNull(comparer);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(comparer.Equals(Subject, expected))
             .WithDefaultIdentifier(Identifier)
@@ -192,7 +197,7 @@ public AndConstraint<TAssertions> Be(TSubject expected, IEqualityComparer<TSubje
     public AndConstraint<TAssertions> NotBe(TSubject unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!ObjectExtensions.GetComparer<TSubject>()(Subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -221,7 +226,7 @@ public AndConstraint<TAssertions> NotBe(TSubject unexpected, IEqualityComparer<T
     {
         Guard.ThrowIfArgumentIsNull(comparer);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(!comparer.Equals(Subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -287,7 +292,7 @@ public AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expe
         EquivalencyOptions<TExpectation> options = config(AssertionOptions.CloneDefaults<TExpectation>());
 
         var context = new EquivalencyValidationContext(Node.From<TExpectation>(() =>
-            AssertionScope.Current.CallerIdentity), options)
+            CurrentAssertionChain.CallerIdentifier), options)
         {
             Reason = new Reason(because, becauseArgs),
             TraceWriter = options.TraceWriter
@@ -369,7 +374,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(
             hasMismatches = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(hasMismatches)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -405,7 +410,7 @@ public AndConstraint<TAssertions> BeOneOf(params TSubject[] validValues)
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<TSubject> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to be one of {0}{reason}, but found {1}.", validValues, Subject);
@@ -438,7 +443,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<TSubject> validValues,
         Guard.ThrowIfArgumentIsNull(validValues);
         Guard.ThrowIfArgumentIsNull(comparer);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject, comparer))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:object} to be one of {0}{reason}, but found {1}.", validValues, Subject);
diff --git a/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs b/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs
index 8817613104..9a08c161f7 100644
--- a/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs
+++ b/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs
@@ -17,8 +17,9 @@ namespace FluentAssertions.Primitives;
 public abstract class ReferenceTypeAssertions<TSubject, TAssertions>
     where TAssertions : ReferenceTypeAssertions<TSubject, TAssertions>
 {
-    protected ReferenceTypeAssertions(TSubject subject)
+    protected ReferenceTypeAssertions(TSubject subject, AssertionChain assertionChain)
     {
+        CurrentAssertionChain = assertionChain;
         Subject = subject;
     }
 
@@ -39,7 +40,7 @@ protected ReferenceTypeAssertions(TSubject subject)
     /// </param>
     public AndConstraint<TAssertions> BeNull([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -58,9 +59,10 @@ public AndConstraint<TAssertions> BeNull([StringSyntax("CompositeFormat")] strin
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -83,7 +85,7 @@ public AndConstraint<TAssertions> NotBeNull([StringSyntax("CompositeFormat")] st
     public AndConstraint<TAssertions> BeSameAs(TSubject expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(ReferenceEquals(Subject, expected))
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -106,7 +108,7 @@ public AndConstraint<TAssertions> BeSameAs(TSubject expected,
     public AndConstraint<TAssertions> NotBeSameAs(TSubject unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(!ReferenceEquals(Subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -126,7 +128,8 @@ public AndConstraint<TAssertions> NotBeSameAs(TSubject unexpected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndWhichConstraint<TAssertions, T> BeOfType<T>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndWhichConstraint<TAssertions, T> BeOfType<T>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         BeOfType(typeof(T), because, becauseArgs);
 
@@ -156,13 +159,13 @@ public AndConstraint<TAssertions> BeOfType(Type expectedType,
     {
         Guard.ThrowIfArgumentIsNull(expectedType);
 
-        bool success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier("type")
             .FailWith("Expected {context} to be {0}{reason}, but found <null>.", expectedType);
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
             Type subjectType = Subject.GetType();
 
@@ -190,7 +193,8 @@ public AndConstraint<TAssertions> BeOfType(Type expectedType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotBeOfType<T>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeOfType<T>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         NotBeOfType(typeof(T), because, becauseArgs);
 
@@ -216,13 +220,13 @@ public AndConstraint<TAssertions> NotBeOfType(Type unexpectedType,
     {
         Guard.ThrowIfArgumentIsNull(unexpectedType);
 
-        bool success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier("type")
             .FailWith("Expected {context} not to be {0}{reason}, but found <null>.", unexpectedType);
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
             Type subjectType = Subject.GetType();
 
@@ -250,18 +254,19 @@ public AndConstraint<TAssertions> NotBeOfType(Type unexpectedType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    /// <returns>An <see cref="AndWhichConstraint{TAssertions, T}"/> which can be used to chain assertions.</returns>
-    public AndWhichConstraint<TAssertions, T> BeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    /// <returns>An <see cref="AndWhichConstraint{TParent,TSubject}"/> which can be used to chain assertions.</returns>
+    public AndWhichConstraint<TAssertions, T> BeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier("type")
             .FailWith("Expected {context} to be assignable to {0}{reason}, but found <null>.", typeof(T));
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
-            Execute.Assertion
+            CurrentAssertionChain
                 .ForCondition(Subject is T)
                 .BecauseOf(because, becauseArgs)
                 .WithDefaultIdentifier(Identifier)
@@ -293,19 +298,19 @@ public AndConstraint<TAssertions> BeAssignableTo(Type type,
     {
         Guard.ThrowIfArgumentIsNull(type);
 
-        bool success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier("type")
             .FailWith("Expected {context} to be assignable to {0}{reason}, but found <null>.", type);
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
             bool isAssignable = type.IsGenericTypeDefinition
                 ? Subject.GetType().IsAssignableToOpenGeneric(type)
                 : type.IsAssignableFrom(Subject.GetType());
 
-            Execute.Assertion
+            CurrentAssertionChain
                 .ForCondition(isAssignable)
                 .BecauseOf(because, becauseArgs)
                 .WithDefaultIdentifier(Identifier)
@@ -329,7 +334,8 @@ public AndConstraint<TAssertions> BeAssignableTo(Type type,
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <returns>An <see cref="AndConstraint{TAssertions}"/> which can be used to chain assertions.</returns>
-    public AndConstraint<TAssertions> NotBeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotBeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBeAssignableTo(typeof(T), because, becauseArgs);
     }
@@ -352,19 +358,19 @@ public AndConstraint<TAssertions> NotBeAssignableTo(Type type,
     {
         Guard.ThrowIfArgumentIsNull(type);
 
-        bool success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier("type")
             .FailWith("Expected {context} to not be assignable to {0}{reason}, but found <null>.", type);
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
             bool isAssignable = type.IsGenericTypeDefinition
                 ? Subject.GetType().IsAssignableToOpenGeneric(type)
                 : type.IsAssignableFrom(Subject.GetType());
 
-            Execute.Assertion
+            CurrentAssertionChain
                 .ForCondition(!isAssignable)
                 .BecauseOf(because, becauseArgs)
                 .WithDefaultIdentifier(Identifier)
@@ -411,7 +417,7 @@ public AndConstraint<TAssertions> Match<T>(Expression<Func<T, bool>> predicate,
     {
         Guard.ThrowIfArgumentIsNull(predicate, nameof(predicate), "Cannot match an object against a <null> predicate.");
 
-        Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(predicate.Compile()((T)Subject))
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier(Identifier)
@@ -434,16 +440,17 @@ public AndConstraint<TAssertions> Satisfy<T>(Action<T> assertion)
     {
         Guard.ThrowIfArgumentIsNull(assertion, nameof(assertion), "Cannot verify an object against a <null> inspector.");
 
-        var success = Execute.Assertion
+        CurrentAssertionChain
             .ForCondition(Subject is not null)
             .WithDefaultIdentifier(Identifier)
             .FailWith("Expected {context:object} to be assignable to {0}{reason}, but found <null>.", typeof(T))
             .Then
             .ForCondition(Subject is T)
             .WithDefaultIdentifier(Identifier)
-            .FailWith("Expected {context:object} to be assignable to {0}{reason}, but {1} is not.", typeof(T), Subject?.GetType());
+            .FailWith("Expected {context:object} to be assignable to {0}{reason}, but {1} is not.", typeof(T),
+                Subject?.GetType());
 
-        if (success)
+        if (CurrentAssertionChain.Succeeded)
         {
             string[] failuresFromInspector;
 
@@ -458,10 +465,11 @@ public AndConstraint<TAssertions> Satisfy<T>(Action<T> assertion)
                 string failureMessage = Environment.NewLine
                     + string.Join(Environment.NewLine, failuresFromInspector.Select(x => x.IndentLines()));
 
-                Execute.Assertion
+                CurrentAssertionChain
                     .WithDefaultIdentifier(Identifier)
-                    .WithExpectation("Expected {context:object} to match inspector, but the inspector was not satisfied:", Subject)
-                    .FailWithPreFormatted(failureMessage);
+                    .WithExpectation("Expected {context:object} to match inspector, but the inspector was not satisfied:",
+                        Subject,
+                        chain => chain.FailWithPreFormatted(failureMessage));
             }
         }
 
@@ -477,4 +485,6 @@ public AndConstraint<TAssertions> Satisfy<T>(Action<T> assertion)
     /// <inheritdoc/>
     public override bool Equals(object obj) =>
         throw new NotSupportedException("Equals is not part of Fluent Assertions. Did you mean BeSameAs() instead?");
+
+    public AssertionChain CurrentAssertionChain { get; }
 }
diff --git a/Src/FluentAssertions/Primitives/SimpleTimeSpanAssertions.cs b/Src/FluentAssertions/Primitives/SimpleTimeSpanAssertions.cs
index 7387544b22..634feee5a7 100644
--- a/Src/FluentAssertions/Primitives/SimpleTimeSpanAssertions.cs
+++ b/Src/FluentAssertions/Primitives/SimpleTimeSpanAssertions.cs
@@ -12,8 +12,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class SimpleTimeSpanAssertions : SimpleTimeSpanAssertions<SimpleTimeSpanAssertions>
 {
-    public SimpleTimeSpanAssertions(TimeSpan? value)
-        : base(value)
+    public SimpleTimeSpanAssertions(TimeSpan? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -27,8 +27,11 @@ public SimpleTimeSpanAssertions(TimeSpan? value)
 public class SimpleTimeSpanAssertions<TAssertions>
     where TAssertions : SimpleTimeSpanAssertions<TAssertions>
 {
-    public SimpleTimeSpanAssertions(TimeSpan? value)
+    private readonly AssertionChain assertionChain;
+
+    public SimpleTimeSpanAssertions(TimeSpan? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -49,7 +52,7 @@ public SimpleTimeSpanAssertions(TimeSpan? value)
     /// </param>
     public AndConstraint<TAssertions> BePositive([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject > TimeSpan.Zero)
             .FailWith("Expected {context:time} to be positive{reason}, but found {0}.", Subject);
@@ -69,7 +72,7 @@ public AndConstraint<TAssertions> BePositive([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> BeNegative([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject < TimeSpan.Zero)
             .FailWith("Expected {context:time} to be negative{reason}, but found {0}.", Subject);
@@ -92,7 +95,7 @@ public AndConstraint<TAssertions> BeNegative([StringSyntax("CompositeFormat")] s
     public AndConstraint<TAssertions> Be(TimeSpan expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(expected == Subject)
             .FailWith("Expected {0}{reason}, but found {1}.", expected, Subject);
@@ -115,7 +118,7 @@ public AndConstraint<TAssertions> Be(TimeSpan expected,
     public AndConstraint<TAssertions> NotBe(TimeSpan unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(unexpected != Subject)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {0}{reason}.", unexpected);
@@ -138,7 +141,7 @@ public AndConstraint<TAssertions> NotBe(TimeSpan unexpected,
     public AndConstraint<TAssertions> BeLessThan(TimeSpan expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject < expected)
             .FailWith("Expected {context:time} to be less than {0}{reason}, but found {1}.", expected, Subject);
@@ -161,7 +164,7 @@ public AndConstraint<TAssertions> BeLessThan(TimeSpan expected,
     public AndConstraint<TAssertions> BeLessThanOrEqualTo(TimeSpan expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject <= expected)
             .FailWith("Expected {context:time} to be less than or equal to {0}{reason}, but found {1}.", expected, Subject);
@@ -184,7 +187,7 @@ public AndConstraint<TAssertions> BeLessThanOrEqualTo(TimeSpan expected,
     public AndConstraint<TAssertions> BeGreaterThan(TimeSpan expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject > expected)
             .FailWith("Expected {context:time} to be greater than {0}{reason}, but found {1}.", expected, Subject);
@@ -207,7 +210,7 @@ public AndConstraint<TAssertions> BeGreaterThan(TimeSpan expected,
     public AndConstraint<TAssertions> BeGreaterThanOrEqualTo(TimeSpan expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject >= expected)
             .FailWith("Expected {context:time} to be greater than or equal to {0}{reason}, but found {1}.", expected, Subject);
@@ -245,7 +248,7 @@ public AndConstraint<TAssertions> BeCloseTo(TimeSpan nearbyTime, TimeSpan precis
         TimeSpan minimumValue = nearbyTime - precision;
         TimeSpan maximumValue = nearbyTime + precision;
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject >= minimumValue && Subject.Value <= maximumValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be within {0} from {1}{reason}, but found {2}.",
@@ -285,7 +288,7 @@ public AndConstraint<TAssertions> NotBeCloseTo(TimeSpan distantTime, TimeSpan pr
         TimeSpan minimumValue = distantTime - precision;
         TimeSpan maximumValue = distantTime + precision;
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < minimumValue || Subject > maximumValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to not be within {0} from {1}{reason}, but found {2}.",
diff --git a/Src/FluentAssertions/Primitives/StringAssertions.cs b/Src/FluentAssertions/Primitives/StringAssertions.cs
index dbc6a5e7f2..7e1fac4730 100644
--- a/Src/FluentAssertions/Primitives/StringAssertions.cs
+++ b/Src/FluentAssertions/Primitives/StringAssertions.cs
@@ -20,8 +20,8 @@ public class StringAssertions : StringAssertions<StringAssertions>
     /// <summary>
     /// Initializes a new instance of the <see cref="StringAssertions"/> class.
     /// </summary>
-    public StringAssertions(string value)
-        : base(value)
+    public StringAssertions(string value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -33,12 +33,15 @@ public StringAssertions(string value)
 public class StringAssertions<TAssertions> : ReferenceTypeAssertions<string, TAssertions>
     where TAssertions : StringAssertions<TAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="StringAssertions{TAssertions}"/> class.
     /// </summary>
-    public StringAssertions(string value)
-        : base(value)
+    public StringAssertions(string value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -55,7 +58,7 @@ public StringAssertions(string value)
     public AndConstraint<TAssertions> Be(string expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var stringEqualityValidator = new StringValidator(
+        var stringEqualityValidator = new StringValidator(assertionChain,
             new StringEqualityStrategy(StringComparer.Ordinal, "be"),
             because, becauseArgs);
 
@@ -91,7 +94,7 @@ public AndConstraint<TAssertions> BeOneOf(params string[] validValues)
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<string> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to be one of {0}{reason}, but found {1}.", validValues, Subject);
@@ -116,7 +119,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<string> validValues,
     public AndConstraint<TAssertions> BeEquivalentTo(string expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var expectation = new StringValidator(
+        var expectation = new StringValidator(assertionChain,
             new StringEqualityStrategy(StringComparer.OrdinalIgnoreCase, "be equivalent to"),
             because, becauseArgs);
 
@@ -149,7 +152,7 @@ public AndConstraint<TAssertions> BeEquivalentTo(string expected,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var expectation = new StringValidator(
+        var expectation = new StringValidator(assertionChain,
             new StringEqualityStrategy(options.GetStringComparerOrDefault(), "be equivalent to"),
             because, becauseArgs);
 
@@ -185,7 +188,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to be equivalent to {0}{reason}, but they are.", unexpected);
@@ -223,7 +226,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to be equivalent to {0}{reason}, but they are.", unexpected);
@@ -246,7 +249,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo(string unexpected,
     public AndConstraint<TAssertions> NotBe(string unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to be {0}{reason}.", unexpected);
@@ -298,7 +301,7 @@ public AndConstraint<TAssertions> Match(string wildcardPattern,
         Guard.ThrowIfArgumentIsEmpty(wildcardPattern, nameof(wildcardPattern),
             "Cannot match string against an empty string. Provide a wildcard pattern or use the BeEmpty method.");
 
-        var stringWildcardMatchingValidator = new StringValidator(
+        var stringWildcardMatchingValidator = new StringValidator(assertionChain,
             new StringWildcardMatchingStrategy(),
             because, becauseArgs);
 
@@ -351,7 +354,7 @@ public AndConstraint<TAssertions> NotMatch(string wildcardPattern,
         Guard.ThrowIfArgumentIsEmpty(wildcardPattern, nameof(wildcardPattern),
             "Cannot match string against an empty string. Provide a wildcard pattern or use the NotBeEmpty method.");
 
-        var stringWildcardMatchingValidator = new StringValidator(
+        var stringWildcardMatchingValidator = new StringValidator(assertionChain,
             new StringWildcardMatchingStrategy
             {
                 Negate = true
@@ -407,7 +410,7 @@ public AndConstraint<TAssertions> MatchEquivalentOf(string wildcardPattern,
         Guard.ThrowIfArgumentIsEmpty(wildcardPattern, nameof(wildcardPattern),
             "Cannot match string against an empty string. Provide a wildcard pattern or use the BeEmpty method.");
 
-        var stringWildcardMatchingValidator = new StringValidator(
+        var stringWildcardMatchingValidator = new StringValidator(assertionChain,
             new StringWildcardMatchingStrategy
             {
                 IgnoreCase = true,
@@ -472,7 +475,7 @@ public AndConstraint<TAssertions> MatchEquivalentOf(string wildcardPattern,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var stringWildcardMatchingValidator = new StringValidator(
+        var stringWildcardMatchingValidator = new StringValidator(assertionChain,
             new StringWildcardMatchingStrategy
             {
                 IgnoreCase = options.IgnoreCase,
@@ -531,7 +534,7 @@ public AndConstraint<TAssertions> NotMatchEquivalentOf(string wildcardPattern,
         Guard.ThrowIfArgumentIsEmpty(wildcardPattern, nameof(wildcardPattern),
             "Cannot match string against an empty string. Provide a wildcard pattern or use the NotBeEmpty method.");
 
-        var stringWildcardMatchingValidator = new StringValidator(
+        var stringWildcardMatchingValidator = new StringValidator(assertionChain,
             new StringWildcardMatchingStrategy
             {
                 IgnoreCase = true,
@@ -597,7 +600,7 @@ public AndConstraint<TAssertions> NotMatchEquivalentOf(string wildcardPattern,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var stringWildcardMatchingValidator = new StringValidator(
+        var stringWildcardMatchingValidator = new StringValidator(assertionChain,
             new StringWildcardMatchingStrategy
             {
                 IgnoreCase = options.IgnoreCase,
@@ -648,7 +651,7 @@ public AndConstraint<TAssertions> MatchRegex([RegexPattern][StringSyntax("Regex"
         }
         catch (ArgumentException)
         {
-            Execute.Assertion.FailWith("Cannot match {context:string} against {0} because it is not a valid regular expression.",
+            assertionChain.FailWith("Cannot match {context:string} against {0} because it is not a valid regular expression.",
                 regularExpression);
 
             return new AndConstraint<TAssertions>((TAssertions)this);
@@ -685,7 +688,7 @@ public AndConstraint<TAssertions> MatchRegex([RegexPattern][StringSyntax("Regex"
         }
         catch (ArgumentException)
         {
-            Execute.Assertion.FailWith("Cannot match {context:string} against {0} because it is not a valid regular expression.",
+            assertionChain.FailWith("Cannot match {context:string} against {0} because it is not a valid regular expression.",
                 regularExpression);
 
             return new AndConstraint<TAssertions>((TAssertions)this);
@@ -727,17 +730,17 @@ public AndConstraint<TAssertions> MatchRegex(Regex regularExpression,
         Guard.ThrowIfArgumentIsEmpty(regexStr, nameof(regularExpression),
             "Cannot match string against an empty string. Provide a regex pattern or use the BeEmpty method.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .UsingLineBreaks
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to match regex {0}{reason}, but it was <null>.", regexStr);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             int actual = regularExpression.Matches(Subject!).Count;
 
-            Execute.Assertion
+            assertionChain
                 .ForConstraint(occurrenceConstraint, actual)
                 .UsingLineBreaks
                 .BecauseOf(because, becauseArgs)
@@ -775,15 +778,15 @@ public AndConstraint<TAssertions> MatchRegex(Regex regularExpression,
         Guard.ThrowIfArgumentIsEmpty(regexStr, nameof(regularExpression),
             "Cannot match string against an empty string. Provide a regex pattern or use the BeEmpty method.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .UsingLineBreaks
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to match regex {0}{reason}, but it was <null>.", regexStr);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(regularExpression.IsMatch(Subject!))
                 .BecauseOf(because, becauseArgs)
                 .UsingLineBreaks
@@ -821,7 +824,7 @@ public AndConstraint<TAssertions> NotMatchRegex([RegexPattern][StringSyntax("Reg
         }
         catch (ArgumentException)
         {
-            Execute.Assertion.FailWith("Cannot match {context:string} against {0} because it is not a valid regular expression.",
+            assertionChain.FailWith("Cannot match {context:string} against {0} because it is not a valid regular expression.",
                 regularExpression);
 
             return new AndConstraint<TAssertions>((TAssertions)this);
@@ -856,15 +859,15 @@ public AndConstraint<TAssertions> NotMatchRegex(Regex regularExpression,
         Guard.ThrowIfArgumentIsEmpty(regexStr, nameof(regularExpression),
             "Cannot match string against an empty regex pattern. Provide a regex pattern or use the NotBeEmpty method.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .UsingLineBreaks
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to not match regex {0}{reason}, but it was <null>.", regexStr);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!regularExpression.IsMatch(Subject!))
                 .BecauseOf(because, becauseArgs)
                 .UsingLineBreaks
@@ -892,7 +895,7 @@ public AndConstraint<TAssertions> StartWith(string expected,
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare start of string with <null>.");
 
-        var stringStartValidator = new StringValidator(
+        var stringStartValidator = new StringValidator(assertionChain,
             new StringStartStrategy(StringComparer.Ordinal, "start with"),
             because, becauseArgs);
 
@@ -927,7 +930,7 @@ public AndConstraint<TAssertions> NotStartWith(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != null && notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to start with {0}{reason}, but found {1}.", unexpected, Subject);
@@ -953,7 +956,7 @@ public AndConstraint<TAssertions> StartWithEquivalentOf(string expected,
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare string start equivalence with <null>.");
 
-        var stringStartValidator = new StringValidator(
+        var stringStartValidator = new StringValidator(assertionChain,
             new StringStartStrategy(StringComparer.OrdinalIgnoreCase, "start with equivalent of"),
             because, becauseArgs);
 
@@ -986,7 +989,7 @@ public AndConstraint<TAssertions> StartWithEquivalentOf(string expected,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var stringStartValidator = new StringValidator(
+        var stringStartValidator = new StringValidator(assertionChain,
             new StringStartStrategy(options.GetStringComparerOrDefault(), "start with equivalent of"),
             because, becauseArgs);
 
@@ -1023,7 +1026,7 @@ public AndConstraint<TAssertions> NotStartWithEquivalentOf(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != null && notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to start with equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1061,7 +1064,7 @@ public AndConstraint<TAssertions> NotStartWithEquivalentOf(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != null && notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to start with equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1087,7 +1090,7 @@ public AndConstraint<TAssertions> EndWith(string expected,
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare string end with <null>.");
 
-        var stringEndValidator = new StringValidator(
+        var stringEndValidator = new StringValidator(assertionChain,
             new StringEndStrategy(StringComparer.Ordinal, "end with"),
             because, becauseArgs);
 
@@ -1122,7 +1125,7 @@ public AndConstraint<TAssertions> NotEndWith(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != null && notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to end with {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1148,7 +1151,7 @@ public AndConstraint<TAssertions> EndWithEquivalentOf(string expected,
     {
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare string end equivalence with <null>.");
 
-        var stringEndValidator = new StringValidator(
+        var stringEndValidator = new StringValidator(assertionChain,
             new StringEndStrategy(StringComparer.OrdinalIgnoreCase, "end with equivalent of"),
             because, becauseArgs);
 
@@ -1181,7 +1184,7 @@ public AndConstraint<TAssertions> EndWithEquivalentOf(string expected,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var stringEndValidator = new StringValidator(
+        var stringEndValidator = new StringValidator(assertionChain,
             new StringEndStrategy(options.GetStringComparerOrDefault(), "end with equivalent of"),
             because, becauseArgs);
 
@@ -1218,7 +1221,7 @@ public AndConstraint<TAssertions> NotEndWithEquivalentOf(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != null && notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to end with equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1256,7 +1259,7 @@ public AndConstraint<TAssertions> NotEndWithEquivalentOf(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != null && notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to end with equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1285,7 +1288,7 @@ public AndConstraint<TAssertions> Contain(string expected,
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot assert string containment against <null>.");
         Guard.ThrowIfArgumentIsEmpty(expected, nameof(expected), "Cannot assert string containment against an empty string.");
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(Contains(Subject, expected, StringComparison.Ordinal))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} {0} to contain {1}{reason}.", Subject, expected);
@@ -1322,7 +1325,7 @@ public AndConstraint<TAssertions> Contain(string expected, OccurrenceConstraint
 
         int actual = Subject.CountSubstring(expected, StringComparer.Ordinal);
 
-        Execute.Assertion
+        assertionChain
             .ForConstraint(occurrenceConstraint, actual)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -1352,7 +1355,7 @@ public AndConstraint<TAssertions> ContainEquivalentOf(string expected,
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot assert string containment against <null>.");
         Guard.ThrowIfArgumentIsEmpty(expected, nameof(expected), "Cannot assert string containment against an empty string.");
 
-        var stringContainValidator = new StringValidatorSupportingNull(
+        var stringContainValidator = new StringValidatorSupportingNull(assertionChain,
             new StringContainsStrategy(StringComparer.OrdinalIgnoreCase, AtLeast.Once()),
             because, becauseArgs);
 
@@ -1418,7 +1421,7 @@ public AndConstraint<TAssertions> ContainEquivalentOf(string expected,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var stringContainValidator = new StringValidatorSupportingNull(
+        var stringContainValidator = new StringValidatorSupportingNull(assertionChain,
             new StringContainsStrategy(options.GetStringComparerOrDefault(), occurrenceConstraint),
             because, becauseArgs);
 
@@ -1459,7 +1462,7 @@ public AndConstraint<TAssertions> ContainEquivalentOf(string expected,
         Guard.ThrowIfArgumentIsEmpty(expected, nameof(expected), "Cannot assert string containment against an empty string.");
         Guard.ThrowIfArgumentIsNull(occurrenceConstraint);
 
-        var stringContainValidator = new StringValidatorSupportingNull(
+        var stringContainValidator = new StringValidatorSupportingNull(assertionChain,
             new StringContainsStrategy(StringComparer.OrdinalIgnoreCase, occurrenceConstraint),
             because, becauseArgs);
 
@@ -1488,7 +1491,7 @@ public AndConstraint<TAssertions> ContainAll(IEnumerable<string> values,
 
         IEnumerable<string> missing = values.Where(v => !Contains(Subject, v, StringComparison.Ordinal));
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(values.All(v => Contains(Subject, v, StringComparison.Ordinal)))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} {0} to contain the strings: {1}{reason}.", Subject, missing);
@@ -1525,7 +1528,7 @@ public AndConstraint<TAssertions> ContainAny(IEnumerable<string> values,
     {
         ThrowIfValuesNullOrEmpty(values);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(values.Any(v => Contains(Subject, v, StringComparison.Ordinal)))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} {0} to contain at least one of the strings: {1}{reason}.", Subject, values);
@@ -1565,7 +1568,7 @@ public AndConstraint<TAssertions> NotContain(string unexpected,
         Guard.ThrowIfArgumentIsNull(unexpected, nameof(unexpected), "Cannot assert string containment against <null>.");
         Guard.ThrowIfArgumentIsEmpty(unexpected, nameof(unexpected), "Cannot assert string containment against an empty string.");
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(!Contains(Subject, unexpected, StringComparison.Ordinal))
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} {0} to contain {1}{reason}.", Subject, unexpected);
@@ -1594,7 +1597,7 @@ public AndConstraint<TAssertions> NotContainAll(IEnumerable<string> values,
 
         var matches = values.Count(v => Contains(Subject, v, StringComparison.Ordinal));
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(matches != values.Count())
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} {0} to contain all of the strings: {1}{reason}.", Subject, values);
@@ -1634,7 +1637,7 @@ public AndConstraint<TAssertions> NotContainAny(IEnumerable<string> values,
 
         IEnumerable<string> matches = values.Where(v => Contains(Subject, v, StringComparison.Ordinal));
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(!matches.Any())
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} {0} to contain any of the strings: {1}{reason}.", Subject, matches);
@@ -1668,7 +1671,7 @@ public AndConstraint<TAssertions> NotContainAny(params string[] values)
     public AndConstraint<TAssertions> NotContainEquivalentOf(string unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!string.IsNullOrEmpty(unexpected) && Subject != null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} to contain the equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1681,7 +1684,7 @@ public AndConstraint<TAssertions> NotContainEquivalentOf(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} to contain the equivalent of {0}{reason} but found {1}.", unexpected, Subject);
@@ -1709,7 +1712,7 @@ public AndConstraint<TAssertions> NotContainEquivalentOf(string unexpected,
     {
         Guard.ThrowIfArgumentIsNull(config);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(!string.IsNullOrEmpty(unexpected) && Subject != null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} to contain the equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1722,7 +1725,7 @@ public AndConstraint<TAssertions> NotContainEquivalentOf(string unexpected,
             notEquivalent = scope.Discard().Length > 0;
         }
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(notEquivalent)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} to contain the equivalent of {0}{reason}, but found {1}.", unexpected, Subject);
@@ -1742,7 +1745,7 @@ public AndConstraint<TAssertions> NotContainEquivalentOf(string unexpected,
     /// </param>
     public AndConstraint<TAssertions> BeEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject?.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to be empty{reason}, but found {0}.", Subject);
@@ -1762,7 +1765,7 @@ public AndConstraint<TAssertions> BeEmpty([StringSyntax("CompositeFormat")] stri
     /// </param>
     public AndConstraint<TAssertions> NotBeEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is null || Subject.Length > 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:string} to be empty{reason}.");
@@ -1784,14 +1787,14 @@ public AndConstraint<TAssertions> NotBeEmpty([StringSyntax("CompositeFormat")] s
     public AndConstraint<TAssertions> HaveLength(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:string} with length {0}{reason}, but found <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.Length == expected)
                 .FailWith("Expected {context:string} with length {0}{reason}, but found string {1} with length {2}.",
@@ -1813,7 +1816,7 @@ public AndConstraint<TAssertions> HaveLength(int expected,
     /// </param>
     public AndConstraint<TAssertions> NotBeNullOrEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!string.IsNullOrEmpty(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to be <null> or empty{reason}, but found {0}.", Subject);
@@ -1833,7 +1836,7 @@ public AndConstraint<TAssertions> NotBeNullOrEmpty([StringSyntax("CompositeForma
     /// </param>
     public AndConstraint<TAssertions> BeNullOrEmpty([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(string.IsNullOrEmpty(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to be <null> or empty{reason}, but found {0}.", Subject);
@@ -1853,7 +1856,7 @@ public AndConstraint<TAssertions> BeNullOrEmpty([StringSyntax("CompositeFormat")
     /// </param>
     public AndConstraint<TAssertions> NotBeNullOrWhiteSpace([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!string.IsNullOrWhiteSpace(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} not to be <null> or whitespace{reason}, but found {0}.", Subject);
@@ -1873,7 +1876,7 @@ public AndConstraint<TAssertions> NotBeNullOrWhiteSpace([StringSyntax("Composite
     /// </param>
     public AndConstraint<TAssertions> BeNullOrWhiteSpace([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(string.IsNullOrWhiteSpace(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:string} to be <null> or whitespace{reason}, but found {0}.", Subject);
@@ -1898,7 +1901,7 @@ public AndConstraint<TAssertions> BeNullOrWhiteSpace([StringSyntax("CompositeFor
     /// </param>
     public AndConstraint<TAssertions> BeUpperCased([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null && !Subject.Any(char.IsLower))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all alphabetic characters in {context:string} to be upper-case{reason}, but found {0}.", Subject);
@@ -1923,7 +1926,7 @@ public AndConstraint<TAssertions> BeUpperCased([StringSyntax("CompositeFormat")]
     /// </param>
     public AndConstraint<TAssertions> NotBeUpperCased([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is null || HasMixedOrNoCase(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected some characters in {context:string} to be lower-case{reason}.");
@@ -1948,7 +1951,7 @@ public AndConstraint<TAssertions> NotBeUpperCased([StringSyntax("CompositeFormat
     /// </param>
     public AndConstraint<TAssertions> BeLowerCased([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null && !Subject.Any(char.IsUpper))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all alphabetic characters in {context:string} to be lower cased{reason}, but found {0}.", Subject);
@@ -1973,7 +1976,7 @@ public AndConstraint<TAssertions> BeLowerCased([StringSyntax("CompositeFormat")]
     /// </param>
     public AndConstraint<TAssertions> NotBeLowerCased([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject is null || HasMixedOrNoCase(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected some characters in {context:string} to be upper-case{reason}.");
@@ -2008,7 +2011,7 @@ internal AndConstraint<TAssertions> Be(string expected,
 
         EquivalencyOptions<string> options = config(AssertionOptions.CloneDefaults<string>());
 
-        var expectation = new StringValidator(
+        var expectation = new StringValidator(assertionChain,
             new StringEqualityStrategy(options.GetStringComparerOrDefault(), "be"),
             because, becauseArgs);
 
diff --git a/Src/FluentAssertions/Primitives/StringContainsStrategy.cs b/Src/FluentAssertions/Primitives/StringContainsStrategy.cs
index 46c8b5b2e1..c82a053b73 100644
--- a/Src/FluentAssertions/Primitives/StringContainsStrategy.cs
+++ b/Src/FluentAssertions/Primitives/StringContainsStrategy.cs
@@ -17,11 +17,11 @@ public StringContainsStrategy(IEqualityComparer<string> comparer, OccurrenceCons
 
     public string ExpectationDescription => "Expected {context:string} to contain the equivalent of ";
 
-    public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected)
+    public void ValidateAgainstMismatch(AssertionChain assertionChain, string subject, string expected)
     {
         int actual = subject.CountSubstring(expected, comparer);
 
-        assertion
+        assertionChain
             .ForConstraint(occurrenceConstraint, actual)
             .FailWith(
                 $"Expected {{context:string}} {{0}} to contain the equivalent of {{1}} {{expectedOccurrence}}{{reason}}, but found it {actual.Times()}.",
diff --git a/Src/FluentAssertions/Primitives/StringEndStrategy.cs b/Src/FluentAssertions/Primitives/StringEndStrategy.cs
index bdb59f9cbf..a2a332491f 100644
--- a/Src/FluentAssertions/Primitives/StringEndStrategy.cs
+++ b/Src/FluentAssertions/Primitives/StringEndStrategy.cs
@@ -17,11 +17,13 @@ public StringEndStrategy(IEqualityComparer<string> comparer, string predicateDes
 
     public string ExpectationDescription => "Expected {context:string} to " + predicateDescription + " ";
 
-    public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected)
+    public void ValidateAgainstMismatch(AssertionChain assertionChain, string subject, string expected)
     {
-        if (!assertion
-                .ForCondition(subject!.Length >= expected.Length)
-                .FailWith(ExpectationDescription + "{0}{reason}, but {1} is too short.", expected, subject))
+        assertionChain
+            .ForCondition(subject!.Length >= expected.Length)
+            .FailWith(ExpectationDescription + "{0}{reason}, but {1} is too short.", expected, subject);
+
+        if (!assertionChain.Succeeded)
         {
             return;
         }
@@ -33,7 +35,7 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
             return;
         }
 
-        assertion.FailWith(
+        assertionChain.FailWith(
             ExpectationDescription + "{0}{reason}, but {1} differs near " + subject.IndexedSegmentAt(indexOfMismatch) +
             ".",
             expected, subject);
diff --git a/Src/FluentAssertions/Primitives/StringEqualityStrategy.cs b/Src/FluentAssertions/Primitives/StringEqualityStrategy.cs
index 37ad2a72e5..d2c00a4ac0 100644
--- a/Src/FluentAssertions/Primitives/StringEqualityStrategy.cs
+++ b/Src/FluentAssertions/Primitives/StringEqualityStrategy.cs
@@ -18,9 +18,9 @@ public StringEqualityStrategy(IEqualityComparer<string> comparer, string predica
         this.predicateDescription = predicateDescription;
     }
 
-    public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected)
+    public void ValidateAgainstMismatch(AssertionChain assertionChain, string subject, string expected)
     {
-        ValidateAgainstSuperfluousWhitespace(assertion, subject, expected);
+        ValidateAgainstSuperfluousWhitespace(assertionChain, subject, expected);
 
         if (expected.IsLongOrMultiline() || subject.IsLongOrMultiline())
         {
@@ -28,7 +28,7 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
 
             if (indexOfMismatch == -1)
             {
-                ValidateAgainstLengthDifferences(assertion, subject, expected);
+                ValidateAgainstLengthDifferences(assertionChain, subject, expected);
                 return;
             }
 
@@ -43,18 +43,18 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
                 locationDescription = $"on line {lineNumber + 1} and column {column} (index {indexOfMismatch})";
             }
 
-            assertion.FailWith(
+            assertionChain.FailWith(
                 ExpectationDescription + "the same string{reason}, but they differ " + locationDescription + ":" +
                 Environment.NewLine
                 + GetMismatchSegmentForLongStrings(subject, expected, indexOfMismatch) + ".");
         }
-        else if (ValidateAgainstLengthDifferences(assertion, subject, expected))
+        else if (ValidateAgainstLengthDifferences(assertionChain, subject, expected))
         {
             int indexOfMismatch = subject.IndexOfFirstMismatch(expected, comparer);
 
             if (indexOfMismatch != -1)
             {
-                assertion.FailWith(
+                assertionChain.FailWith(
                     ExpectationDescription + "{0}{reason}, but {1} differs near " + subject.IndexedSegmentAt(indexOfMismatch) +
                     ".",
                     expected, subject);
@@ -64,7 +64,7 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
 
     public string ExpectationDescription => "Expected {context:string} to " + predicateDescription + " ";
 
-    private void ValidateAgainstSuperfluousWhitespace(IAssertionScope assertion, string subject, string expected)
+    private void ValidateAgainstSuperfluousWhitespace(AssertionChain assertion, string subject, string expected)
     {
         assertion
             .ForCondition(!(expected.Length > subject.Length && comparer.Equals(expected.TrimEnd(), subject)))
@@ -74,9 +74,9 @@ private void ValidateAgainstSuperfluousWhitespace(IAssertionScope assertion, str
             .FailWith(ExpectationDescription + "{0}{reason}, but it has unexpected whitespace at the end.", expected);
     }
 
-    private bool ValidateAgainstLengthDifferences(IAssertionScope assertion, string subject, string expected)
+    private bool ValidateAgainstLengthDifferences(AssertionChain assertion, string subject, string expected)
     {
-        return assertion
+        assertion
             .ForCondition(subject.Length == expected.Length)
             .FailWith(() =>
             {
@@ -87,6 +87,8 @@ private bool ValidateAgainstLengthDifferences(IAssertionScope assertion, string
 
                 return new FailReason(message, expected, expected.Length, subject, subject.Length);
             });
+
+        return assertion.Succeeded;
     }
 
     private string GetMismatchSegmentForStringsOfDifferentLengths(string subject, string expected)
diff --git a/Src/FluentAssertions/Primitives/StringStartStrategy.cs b/Src/FluentAssertions/Primitives/StringStartStrategy.cs
index e8bd42c53d..40b6b7e834 100644
--- a/Src/FluentAssertions/Primitives/StringStartStrategy.cs
+++ b/Src/FluentAssertions/Primitives/StringStartStrategy.cs
@@ -17,11 +17,13 @@ public StringStartStrategy(IEqualityComparer<string> comparer, string predicateD
 
     public string ExpectationDescription => "Expected {context:string} to " + predicateDescription + " ";
 
-    public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected)
+    public void ValidateAgainstMismatch(AssertionChain assertionChain, string subject, string expected)
     {
-        if (!assertion
-                .ForCondition(subject.Length >= expected.Length)
-                .FailWith(ExpectationDescription + "{0}{reason}, but {1} is too short.", expected, subject))
+        assertionChain
+            .ForCondition(subject.Length >= expected.Length)
+            .FailWith(ExpectationDescription + "{0}{reason}, but {1} is too short.", expected, subject);
+
+        if (!assertionChain.Succeeded)
         {
             return;
         }
@@ -33,7 +35,7 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
             return;
         }
 
-        assertion.FailWith(
+        assertionChain.FailWith(
             ExpectationDescription + "{0}{reason}, but {1} differs near " + subject.IndexedSegmentAt(indexOfMismatch) +
             ".",
             expected, subject);
diff --git a/Src/FluentAssertions/Primitives/StringValidator.cs b/Src/FluentAssertions/Primitives/StringValidator.cs
index 8e7e49d7a0..e3402dde81 100644
--- a/Src/FluentAssertions/Primitives/StringValidator.cs
+++ b/Src/FluentAssertions/Primitives/StringValidator.cs
@@ -1,4 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
 
@@ -7,12 +6,13 @@ namespace FluentAssertions.Primitives;
 internal class StringValidator
 {
     private readonly IStringComparisonStrategy comparisonStrategy;
-    private IAssertionScope assertion;
+    private AssertionChain assertionChain;
 
-    public StringValidator(IStringComparisonStrategy comparisonStrategy, [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
+    public StringValidator(AssertionChain assertionChain, IStringComparisonStrategy comparisonStrategy, string because,
+        object[] becauseArgs)
     {
         this.comparisonStrategy = comparisonStrategy;
-        assertion = Execute.Assertion.BecauseOf(because, becauseArgs);
+        this.assertionChain = assertionChain.BecauseOf(because, becauseArgs);
     }
 
     public void Validate(string subject, string expected)
@@ -29,10 +29,10 @@ public void Validate(string subject, string expected)
 
         if (expected.IsLongOrMultiline() || subject.IsLongOrMultiline())
         {
-            assertion = assertion.UsingLineBreaks;
+            assertionChain = assertionChain.UsingLineBreaks;
         }
 
-        comparisonStrategy.ValidateAgainstMismatch(assertion, subject, expected);
+        comparisonStrategy.ValidateAgainstMismatch(assertionChain, subject, expected);
     }
 
     private bool ValidateAgainstNulls(string subject, string expected)
@@ -42,7 +42,7 @@ private bool ValidateAgainstNulls(string subject, string expected)
             return true;
         }
 
-        assertion.FailWith(comparisonStrategy.ExpectationDescription + "{0}{reason}, but found {1}.", expected, subject);
+        assertionChain.FailWith(comparisonStrategy.ExpectationDescription + "{0}{reason}, but found {1}.", expected, subject);
         return false;
     }
 }
diff --git a/Src/FluentAssertions/Primitives/StringValidatorSupportingNull.cs b/Src/FluentAssertions/Primitives/StringValidatorSupportingNull.cs
index deaf451a21..f0a20b55e7 100644
--- a/Src/FluentAssertions/Primitives/StringValidatorSupportingNull.cs
+++ b/Src/FluentAssertions/Primitives/StringValidatorSupportingNull.cs
@@ -7,12 +7,13 @@ namespace FluentAssertions.Primitives;
 internal class StringValidatorSupportingNull
 {
     private readonly IStringComparisonStrategy comparisonStrategy;
-    private IAssertionScope assertion;
+    private AssertionChain assertionChain;
 
-    public StringValidatorSupportingNull(IStringComparisonStrategy comparisonStrategy, [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
+    public StringValidatorSupportingNull(AssertionChain assertionChain, IStringComparisonStrategy comparisonStrategy,
+        [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
     {
         this.comparisonStrategy = comparisonStrategy;
-        assertion = Execute.Assertion.BecauseOf(because, becauseArgs);
+        this.assertionChain = assertionChain.BecauseOf(because, becauseArgs);
     }
 
     public void Validate(string subject, string expected)
@@ -25,9 +26,9 @@ public void Validate(string subject, string expected)
         if (expected?.IsLongOrMultiline() == true ||
             subject?.IsLongOrMultiline() == true)
         {
-            assertion = assertion.UsingLineBreaks;
+            assertionChain = assertionChain.UsingLineBreaks;
         }
 
-        comparisonStrategy.ValidateAgainstMismatch(assertion, subject, expected);
+        comparisonStrategy.ValidateAgainstMismatch(assertionChain, subject, expected);
     }
 }
diff --git a/Src/FluentAssertions/Primitives/StringWildcardMatchingStrategy.cs b/Src/FluentAssertions/Primitives/StringWildcardMatchingStrategy.cs
index 82afb98462..eca22d9815 100644
--- a/Src/FluentAssertions/Primitives/StringWildcardMatchingStrategy.cs
+++ b/Src/FluentAssertions/Primitives/StringWildcardMatchingStrategy.cs
@@ -8,7 +8,7 @@ namespace FluentAssertions.Primitives;
 
 internal class StringWildcardMatchingStrategy : IStringComparisonStrategy
 {
-    public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected)
+    public void ValidateAgainstMismatch(AssertionChain assertionChain, string subject, string expected)
     {
         bool isMatch = IsMatch(subject, expected);
 
@@ -19,11 +19,11 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
 
         if (Negate)
         {
-            assertion.FailWith(ExpectationDescription + "but {1} matches.", expected, subject);
+            assertionChain.FailWith(ExpectationDescription + "but {1} matches.", expected, subject);
         }
         else
         {
-            assertion.FailWith(ExpectationDescription + "but {1} does not.", expected, subject);
+            assertionChain.FailWith(ExpectationDescription + "but {1} does not.", expected, subject);
         }
     }
 
diff --git a/Src/FluentAssertions/Primitives/TimeOnlyAssertions.cs b/Src/FluentAssertions/Primitives/TimeOnlyAssertions.cs
index ce959601fe..ed92a9c0cb 100644
--- a/Src/FluentAssertions/Primitives/TimeOnlyAssertions.cs
+++ b/Src/FluentAssertions/Primitives/TimeOnlyAssertions.cs
@@ -16,8 +16,8 @@ namespace FluentAssertions.Primitives;
 [DebuggerNonUserCode]
 public class TimeOnlyAssertions : TimeOnlyAssertions<TimeOnlyAssertions>
 {
-    public TimeOnlyAssertions(TimeOnly? value)
-        : base(value)
+    public TimeOnlyAssertions(TimeOnly? value, AssertionChain assertionChain)
+        : base(value, assertionChain)
     {
     }
 }
@@ -31,8 +31,11 @@ public TimeOnlyAssertions(TimeOnly? value)
 public class TimeOnlyAssertions<TAssertions>
     where TAssertions : TimeOnlyAssertions<TAssertions>
 {
-    public TimeOnlyAssertions(TimeOnly? value)
+    private readonly AssertionChain assertionChain;
+
+    public TimeOnlyAssertions(TimeOnly? value, AssertionChain assertionChain)
     {
+        this.assertionChain = assertionChain;
         Subject = value;
     }
 
@@ -55,7 +58,7 @@ public TimeOnlyAssertions(TimeOnly? value)
     public AndConstraint<TAssertions> Be(TimeOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be {0}{reason}, but found {1}.",
@@ -78,7 +81,7 @@ public AndConstraint<TAssertions> Be(TimeOnly expected,
     public AndConstraint<TAssertions> Be(TimeOnly? expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be {0}{reason}, but found {1}.",
@@ -101,7 +104,7 @@ public AndConstraint<TAssertions> Be(TimeOnly? expected,
     public AndConstraint<TAssertions> NotBe(TimeOnly unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} not to be {0}{reason}, but it is.", unexpected);
@@ -123,7 +126,7 @@ public AndConstraint<TAssertions> NotBe(TimeOnly unexpected,
     public AndConstraint<TAssertions> NotBe(TimeOnly? unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject != unexpected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} not to be {0}{reason}, but it is.", unexpected);
@@ -158,16 +161,15 @@ public AndConstraint<TAssertions> BeCloseTo(TimeOnly nearbyTime, TimeSpan precis
             ? MinimumDifference(Subject.Value, nearbyTime)
             : null;
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected {context:the time} to be within {0} from {1}{reason}, ", precision, nearbyTime)
-            .ForCondition(Subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .ForCondition(Subject?.IsCloseTo(nearbyTime, precision) == true)
-            .FailWith("but {0} was off by {1}.", Subject, difference)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected {context:the time} to be within {0} from {1}{reason}, ", precision, nearbyTime,
+                chain => chain
+                    .ForCondition(Subject is not null)
+                    .FailWith("but found <null>.")
+                    .Then
+                    .ForCondition(Subject?.IsCloseTo(nearbyTime, precision) == true)
+                    .FailWith("but {0} was off by {1}.", Subject, difference));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -203,16 +205,15 @@ public AndConstraint<TAssertions> NotBeCloseTo(TimeOnly distantTime, TimeSpan pr
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect {context:the time} to be within {0} from {1}{reason}, ", precision, distantTime)
-            .ForCondition(Subject is not null)
-            .FailWith("but found <null>.")
-            .Then
-            .ForCondition(Subject?.IsCloseTo(distantTime, precision) == false)
-            .FailWith("but it was {0}.", Subject)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect {context:the time} to be within {0} from {1}{reason}, ", precision, distantTime,
+                chain => chain
+                    .ForCondition(Subject is not null)
+                    .FailWith("but found <null>.")
+                    .Then
+                    .ForCondition(Subject?.IsCloseTo(distantTime, precision) == false)
+                    .FailWith("but it was {0}.", Subject));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -231,7 +232,7 @@ public AndConstraint<TAssertions> NotBeCloseTo(TimeOnly distantTime, TimeSpan pr
     public AndConstraint<TAssertions> BeBefore(TimeOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject < expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be before {0}{reason}, but found {1}.", expected,
@@ -271,7 +272,7 @@ public AndConstraint<TAssertions> NotBeBefore(TimeOnly unexpected,
     public AndConstraint<TAssertions> BeOnOrBefore(TimeOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject <= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be on or before {0}{reason}, but found {1}.", expected,
@@ -311,7 +312,7 @@ public AndConstraint<TAssertions> NotBeOnOrBefore(TimeOnly unexpected,
     public AndConstraint<TAssertions> BeAfter(TimeOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject > expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be after {0}{reason}, but found {1}.", expected,
@@ -351,7 +352,7 @@ public AndConstraint<TAssertions> NotBeAfter(TimeOnly unexpected,
     public AndConstraint<TAssertions> BeOnOrAfter(TimeOnly expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject >= expected)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be on or after {0}{reason}, but found {1}.", expected,
@@ -391,16 +392,14 @@ public AndConstraint<TAssertions> NotBeOnOrAfter(TimeOnly unexpected,
     public AndConstraint<TAssertions> HaveHours(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the hours part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found <null>.")
-            .Then
-            .ForCondition(Subject.Value.Hour == expected)
-            .FailWith(", but found {0}.", Subject.Value.Hour)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the hours part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found <null>.")
+                .Then
+                .ForCondition(Subject.Value.Hour == expected)
+                .FailWith(", but found {0}.", Subject.Value.Hour));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -419,7 +418,7 @@ public AndConstraint<TAssertions> HaveHours(int expected,
     public AndConstraint<TAssertions> NotHaveHours(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject.HasValue)
             .FailWith("Did not expect the hours part of {context:the time} to be {0}{reason}, but found a <null> TimeOnly.",
@@ -446,16 +445,14 @@ public AndConstraint<TAssertions> NotHaveHours(int unexpected,
     public AndConstraint<TAssertions> HaveMinutes(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the minutes part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> TimeOnly.")
-            .Then
-            .ForCondition(Subject.Value.Minute == expected)
-            .FailWith(", but found {0}.", Subject.Value.Minute)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the minutes part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> TimeOnly.")
+                .Then
+                .ForCondition(Subject.Value.Minute == expected)
+                .FailWith(", but found {0}.", Subject.Value.Minute));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -474,16 +471,14 @@ public AndConstraint<TAssertions> HaveMinutes(int expected,
     public AndConstraint<TAssertions> NotHaveMinutes(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the minutes part of {context:the time} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> TimeOnly.")
-            .Then
-            .ForCondition(Subject.Value.Minute != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the minutes part of {context:the time} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> TimeOnly.")
+                .Then
+                .ForCondition(Subject.Value.Minute != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -502,16 +497,14 @@ public AndConstraint<TAssertions> NotHaveMinutes(int unexpected,
     public AndConstraint<TAssertions> HaveSeconds(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the seconds part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> TimeOnly.")
-            .Then
-            .ForCondition(Subject.Value.Second == expected)
-            .FailWith(", but found {0}.", Subject.Value.Second)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the seconds part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> TimeOnly.")
+                .Then
+                .ForCondition(Subject.Value.Second == expected)
+                .FailWith(", but found {0}.", Subject.Value.Second));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -530,16 +523,14 @@ public AndConstraint<TAssertions> HaveSeconds(int expected,
     public AndConstraint<TAssertions> NotHaveSeconds(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the seconds part of {context:the time} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> TimeOnly.")
-            .Then
-            .ForCondition(Subject.Value.Second != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the seconds part of {context:the time} to be {0}{reason}", unexpected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> TimeOnly.")
+                .Then
+                .ForCondition(Subject.Value.Second != unexpected)
+                .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -558,16 +549,14 @@ public AndConstraint<TAssertions> NotHaveSeconds(int unexpected,
     public AndConstraint<TAssertions> HaveMilliseconds(int expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected the milliseconds part of {context:the time} to be {0}{reason}", expected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> TimeOnly.")
-            .Then
-            .ForCondition(Subject.Value.Millisecond == expected)
-            .FailWith(", but found {0}.", Subject.Value.Millisecond)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected the milliseconds part of {context:the time} to be {0}{reason}", expected, chain => chain
+                .ForCondition(Subject.HasValue)
+                .FailWith(", but found a <null> TimeOnly.")
+                .Then
+                .ForCondition(Subject.Value.Millisecond == expected)
+                .FailWith(", but found {0}.", Subject.Value.Millisecond));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -586,16 +575,15 @@ public AndConstraint<TAssertions> HaveMilliseconds(int expected,
     public AndConstraint<TAssertions> NotHaveMilliseconds(int unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Did not expect the milliseconds part of {context:the time} to be {0}{reason}", unexpected)
-            .ForCondition(Subject.HasValue)
-            .FailWith(", but found a <null> TimeOnly.")
-            .Then
-            .ForCondition(Subject.Value.Millisecond != unexpected)
-            .FailWith(", but it was.")
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Did not expect the milliseconds part of {context:the time} to be {0}{reason}", unexpected,
+                chain => chain
+                    .ForCondition(Subject.HasValue)
+                    .FailWith(", but found a <null> TimeOnly.")
+                    .Then
+                    .ForCondition(Subject.Value.Millisecond != unexpected)
+                    .FailWith(", but it was."));
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -657,7 +645,7 @@ public AndConstraint<TAssertions> BeOneOf(IEnumerable<TimeOnly> validValues,
     public AndConstraint<TAssertions> BeOneOf(IEnumerable<TimeOnly?> validValues,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(validValues.Contains(Subject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:time} to be one of {0}{reason}, but found {1}.", validValues, Subject);
diff --git a/Src/FluentAssertions/Specialized/ActionAssertions.cs b/Src/FluentAssertions/Specialized/ActionAssertions.cs
index 0051f0dee8..94be29f8c4 100644
--- a/Src/FluentAssertions/Specialized/ActionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/ActionAssertions.cs
@@ -12,14 +12,18 @@ namespace FluentAssertions.Specialized;
 [DebuggerNonUserCode]
 public class ActionAssertions : DelegateAssertions<Action, ActionAssertions>
 {
-    public ActionAssertions(Action subject, IExtractExceptions extractor)
-        : base(subject, extractor)
+    private readonly AssertionChain assertionChain;
+
+    public ActionAssertions(Action subject, IExtractExceptions extractor, AssertionChain assertionChain)
+        : base(subject, extractor, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
-    public ActionAssertions(Action subject, IExtractExceptions extractor, IClock clock)
-        : base(subject, extractor, clock)
+    public ActionAssertions(Action subject, IExtractExceptions extractor, AssertionChain assertionChain, IClock clock)
+        : base(subject, extractor, assertionChain, clock)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -34,12 +38,12 @@ public ActionAssertions(Action subject, IExtractExceptions extractor, IClock clo
     /// </param>
     public AndConstraint<ActionAssertions> NotThrow([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             FailIfSubjectIsAsyncVoid();
             Exception exception = InvokeSubjectWithInterception();
@@ -78,12 +82,12 @@ public AndConstraint<ActionAssertions> NotThrowAfter(TimeSpan waitTime, TimeSpan
         Guard.ThrowIfArgumentIsNegative(waitTime);
         Guard.ThrowIfArgumentIsNegative(pollInterval);
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw after {0}{reason}, but found <null>.", waitTime);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             FailIfSubjectIsAsyncVoid();
 
@@ -104,7 +108,7 @@ public AndConstraint<ActionAssertions> NotThrowAfter(TimeSpan waitTime, TimeSpan
                 invocationEndTime = timer.Elapsed;
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(exception is null)
                 .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
diff --git a/Src/FluentAssertions/Specialized/AsyncFunctionAssertions.cs b/Src/FluentAssertions/Specialized/AsyncFunctionAssertions.cs
index 30791f52a2..7a120af2a0 100644
--- a/Src/FluentAssertions/Specialized/AsyncFunctionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/AsyncFunctionAssertions.cs
@@ -19,9 +19,13 @@ public class AsyncFunctionAssertions<TTask, TAssertions> : DelegateAssertionsBas
     where TTask : Task
     where TAssertions : AsyncFunctionAssertions<TTask, TAssertions>
 {
-    protected AsyncFunctionAssertions(Func<TTask> subject, IExtractExceptions extractor, IClock clock)
-        : base(subject, extractor, clock)
+    private readonly AssertionChain assertionChain;
+
+    protected AsyncFunctionAssertions(Func<TTask> subject, IExtractExceptions extractor, AssertionChain assertionChain,
+        IClock clock)
+        : base(subject, extractor, assertionChain, clock)
     {
+        this.assertionChain = assertionChain;
     }
 
     protected override string Identifier => "async function";
@@ -40,12 +44,12 @@ protected AsyncFunctionAssertions(Func<TTask> subject, IExtractExceptions extrac
     public async Task<AndConstraint<TAssertions>> NotCompleteWithinAsync(TimeSpan timeSpan,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:task} to complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             (Task task, TimeSpan remainingTime) = InvokeWithTimer(timeSpan);
 
@@ -53,7 +57,7 @@ public async Task<AndConstraint<TAssertions>> NotCompleteWithinAsync(TimeSpan ti
             {
                 bool completesWithinTimeout = await CompletesWithinTimeoutAsync(task, remainingTime);
 
-                Execute.Assertion
+                assertionChain
                     .ForCondition(!completesWithinTimeout)
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Did not expect {context:task} to complete within {0}{reason}.", timeSpan);
@@ -83,29 +87,29 @@ public async Task<ExceptionAssertions<TException>> ThrowExactlyAsync<TException>
     {
         Type expectedType = typeof(TException);
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw exactly {0}{reason}, but found <null>.", expectedType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Exception exception = await InvokeWithInterceptionAsync(Subject);
 
-            success = Execute.Assertion
+            assertionChain
                 .ForCondition(exception is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {0}{reason}, but no exception was thrown.", expectedType);
 
-            if (success)
+            if (assertionChain.Succeeded)
             {
                 exception.Should().BeOfType(expectedType, because, becauseArgs);
             }
 
-            return new ExceptionAssertions<TException>([exception as TException]);
+            return new ExceptionAssertions<TException>([exception as TException], assertionChain);
         }
 
-        return new ExceptionAssertions<TException>([]);
+        return new ExceptionAssertions<TException>([], assertionChain);
     }
 
     /// <summary>
@@ -123,18 +127,18 @@ public async Task<ExceptionAssertions<TException>> ThrowAsync<TException>(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw {0}{reason}, but found <null>.", typeof(TException));
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Exception exception = await InvokeWithInterceptionAsync(Subject);
             return ThrowInternal<TException>(exception, because, becauseArgs);
         }
 
-        return new ExceptionAssertions<TException>([]);
+        return new ExceptionAssertions<TException>([], assertionChain);
     }
 
     /// <summary>
@@ -154,19 +158,19 @@ public async Task<ExceptionAssertions<TException>> ThrowWithinAsync<TException>(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw {0} within {1}{reason}, but found <null>.",
                 typeof(TException), timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             Exception caughtException = await InvokeWithInterceptionAsync(timeSpan);
             return AssertThrows<TException>(caughtException, timeSpan, because, becauseArgs);
         }
 
-        return new ExceptionAssertions<TException>([]);
+        return new ExceptionAssertions<TException>([], assertionChain);
     }
 
     private ExceptionAssertions<TException> AssertThrows<TException>(
@@ -176,21 +180,18 @@ private ExceptionAssertions<TException> AssertThrows<TException>(
     {
         TException[] expectedExceptions = Extractor.OfType<TException>(exception).ToArray();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected a <{0}> to be thrown within {1}{reason}, ",
-                typeof(TException), timeSpan)
-            .ForCondition(exception is not null)
-            .FailWith("but no exception was thrown.")
-            .Then
-            .ForCondition(expectedExceptions.Length > 0)
-            .FailWith("but found <{0}>:" + Environment.NewLine + "{1}.",
-                exception?.GetType(),
-                exception)
-            .Then
-            .ClearExpectation();
-
-        return new ExceptionAssertions<TException>(expectedExceptions);
+            .WithExpectation("Expected a <{0}> to be thrown within {1}{reason}, ", typeof(TException), timeSpan, chain => chain
+                .ForCondition(exception is not null)
+                .FailWith("but no exception was thrown.")
+                .Then
+                .ForCondition(expectedExceptions.Length > 0)
+                .FailWith("but found <{0}>:" + Environment.NewLine + "{1}.",
+                    exception?.GetType(),
+                    exception));
+
+        return new ExceptionAssertions<TException>(expectedExceptions, assertionChain);
     }
 
     private async Task<Exception> InvokeWithInterceptionAsync(TimeSpan timeout)
@@ -210,6 +211,7 @@ private async Task<Exception> InvokeWithInterceptionAsync(TimeSpan timeout)
                        : default)
             {
                 (TTask task, TimeSpan remainingTime) = InvokeWithTimer(timeout);
+
                 if (remainingTime < TimeSpan.Zero)
                 {
                     // timeout reached without exception
@@ -248,15 +250,16 @@ private async Task<Exception> InvokeWithInterceptionAsync(TimeSpan timeout)
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public async Task<AndConstraint<TAssertions>> NotThrowAsync<TException>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public async Task<AndConstraint<TAssertions>> NotThrowAsync<TException>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TException : Exception
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             try
             {
diff --git a/Src/FluentAssertions/Specialized/DelegateAssertions.cs b/Src/FluentAssertions/Specialized/DelegateAssertions.cs
index a8084e3255..f10a4b5885 100644
--- a/Src/FluentAssertions/Specialized/DelegateAssertions.cs
+++ b/Src/FluentAssertions/Specialized/DelegateAssertions.cs
@@ -16,14 +16,18 @@ public abstract class DelegateAssertions<TDelegate, TAssertions> : DelegateAsser
     where TDelegate : Delegate
     where TAssertions : DelegateAssertions<TDelegate, TAssertions>
 {
-    protected DelegateAssertions(TDelegate @delegate, IExtractExceptions extractor)
-        : base(@delegate, extractor, new Clock())
+    private readonly AssertionChain assertionChain;
+
+    protected DelegateAssertions(TDelegate @delegate, IExtractExceptions extractor, AssertionChain assertionChain)
+        : base(@delegate, extractor, assertionChain, new Clock())
     {
+        this.assertionChain = assertionChain;
     }
 
-    private protected DelegateAssertions(TDelegate @delegate, IExtractExceptions extractor, IClock clock)
-        : base(@delegate, extractor, clock)
+    private protected DelegateAssertions(TDelegate @delegate, IExtractExceptions extractor, AssertionChain assertionChain, IClock clock)
+        : base(@delegate, extractor, assertionChain, clock)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -39,19 +43,19 @@ private protected DelegateAssertions(TDelegate @delegate, IExtractExceptions ext
     public ExceptionAssertions<TException> Throw<TException>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw {0}{reason}, but found <null>.", typeof(TException));
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             FailIfSubjectIsAsyncVoid();
             Exception exception = InvokeSubjectWithInterception();
             return ThrowInternal<TException>(exception, because, becauseArgs);
         }
 
-        return new ExceptionAssertions<TException>([]);
+        return new ExceptionAssertions<TException>([], assertionChain);
     }
 
     /// <summary>
@@ -67,12 +71,12 @@ public ExceptionAssertions<TException> Throw<TException>([StringSyntax("Composit
     public AndConstraint<TAssertions> NotThrow<TException>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw {0}{reason}, but found <null>.", typeof(TException));
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             FailIfSubjectIsAsyncVoid();
             Exception exception = InvokeSubjectWithInterception();
@@ -102,32 +106,32 @@ public ExceptionAssertions<TException> ThrowExactly<TException>([StringSyntax("C
         params object[] becauseArgs)
         where TException : Exception
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw exactly {0}{reason}, but found <null>.", typeof(TException));
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             FailIfSubjectIsAsyncVoid();
             Exception exception = InvokeSubjectWithInterception();
 
             Type expectedType = typeof(TException);
 
-            success = Execute.Assertion
+            assertionChain
                 .ForCondition(exception is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {0}{reason}, but no exception was thrown.", expectedType);
 
-            if (success)
+            if (assertionChain.Succeeded)
             {
                 exception.Should().BeOfType(expectedType, because, becauseArgs);
             }
 
-            return new ExceptionAssertions<TException>([exception as TException]);
+            return new ExceptionAssertions<TException>([exception as TException], assertionChain);
         }
 
-        return new ExceptionAssertions<TException>([]);
+        return new ExceptionAssertions<TException>([], assertionChain);
     }
 
     protected abstract void InvokeSubject();
diff --git a/Src/FluentAssertions/Specialized/DelegateAssertionsBase.cs b/Src/FluentAssertions/Specialized/DelegateAssertionsBase.cs
index 77b687f54e..fe662c0424 100644
--- a/Src/FluentAssertions/Specialized/DelegateAssertionsBase.cs
+++ b/Src/FluentAssertions/Specialized/DelegateAssertionsBase.cs
@@ -18,11 +18,15 @@ public abstract class DelegateAssertionsBase<TDelegate, TAssertions>
     where TDelegate : Delegate
     where TAssertions : DelegateAssertionsBase<TDelegate, TAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     private protected IExtractExceptions Extractor { get; }
 
-    private protected DelegateAssertionsBase(TDelegate @delegate, IExtractExceptions extractor, IClock clock)
-        : base(@delegate)
+    private protected DelegateAssertionsBase(TDelegate @delegate, IExtractExceptions extractor, AssertionChain assertionChain,
+        IClock clock)
+        : base(@delegate, assertionChain)
     {
+        this.assertionChain = assertionChain;
         Extractor = extractor ?? throw new ArgumentNullException(nameof(extractor));
         Clock = clock ?? throw new ArgumentNullException(nameof(clock));
     }
@@ -36,25 +40,24 @@ protected ExceptionAssertions<TException> ThrowInternal<TException>(
     {
         TException[] expectedExceptions = Extractor.OfType<TException>(exception).ToArray();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected a <{0}> to be thrown{reason}, ", typeof(TException))
-            .ForCondition(exception is not null)
-            .FailWith("but no exception was thrown.")
-            .Then
-            .ForCondition(expectedExceptions.Length > 0)
-            .FailWith("but found <{0}>:" + Environment.NewLine + "{1}.",
-                exception?.GetType(),
-                exception)
-            .Then
-            .ClearExpectation();
+            .WithExpectation("Expected a <{0}> to be thrown{reason}, ", typeof(TException), chain => chain
+                .ForCondition(exception is not null)
+                .FailWith("but no exception was thrown.")
+                .Then
+                .ForCondition(expectedExceptions.Length > 0)
+                .FailWith("but found <{0}>:" + Environment.NewLine + "{1}.",
+                    exception?.GetType(),
+                    exception));
 
-        return new ExceptionAssertions<TException>(expectedExceptions);
+        return new ExceptionAssertions<TException>(expectedExceptions, assertionChain);
     }
 
-    protected AndConstraint<TAssertions> NotThrowInternal(Exception exception, [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
+    protected AndConstraint<TAssertions> NotThrowInternal(Exception exception, [StringSyntax("CompositeFormat")] string because,
+        object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(exception is null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect any exception{reason}, but found {0}.", exception);
@@ -62,12 +65,13 @@ protected AndConstraint<TAssertions> NotThrowInternal(Exception exception, [Stri
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
 
-    protected AndConstraint<TAssertions> NotThrowInternal<TException>(Exception exception, [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
+    protected AndConstraint<TAssertions> NotThrowInternal<TException>(Exception exception,
+        [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
         where TException : Exception
     {
         IEnumerable<TException> exceptions = Extractor.OfType<TException>(exception);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(!exceptions.Any())
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {0}{reason}, but found {1}.", typeof(TException), exception);
diff --git a/Src/FluentAssertions/Specialized/ExceptionAssertions.cs b/Src/FluentAssertions/Specialized/ExceptionAssertions.cs
index 3cec526e9a..6c249a969d 100644
--- a/Src/FluentAssertions/Specialized/ExceptionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/ExceptionAssertions.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Linq.Expressions;
 using FluentAssertions.Common;
@@ -19,9 +18,12 @@ namespace FluentAssertions.Specialized;
 public class ExceptionAssertions<TException> : ReferenceTypeAssertions<IEnumerable<TException>, ExceptionAssertions<TException>>
     where TException : Exception
 {
-    public ExceptionAssertions(IEnumerable<TException> exceptions)
-        : base(exceptions)
+    private readonly AssertionChain assertionChain;
+
+    public ExceptionAssertions(IEnumerable<TException> exceptions, AssertionChain assertionChain)
+        : base(exceptions, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -72,16 +74,16 @@ public ExceptionAssertions(IEnumerable<TException> exceptions)
     /// </item>
     /// </list>
     /// </remarks>
-    public virtual ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public virtual ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern, string because = "",
+        params object[] becauseArgs)
     {
-        AssertionScope assertion = Execute.Assertion.BecauseOf(because, becauseArgs).UsingLineBreaks;
-
-        assertion
+        assertionChain
+            .BecauseOf(because, becauseArgs)
+            .UsingLineBreaks
             .ForCondition(Subject.Any())
             .FailWith("Expected exception with message {0}{reason}, but no exception was thrown.", expectedWildcardPattern);
 
-        ExceptionMessageAssertion.Execute(Subject.Select(exc => exc.Message), expectedWildcardPattern, because,
+        AssertExceptionMessage(Subject.Select(exc => exc.Message), expectedWildcardPattern, because,
             becauseArgs);
 
         return this;
@@ -98,12 +100,12 @@ public virtual ExceptionAssertions<TException> WithMessage(string expectedWildca
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public virtual ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public virtual ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(string because = "",
+        params object[] becauseArgs)
         where TInnerException : Exception
     {
         var expectedInnerExceptions = AssertInnerExceptions(typeof(TInnerException), because, becauseArgs);
-        return new ExceptionAssertions<TInnerException>(expectedInnerExceptions.Cast<TInnerException>());
+        return new ExceptionAssertions<TInnerException>(expectedInnerExceptions.Cast<TInnerException>(), assertionChain);
     }
 
     /// <summary>
@@ -117,12 +119,12 @@ public virtual ExceptionAssertions<TInnerException> WithInnerException<TInnerExc
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public ExceptionAssertions<Exception> WithInnerException(Type innerException,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public ExceptionAssertions<Exception> WithInnerException(Type innerException, string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(innerException);
 
-        return new ExceptionAssertions<Exception>(AssertInnerExceptions(innerException, because, becauseArgs));
+        return new ExceptionAssertions<Exception>(AssertInnerExceptions(innerException, because, becauseArgs), assertionChain);
     }
 
     /// <summary>
@@ -136,12 +138,12 @@ public ExceptionAssertions<Exception> WithInnerException(Type innerException,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public virtual ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>([StringSyntax("CompositeFormat")] string because = "",
+    public virtual ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>(string because = "",
         params object[] becauseArgs)
         where TInnerException : Exception
     {
         var exceptionExpression = AssertInnerExceptionExactly(typeof(TInnerException), because, becauseArgs);
-        return new ExceptionAssertions<TInnerException>(exceptionExpression.Cast<TInnerException>());
+        return new ExceptionAssertions<TInnerException>(exceptionExpression.Cast<TInnerException>(), assertionChain);
     }
 
     /// <summary>
@@ -155,12 +157,12 @@ public virtual ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TI
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public ExceptionAssertions<Exception> WithInnerExceptionExactly(Type innerException,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public ExceptionAssertions<Exception> WithInnerExceptionExactly(Type innerException, string because = "",
+        params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(innerException);
 
-        return new ExceptionAssertions<Exception>(AssertInnerExceptionExactly(innerException, because, becauseArgs));
+        return new ExceptionAssertions<Exception>(AssertInnerExceptionExactly(innerException, because, becauseArgs), assertionChain);
     }
 
     /// <summary>
@@ -178,13 +180,13 @@ public ExceptionAssertions<Exception> WithInnerExceptionExactly(Type innerExcept
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="exceptionExpression"/> is <see langword="null"/>.</exception>
     public ExceptionAssertions<TException> Where(Expression<Func<TException, bool>> exceptionExpression,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(exceptionExpression);
 
         Func<TException, bool> condition = exceptionExpression.Compile();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(condition(SingleSubject))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected exception where {0}{reason}, but the condition was not met by:"
@@ -194,10 +196,10 @@ public ExceptionAssertions<TException> Where(Expression<Func<TException, bool>>
         return this;
     }
 
-    private IEnumerable<Exception> AssertInnerExceptionExactly(Type innerException,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    private IEnumerable<Exception> AssertInnerExceptionExactly(Type innerException, string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject.Any(e => e.InnerException is not null))
             .FailWith("Expected inner {0}{reason}, but the thrown exception has no inner exception.", innerException);
@@ -206,7 +208,7 @@ private IEnumerable<Exception> AssertInnerExceptionExactly(Type innerException,
             .Select(e => e.InnerException)
             .Where(e => e?.GetType() == innerException).ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(expectedExceptions.Length > 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected inner {0}{reason}, but found {1}.", innerException, SingleSubject.InnerException);
@@ -214,10 +216,10 @@ private IEnumerable<Exception> AssertInnerExceptionExactly(Type innerException,
         return expectedExceptions;
     }
 
-    private IEnumerable<Exception> AssertInnerExceptions(Type innerException,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    private IEnumerable<Exception> AssertInnerExceptions(Type innerException, string because = "",
+        params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject.Any(e => e.InnerException is not null))
             .FailWith("Expected inner {0}{reason}, but the thrown exception has no inner exception.", innerException);
@@ -227,7 +229,7 @@ private IEnumerable<Exception> AssertInnerExceptions(Type innerException,
             .Where(e => e != null && e.GetType().IsSameOrInherits(innerException))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(expectedInnerExceptions.Length > 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected inner {0}{reason}, but found {1}.", innerException, SingleSubject.InnerException);
@@ -259,39 +261,35 @@ private static string BuildExceptionsString(IEnumerable<TException> exceptions)
                     "\t" + Formatter.ToString(exception)));
     }
 
-    private static class ExceptionMessageAssertion
+    private void AssertExceptionMessage(IEnumerable<string> messages, string expectation, string because, params object[] becauseArgs)
     {
-        private const string Context = "exception message";
+        var results = new AssertionResultSet();
 
-        public static void Execute(IEnumerable<string> messages, string expectation, [StringSyntax("CompositeFormat")] string because, params object[] becauseArgs)
+        foreach (string message in messages)
         {
-            using var _ = new AssertionScope();
-            var results = new AssertionResultSet();
-
-            foreach (string message in messages)
+            using (var scope = new AssertionScope())
             {
-                using (var scope = new AssertionScope())
-                {
-                    scope.Context = new Lazy<string>(() => Context);
+                var chain = AssertionChain.GetOrCreate();
+                chain.OverrideCallerIdentifier(() => "exception message");
+                chain.ReuseOnce();
 
-                    message.Should().MatchEquivalentOf(expectation, because, becauseArgs);
+                message.Should().MatchEquivalentOf(expectation, because, becauseArgs);
 
-                    results.AddSet(message, scope.Discard());
-                }
-
-                if (results.ContainsSuccessfulSet())
-                {
-                    break;
-                }
+                results.AddSet(message, scope.Discard());
             }
 
-            foreach (string failure in results.GetTheFailuresForTheSetWithTheFewestFailures())
+            if (results.ContainsSuccessfulSet())
             {
-                string replacedCurlyBraces =
-                    failure.EscapePlaceholders();
-
-                AssertionScope.Current.FailWith(replacedCurlyBraces);
+                break;
             }
         }
+
+        foreach (string failure in results.GetTheFailuresForTheSetWithTheFewestFailures())
+        {
+            string replacedCurlyBraces =
+                failure.EscapePlaceholders();
+
+            assertionChain.FailWith(replacedCurlyBraces);
+        }
     }
 }
diff --git a/Src/FluentAssertions/Specialized/ExecutionTimeAssertions.cs b/Src/FluentAssertions/Specialized/ExecutionTimeAssertions.cs
index 1c63fcc35a..0dfaf1446d 100644
--- a/Src/FluentAssertions/Specialized/ExecutionTimeAssertions.cs
+++ b/Src/FluentAssertions/Specialized/ExecutionTimeAssertions.cs
@@ -13,14 +13,16 @@ namespace FluentAssertions.Specialized;
 public class ExecutionTimeAssertions
 {
     private readonly ExecutionTime execution;
+    private readonly AssertionChain assertionChain;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ExecutionTime"/> class.
     /// </summary>
     /// <param name="executionTime">The execution on which time must be asserted.</param>
-    public ExecutionTimeAssertions(ExecutionTime executionTime)
+    public ExecutionTimeAssertions(ExecutionTime executionTime, AssertionChain assertionChain)
     {
         execution = executionTime ?? throw new ArgumentNullException(nameof(executionTime));
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -74,7 +76,7 @@ public AndConstraint<ExecutionTimeAssertions> BeLessThanOrEqualTo(TimeSpan maxDu
     {
         (bool isRunning, TimeSpan elapsed) = PollUntil(duration => duration <= maxDuration, expectedResult: false, rate: maxDuration);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(elapsed <= maxDuration)
             .BecauseOf(because, becauseArgs)
             .FailWith("Execution of " +
@@ -105,7 +107,7 @@ public AndConstraint<ExecutionTimeAssertions> BeLessThan(TimeSpan maxDuration,
     {
         (bool isRunning, TimeSpan elapsed) = PollUntil(duration => duration < maxDuration, expectedResult: false, rate: maxDuration);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(elapsed < maxDuration)
             .BecauseOf(because, becauseArgs)
             .FailWith("Execution of " +
@@ -135,7 +137,7 @@ public AndConstraint<ExecutionTimeAssertions> BeGreaterThanOrEqualTo(TimeSpan mi
     {
         (bool isRunning, TimeSpan elapsed) = PollUntil(duration => duration >= minDuration, expectedResult: true, rate: minDuration);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(elapsed >= minDuration)
             .BecauseOf(because, becauseArgs)
             .FailWith("Execution of " +
@@ -166,7 +168,7 @@ public AndConstraint<ExecutionTimeAssertions> BeGreaterThan(TimeSpan minDuration
     {
         (bool isRunning, TimeSpan elapsed) = PollUntil(duration => duration > minDuration, expectedResult: true, rate: minDuration);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(elapsed > minDuration)
             .BecauseOf(because, becauseArgs)
             .FailWith("Execution of " +
@@ -208,7 +210,7 @@ public AndConstraint<ExecutionTimeAssertions> BeCloseTo(TimeSpan expectedDuratio
         // elapsed time didn't even get to the acceptable range
         (bool isRunning, TimeSpan elapsed) = PollUntil(duration => duration <= maximumValue, expectedResult: false, rate: maximumValue);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(elapsed >= minimumValue && elapsed <= maximumValue)
             .BecauseOf(because, becauseArgs)
             .FailWith("Execution of " + execution.ActionDescription.EscapePlaceholders() +
diff --git a/Src/FluentAssertions/Specialized/FunctionAssertionHelpers.cs b/Src/FluentAssertions/Specialized/FunctionAssertionHelpers.cs
deleted file mode 100644
index 28c4e0983f..0000000000
--- a/Src/FluentAssertions/Specialized/FunctionAssertionHelpers.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using FluentAssertions.Common;
-using FluentAssertions.Execution;
-
-namespace FluentAssertions.Specialized;
-
-internal static class FunctionAssertionHelpers
-{
-    internal static T NotThrow<T>(Func<T> subject, [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
-    {
-        try
-        {
-            return subject();
-        }
-        catch (Exception exception)
-        {
-            Execute.Assertion
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Did not expect any exception{reason}, but found {0}.", exception);
-
-            return default;
-        }
-    }
-
-    internal static TResult NotThrowAfter<TResult>(Func<TResult> subject, IClock clock, TimeSpan waitTime, TimeSpan pollInterval,
-        [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
-    {
-        Guard.ThrowIfArgumentIsNegative(waitTime);
-        Guard.ThrowIfArgumentIsNegative(pollInterval);
-
-        TimeSpan? invocationEndTime = null;
-        Exception exception = null;
-        ITimer timer = clock.StartTimer();
-
-        while (invocationEndTime is null || invocationEndTime < waitTime)
-        {
-            try
-            {
-                return subject();
-            }
-            catch (Exception ex)
-            {
-                exception = ex;
-            }
-
-            clock.Delay(pollInterval);
-            invocationEndTime = timer.Elapsed;
-        }
-
-        Execute.Assertion
-            .BecauseOf(because, becauseArgs)
-            .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
-
-        return default;
-    }
-}
diff --git a/Src/FluentAssertions/Specialized/FunctionAssertions.cs b/Src/FluentAssertions/Specialized/FunctionAssertions.cs
index 011b961165..0219cab38f 100644
--- a/Src/FluentAssertions/Specialized/FunctionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/FunctionAssertions.cs
@@ -12,14 +12,18 @@ namespace FluentAssertions.Specialized;
 [DebuggerNonUserCode]
 public class FunctionAssertions<T> : DelegateAssertions<Func<T>, FunctionAssertions<T>>
 {
-    public FunctionAssertions(Func<T> subject, IExtractExceptions extractor)
-        : base(subject, extractor)
+    private readonly AssertionChain assertionChain;
+
+    public FunctionAssertions(Func<T> subject, IExtractExceptions extractor, AssertionChain assertionChain)
+        : base(subject, extractor, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
-    public FunctionAssertions(Func<T> subject, IExtractExceptions extractor, IClock clock)
-        : base(subject, extractor, clock)
+    public FunctionAssertions(Func<T> subject, IExtractExceptions extractor, AssertionChain assertionChain, IClock clock)
+        : base(subject, extractor, assertionChain, clock)
     {
+        this.assertionChain = assertionChain;
     }
 
     protected override void InvokeSubject()
@@ -41,19 +45,30 @@ protected override void InvokeSubject()
     /// </param>
     public AndWhichConstraint<FunctionAssertions<T>, T> NotThrow([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
         T result = default;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            result = FunctionAssertionHelpers.NotThrow(Subject, because, becauseArgs);
+            try
+            {
+                result = Subject!();
+            }
+            catch (Exception exception)
+            {
+                assertionChain
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Did not expect any exception{reason}, but found {0}.", exception);
+
+                result = default;
+            }
         }
 
-        return new AndWhichConstraint<FunctionAssertions<T>, T>(this, result);
+        return new AndWhichConstraint<FunctionAssertions<T>, T>(this, result, assertionChain, ".Result");
     }
 
     /// <summary>
@@ -82,18 +97,50 @@ public AndWhichConstraint<FunctionAssertions<T>, T> NotThrow([StringSyntax("Comp
     public AndWhichConstraint<FunctionAssertions<T>, T> NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw any exceptions after {0}{reason}, but found <null>.", waitTime);
 
         T result = default;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            result = FunctionAssertionHelpers.NotThrowAfter(Subject, Clock, waitTime, pollInterval, because, becauseArgs);
+            result = NotThrowAfter(Subject, Clock, waitTime, pollInterval, because, becauseArgs);
         }
 
-        return new AndWhichConstraint<FunctionAssertions<T>, T>(this, result);
+        return new AndWhichConstraint<FunctionAssertions<T>, T>(this, result, assertionChain, ".Result");
+    }
+
+    internal TResult NotThrowAfter<TResult>(Func<TResult> subject, IClock clock, TimeSpan waitTime, TimeSpan pollInterval,
+        string because, object[] becauseArgs)
+    {
+        Guard.ThrowIfArgumentIsNegative(waitTime);
+        Guard.ThrowIfArgumentIsNegative(pollInterval);
+
+        TimeSpan? invocationEndTime = null;
+        Exception exception = null;
+        ITimer timer = clock.StartTimer();
+
+        while (invocationEndTime is null || invocationEndTime < waitTime)
+        {
+            try
+            {
+                return subject();
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            }
+
+            clock.Delay(pollInterval);
+            invocationEndTime = timer.Elapsed;
+        }
+
+        assertionChain
+            .BecauseOf(because, becauseArgs)
+            .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
+
+        return default;
     }
 }
diff --git a/Src/FluentAssertions/Specialized/GenericAsyncFunctionAssertions.cs b/Src/FluentAssertions/Specialized/GenericAsyncFunctionAssertions.cs
index 109d1918b3..ea78c3b77b 100644
--- a/Src/FluentAssertions/Specialized/GenericAsyncFunctionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/GenericAsyncFunctionAssertions.cs
@@ -14,20 +14,25 @@ namespace FluentAssertions.Specialized;
 public class GenericAsyncFunctionAssertions<TResult>
     : AsyncFunctionAssertions<Task<TResult>, GenericAsyncFunctionAssertions<TResult>>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="GenericAsyncFunctionAssertions{TResult}"/> class.
     /// </summary>
-    public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExceptions extractor)
-        : this(subject, extractor, new Clock())
+    public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExceptions extractor, AssertionChain assertionChain)
+        : this(subject, extractor, assertionChain, new Clock())
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="GenericAsyncFunctionAssertions{TResult}"/> class with custom <see cref="IClock"/>.
     /// </summary>
-    public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExceptions extractor, IClock clock)
-        : base(subject, extractor, clock)
+    public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExceptions extractor, AssertionChain assertionChain,
+        IClock clock)
+        : base(subject, extractor, assertionChain, clock)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -44,34 +49,34 @@ public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExcep
     public async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>> CompleteWithinAsync(
         TimeSpan timeSpan, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             (Task<TResult> task, TimeSpan remainingTime) = InvokeWithTimer(timeSpan);
 
-            success = Execute.Assertion
+            assertionChain
                 .ForCondition(remainingTime >= TimeSpan.Zero)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:task} to complete within {0}{reason}.", timeSpan);
 
-            if (success)
+            if (assertionChain.Succeeded)
             {
                 bool completesWithinTimeout = await CompletesWithinTimeoutAsync(task, remainingTime);
 
-                success = Execute.Assertion
+                assertionChain
                     .ForCondition(completesWithinTimeout)
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:task} to complete within {0}{reason}.", timeSpan);
             }
 
 #pragma warning disable CA1849 // Call async methods when in an async method
-            TResult result = success ? task.Result : default;
+            TResult result = assertionChain.Succeeded ? task.Result : default;
 #pragma warning restore CA1849 // Call async methods when in an async method
-            return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, result);
+            return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, result, assertionChain, ".Result");
         }
 
         return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, default(TResult));
@@ -90,17 +95,17 @@ public async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TR
     public async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAsync(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             try
             {
                 TResult result = await Subject!.Invoke();
-                return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, result);
+                return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, result, assertionChain, ".Result");
             }
             catch (Exception exception)
             {
@@ -140,12 +145,12 @@ public Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>
         Guard.ThrowIfArgumentIsNegative(waitTime);
         Guard.ThrowIfArgumentIsNegative(pollInterval);
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw any exceptions after {0}{reason}, but found <null>.", waitTime);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             return AssertionTaskAsync();
 
@@ -160,7 +165,7 @@ async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>>
                     try
                     {
                         TResult result = await Subject.Invoke();
-                        return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, result);
+                        return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, result, assertionChain, ".Result");
                     }
                     catch (Exception ex)
                     {
@@ -170,7 +175,7 @@ async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>>
                     }
                 }
 
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
 
diff --git a/Src/FluentAssertions/Specialized/NonGenericAsyncFunctionAssertions.cs b/Src/FluentAssertions/Specialized/NonGenericAsyncFunctionAssertions.cs
index 91f2b85022..8c672ff0d2 100644
--- a/Src/FluentAssertions/Specialized/NonGenericAsyncFunctionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/NonGenericAsyncFunctionAssertions.cs
@@ -12,20 +12,24 @@ namespace FluentAssertions.Specialized;
 /// </summary>
 public class NonGenericAsyncFunctionAssertions : AsyncFunctionAssertions<Task, NonGenericAsyncFunctionAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="NonGenericAsyncFunctionAssertions"/> class.
     /// </summary>
-    public NonGenericAsyncFunctionAssertions(Func<Task> subject, IExtractExceptions extractor)
-        : this(subject, extractor, new Clock())
+    public NonGenericAsyncFunctionAssertions(Func<Task> subject, IExtractExceptions extractor, AssertionChain assertionChain)
+        : this(subject, extractor, assertionChain, new Clock())
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="NonGenericAsyncFunctionAssertions"/> class with custom <see cref="IClock"/>.
     /// </summary>
-    public NonGenericAsyncFunctionAssertions(Func<Task> subject, IExtractExceptions extractor, IClock clock)
-        : base(subject, extractor, clock)
+    public NonGenericAsyncFunctionAssertions(Func<Task> subject, IExtractExceptions extractor, AssertionChain assertionChain, IClock clock)
+        : base(subject, extractor, assertionChain, clock)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -42,25 +46,25 @@ public NonGenericAsyncFunctionAssertions(Func<Task> subject, IExtractExceptions
     public async Task<AndConstraint<NonGenericAsyncFunctionAssertions>> CompleteWithinAsync(
         TimeSpan timeSpan, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:task} to complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             (Task task, TimeSpan remainingTime) = InvokeWithTimer(timeSpan);
 
-            success = Execute.Assertion
+            assertionChain
                 .ForCondition(remainingTime >= TimeSpan.Zero)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:task} to complete within {0}{reason}.", timeSpan);
 
-            if (success)
+            if (assertionChain.Succeeded)
             {
                 bool completesWithinTimeout = await CompletesWithinTimeoutAsync(task, remainingTime);
 
-                Execute.Assertion
+                assertionChain
                     .ForCondition(completesWithinTimeout)
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context:task} to complete within {0}{reason}.", timeSpan);
@@ -83,12 +87,12 @@ public async Task<AndConstraint<NonGenericAsyncFunctionAssertions>> CompleteWith
     public async Task<AndConstraint<NonGenericAsyncFunctionAssertions>> NotThrowAsync(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             try
             {
@@ -132,12 +136,12 @@ public Task<AndConstraint<NonGenericAsyncFunctionAssertions>> NotThrowAfterAsync
         Guard.ThrowIfArgumentIsNegative(waitTime);
         Guard.ThrowIfArgumentIsNegative(pollInterval);
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw any exceptions after {0}{reason}, but found <null>.", waitTime);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             return AssertionTaskAsync();
 
@@ -160,7 +164,7 @@ async Task<AndConstraint<NonGenericAsyncFunctionAssertions>> AssertionTaskAsync(
                     invocationEndTime = timer.Elapsed;
                 }
 
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
 
diff --git a/Src/FluentAssertions/Specialized/TaskCompletionSourceAssertions.cs b/Src/FluentAssertions/Specialized/TaskCompletionSourceAssertions.cs
index a79d9d5cf2..0081053767 100644
--- a/Src/FluentAssertions/Specialized/TaskCompletionSourceAssertions.cs
+++ b/Src/FluentAssertions/Specialized/TaskCompletionSourceAssertions.cs
@@ -12,17 +12,20 @@ namespace FluentAssertions.Specialized;
 #if NET6_0_OR_GREATER
 public class TaskCompletionSourceAssertions : TaskCompletionSourceAssertionsBase
 {
+    private readonly AssertionChain assertionChain;
     private readonly TaskCompletionSource subject;
 
-    public TaskCompletionSourceAssertions(TaskCompletionSource tcs)
-        : this(tcs, new Clock())
+    public TaskCompletionSourceAssertions(TaskCompletionSource tcs, AssertionChain assertionChain)
+        : this(tcs, assertionChain, new Clock())
     {
+        this.assertionChain = assertionChain;
     }
 
-    public TaskCompletionSourceAssertions(TaskCompletionSource tcs, IClock clock)
+    public TaskCompletionSourceAssertions(TaskCompletionSource tcs, AssertionChain assertionChain, IClock clock)
         : base(clock)
     {
         subject = tcs;
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -39,15 +42,15 @@ public TaskCompletionSourceAssertions(TaskCompletionSource tcs, IClock clock)
     public async Task<AndConstraint<TaskCompletionSourceAssertions>> CompleteWithinAsync(
         TimeSpan timeSpan, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             bool completesWithinTimeout = await CompletesWithinTimeoutAsync(subject!.Task, timeSpan);
-            Execute.Assertion
+            assertionChain
                 .ForCondition(completesWithinTimeout)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:task} to complete within {0}{reason}.", timeSpan);
@@ -70,15 +73,15 @@ public async Task<AndConstraint<TaskCompletionSourceAssertions>> CompleteWithinA
     public async Task<AndConstraint<TaskCompletionSourceAssertions>> NotCompleteWithinAsync(
         TimeSpan timeSpan, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to not complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             bool completesWithinTimeout = await CompletesWithinTimeoutAsync(subject!.Task, timeSpan);
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!completesWithinTimeout)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:task} to not complete within {0}{reason}.", timeSpan);
@@ -91,17 +94,20 @@ public async Task<AndConstraint<TaskCompletionSourceAssertions>> NotCompleteWith
 
 public class TaskCompletionSourceAssertions<T> : TaskCompletionSourceAssertionsBase
 {
+    private readonly AssertionChain assertionChain;
     private readonly TaskCompletionSource<T> subject;
 
-    public TaskCompletionSourceAssertions(TaskCompletionSource<T> tcs)
-        : this(tcs, new Clock())
+    public TaskCompletionSourceAssertions(TaskCompletionSource<T> tcs, AssertionChain assertionChain)
+        : this(tcs, assertionChain, new Clock())
     {
+        this.assertionChain = assertionChain;
     }
 
-    public TaskCompletionSourceAssertions(TaskCompletionSource<T> tcs, IClock clock)
+    public TaskCompletionSourceAssertions(TaskCompletionSource<T> tcs, AssertionChain assertionChain, IClock clock)
         : base(clock)
     {
         subject = tcs;
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -118,16 +124,16 @@ public TaskCompletionSourceAssertions(TaskCompletionSource<T> tcs, IClock clock)
     public async Task<AndWhichConstraint<TaskCompletionSourceAssertions<T>, T>> CompleteWithinAsync(
         TimeSpan timeSpan, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             bool completesWithinTimeout = await CompletesWithinTimeoutAsync(subject!.Task, timeSpan);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(completesWithinTimeout)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:task} to complete within {0}{reason}.", timeSpan);
@@ -135,7 +141,7 @@ public async Task<AndWhichConstraint<TaskCompletionSourceAssertions<T>, T>> Comp
 #pragma warning disable CA1849 // Call async methods when in an async method
             T result = subject.Task.IsCompleted ? subject.Task.Result : default;
 #pragma warning restore CA1849 // Call async methods when in an async method
-            return new AndWhichConstraint<TaskCompletionSourceAssertions<T>, T>(this, result);
+            return new AndWhichConstraint<TaskCompletionSourceAssertions<T>, T>(this, result, assertionChain, ".Result");
         }
 
         return new AndWhichConstraint<TaskCompletionSourceAssertions<T>, T>(this, default(T));
@@ -155,16 +161,16 @@ public async Task<AndWhichConstraint<TaskCompletionSourceAssertions<T>, T>> Comp
     public async Task<AndConstraint<TaskCompletionSourceAssertions<T>>> NotCompleteWithinAsync(
         TimeSpan timeSpan, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        var success = Execute.Assertion
+        assertionChain
             .ForCondition(subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context} to complete within {0}{reason}, but found <null>.", timeSpan);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             bool completesWithinTimeout = await CompletesWithinTimeoutAsync(subject!.Task, timeSpan);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!completesWithinTimeout)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Did not expect {context:task} to complete within {0}{reason}.", timeSpan);
diff --git a/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs b/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs
index 70ce652d07..1f4a9dd604 100644
--- a/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs
+++ b/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs
@@ -1,9 +1,7 @@
-using System.Diagnostics;
+#if NET6_0_OR_GREATER || NETSTANDARD2_1
+using System.Diagnostics;
 using System.IO;
-#if NET6_0_OR_GREATER || NETSTANDARD2_1
-using System.Diagnostics.CodeAnalysis;
 using FluentAssertions.Execution;
-#endif
 
 namespace FluentAssertions.Streams;
 
@@ -14,8 +12,8 @@ namespace FluentAssertions.Streams;
 [DebuggerNonUserCode]
 public class BufferedStreamAssertions : BufferedStreamAssertions<BufferedStreamAssertions>
 {
-    public BufferedStreamAssertions(BufferedStream stream)
-        : base(stream)
+    public BufferedStreamAssertions(BufferedStream stream, AssertionChain assertionChain)
+        : base(stream, assertionChain)
     {
     }
 }
@@ -23,14 +21,16 @@ public BufferedStreamAssertions(BufferedStream stream)
 public class BufferedStreamAssertions<TAssertions> : StreamAssertions<BufferedStream, TAssertions>
     where TAssertions : BufferedStreamAssertions<TAssertions>
 {
-    public BufferedStreamAssertions(BufferedStream stream)
-        : base(stream)
+    private readonly AssertionChain assertionChain;
+
+    public BufferedStreamAssertions(BufferedStream stream, AssertionChain assertionChain)
+        : base(stream, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     protected override string Identifier => "buffered stream";
 
-#if NET6_0_OR_GREATER || NETSTANDARD2_1
     /// <summary>
     /// Asserts that the current <see cref="BufferedStream"/> has the <paramref name="expected"/> buffer size.
     /// </summary>
@@ -42,18 +42,17 @@ public BufferedStreamAssertions(BufferedStream stream)
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> HaveBufferSize(int expected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> HaveBufferSize(int expected, string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the buffer size of {context:stream} to be {0}{reason}, but found a <null> reference.",
                 expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.BufferSize == expected)
                 .FailWith("Expected the buffer size of {context:stream} to be {0}{reason}, but it was {1}.",
@@ -74,18 +73,17 @@ public AndConstraint<TAssertions> HaveBufferSize(int expected,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TAssertions> NotHaveBufferSize(int unexpected,
-        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TAssertions> NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the buffer size of {context:stream} not to be {0}{reason}, but found a <null> reference.",
                 unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.BufferSize != unexpected)
                 .FailWith("Expected the buffer size of {context:stream} not to be {0}{reason}, but it was.",
@@ -94,5 +92,5 @@ public AndConstraint<TAssertions> NotHaveBufferSize(int unexpected,
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
-#endif
 }
+#endif
diff --git a/Src/FluentAssertions/Streams/StreamAssertions.cs b/Src/FluentAssertions/Streams/StreamAssertions.cs
index 7b61dd41f8..3116721541 100644
--- a/Src/FluentAssertions/Streams/StreamAssertions.cs
+++ b/Src/FluentAssertions/Streams/StreamAssertions.cs
@@ -13,8 +13,8 @@ namespace FluentAssertions.Streams;
 [DebuggerNonUserCode]
 public class StreamAssertions : StreamAssertions<Stream, StreamAssertions>
 {
-    public StreamAssertions(Stream stream)
-        : base(stream)
+    public StreamAssertions(Stream stream, AssertionChain assertionChain)
+        : base(stream, assertionChain)
     {
     }
 }
@@ -26,9 +26,12 @@ public class StreamAssertions<TSubject, TAssertions> : ReferenceTypeAssertions<T
     where TSubject : Stream
     where TAssertions : StreamAssertions<TSubject, TAssertions>
 {
-    public StreamAssertions(TSubject stream)
-        : base(stream)
+    private readonly AssertionChain assertionChain;
+
+    public StreamAssertions(TSubject stream, AssertionChain assertionChain)
+        : base(stream, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     protected override string Identifier => "stream";
@@ -45,14 +48,14 @@ public StreamAssertions(TSubject stream)
     /// </param>
     public AndConstraint<TAssertions> BeWritable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} to be writable{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.CanWrite)
                 .FailWith("Expected {context:stream} to be writable{reason}, but it was not.");
@@ -73,14 +76,14 @@ public AndConstraint<TAssertions> BeWritable([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> NotBeWritable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} not to be writable{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject!.CanWrite)
                 .FailWith("Expected {context:stream} not to be writable{reason}, but it was.");
@@ -101,14 +104,14 @@ public AndConstraint<TAssertions> NotBeWritable([StringSyntax("CompositeFormat")
     /// </param>
     public AndConstraint<TAssertions> BeSeekable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} to be seekable{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.CanSeek)
                 .FailWith("Expected {context:stream} to be seekable{reason}, but it was not.");
@@ -129,14 +132,14 @@ public AndConstraint<TAssertions> BeSeekable([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> NotBeSeekable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} not to be seekable{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject!.CanSeek)
                 .FailWith("Expected {context:stream} not to be seekable{reason}, but it was.");
@@ -157,14 +160,14 @@ public AndConstraint<TAssertions> NotBeSeekable([StringSyntax("CompositeFormat")
     /// </param>
     public AndConstraint<TAssertions> BeReadable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} to be readable{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.CanRead)
                 .FailWith("Expected {context:stream} to be readable{reason}, but it was not.");
@@ -185,14 +188,14 @@ public AndConstraint<TAssertions> BeReadable([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> NotBeReadable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} not to be readable{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject!.CanRead)
                 .FailWith("Expected {context:stream} not to be readable{reason}, but it was.");
@@ -215,13 +218,13 @@ public AndConstraint<TAssertions> NotBeReadable([StringSyntax("CompositeFormat")
     public AndConstraint<TAssertions> HavePosition(long expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the position of {context:stream} to be {0}{reason}, but found a <null> reference.",
                 expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             long position;
 
@@ -232,7 +235,7 @@ public AndConstraint<TAssertions> HavePosition(long expected,
             catch (Exception exception)
                 when (exception is IOException or NotSupportedException or ObjectDisposedException)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected the position of {context:stream} to be {0}{reason}, but it failed with:"
                                 + Environment.NewLine + "{1}",
@@ -241,7 +244,7 @@ public AndConstraint<TAssertions> HavePosition(long expected,
                 return new AndConstraint<TAssertions>((TAssertions)this);
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(position == expected)
                 .FailWith("Expected the position of {context:stream} to be {0}{reason}, but it was {1}.",
@@ -265,13 +268,13 @@ public AndConstraint<TAssertions> HavePosition(long expected,
     public AndConstraint<TAssertions> NotHavePosition(long unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the position of {context:stream} not to be {0}{reason}, but found a <null> reference.",
                 unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             long position;
 
@@ -282,7 +285,7 @@ public AndConstraint<TAssertions> NotHavePosition(long unexpected,
             catch (Exception exception)
                 when (exception is IOException or NotSupportedException or ObjectDisposedException)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected the position of {context:stream} not to be {0}{reason}, but it failed with:"
                                 + Environment.NewLine + "{1}",
@@ -291,7 +294,7 @@ public AndConstraint<TAssertions> NotHavePosition(long unexpected,
                 return new AndConstraint<TAssertions>((TAssertions)this);
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(position != unexpected)
                 .FailWith("Expected the position of {context:stream} not to be {0}{reason}, but it was.",
@@ -315,13 +318,13 @@ public AndConstraint<TAssertions> NotHavePosition(long unexpected,
     public AndConstraint<TAssertions> HaveLength(long expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the length of {context:stream} to be {0}{reason}, but found a <null> reference.",
                 expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             long length;
 
@@ -332,7 +335,7 @@ public AndConstraint<TAssertions> HaveLength(long expected,
             catch (Exception exception)
                 when (exception is IOException or NotSupportedException or ObjectDisposedException)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected the length of {context:stream} to be {0}{reason}, but it failed with:"
                                 + Environment.NewLine + "{1}",
@@ -341,7 +344,7 @@ public AndConstraint<TAssertions> HaveLength(long expected,
                 return new AndConstraint<TAssertions>((TAssertions)this);
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(length == expected)
                 .FailWith("Expected the length of {context:stream} to be {0}{reason}, but it was {1}.",
@@ -365,13 +368,13 @@ public AndConstraint<TAssertions> HaveLength(long expected,
     public AndConstraint<TAssertions> NotHaveLength(long unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the length of {context:stream} not to be {0}{reason}, but found a <null> reference.",
                 unexpected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             long length;
 
@@ -382,7 +385,7 @@ public AndConstraint<TAssertions> NotHaveLength(long unexpected,
             catch (Exception exception)
                 when (exception is IOException or NotSupportedException or ObjectDisposedException)
             {
-                Execute.Assertion
+                assertionChain
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected the length of {context:stream} not to be {0}{reason}, but it failed with:"
                                 + Environment.NewLine + "{1}",
@@ -391,7 +394,7 @@ public AndConstraint<TAssertions> NotHaveLength(long unexpected,
                 return new AndConstraint<TAssertions>((TAssertions)this);
             }
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(length != unexpected)
                 .FailWith("Expected the length of {context:stream} not to be {0}{reason}, but it was.",
@@ -413,14 +416,14 @@ public AndConstraint<TAssertions> NotHaveLength(long unexpected,
     /// </param>
     public AndConstraint<TAssertions> BeReadOnly([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} to be read-only{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject!.CanWrite && Subject.CanRead)
                 .FailWith("Expected {context:stream} to be read-only{reason}, but it was writable or not readable.");
@@ -441,14 +444,14 @@ public AndConstraint<TAssertions> BeReadOnly([StringSyntax("CompositeFormat")] s
     /// </param>
     public AndConstraint<TAssertions> NotBeReadOnly([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} not to be read-only{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.CanWrite || !Subject.CanRead)
                 .FailWith("Expected {context:stream} not to be read-only{reason}, but it was.");
@@ -469,14 +472,14 @@ public AndConstraint<TAssertions> NotBeReadOnly([StringSyntax("CompositeFormat")
     /// </param>
     public AndConstraint<TAssertions> BeWriteOnly([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} to be write-only{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.CanWrite && !Subject.CanRead)
                 .FailWith("Expected {context:stream} to be write-only{reason}, but it was readable or not writable.");
@@ -497,14 +500,14 @@ public AndConstraint<TAssertions> BeWriteOnly([StringSyntax("CompositeFormat")]
     /// </param>
     public AndConstraint<TAssertions> NotBeWriteOnly([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected {context:stream} not to be write-only{reason}, but found a <null> reference.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject!.CanWrite || Subject.CanRead)
                 .FailWith("Expected {context:stream} not to be write-only{reason}, but it was.");
diff --git a/Src/FluentAssertions/Types/AssemblyAssertions.cs b/Src/FluentAssertions/Types/AssemblyAssertions.cs
index 91e170fa67..5ceac78772 100644
--- a/Src/FluentAssertions/Types/AssemblyAssertions.cs
+++ b/Src/FluentAssertions/Types/AssemblyAssertions.cs
@@ -14,12 +14,15 @@ namespace FluentAssertions.Types;
 /// </summary>
 public class AssemblyAssertions : ReferenceTypeAssertions<Assembly, AssemblyAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="AssemblyAssertions" /> class.
     /// </summary>
-    public AssemblyAssertions(Assembly assembly)
-        : base(assembly)
+    public AssemblyAssertions(Assembly assembly, AssertionChain assertionChain)
+        : base(assembly, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -41,19 +44,19 @@ public AndConstraint<AssemblyAssertions> NotReference(Assembly assembly,
 
         var assemblyName = assembly.GetName().Name;
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected assembly not to reference assembly {0}{reason}, but {context:assembly} is <null>.",
                 assemblyName);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             var subjectName = Subject!.GetName().Name;
 
             IEnumerable<string> references = Subject.GetReferencedAssemblies().Select(x => x.Name);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!references.Contains(assemblyName))
                 .FailWith("Expected assembly {0} not to reference assembly {1}{reason}.", subjectName, assemblyName);
@@ -81,18 +84,18 @@ public AndConstraint<AssemblyAssertions> Reference(Assembly assembly,
 
         var assemblyName = assembly.GetName().Name;
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected assembly to reference assembly {0}{reason}, but {context:assembly} is <null>.", assemblyName);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             var subjectName = Subject!.GetName().Name;
 
             IEnumerable<string> references = Subject.GetReferencedAssemblies().Select(x => x.Name);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(references.Contains(assemblyName))
                 .FailWith("Expected assembly {0} to reference assembly {1}{reason}, but it does not.", subjectName, assemblyName);
@@ -120,7 +123,7 @@ public AndWhichConstraint<AssemblyAssertions, Type> DefineType(string @namespace
     {
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected assembly to define type {0}.{1}{reason}, but {context:assembly} is <null>.",
@@ -128,11 +131,11 @@ public AndWhichConstraint<AssemblyAssertions, Type> DefineType(string @namespace
 
         Type foundType = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             foundType = Subject!.GetTypes().SingleOrDefault(t => t.Namespace == @namespace && t.Name == name);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(foundType is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected assembly {0} to define type {1}.{2}{reason}, but it does not.",
@@ -150,15 +153,16 @@ public AndWhichConstraint<AssemblyAssertions, Type> DefineType(string @namespace
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndConstraint<AssemblyAssertions> BeUnsigned([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<AssemblyAssertions> BeUnsigned([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .FailWith("Can't check for assembly signing if {context:assembly} reference is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject!.GetName().GetPublicKey() is not { Length: > 0 })
                 .FailWith(
@@ -181,29 +185,28 @@ public AndConstraint<AssemblyAssertions> BeUnsigned([StringSyntax("CompositeForm
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="publicKey"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="publicKey"/> is empty.</exception>
-    public AndConstraint<AssemblyAssertions> BeSignedWithPublicKey(string publicKey, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<AssemblyAssertions> BeSignedWithPublicKey(string publicKey,
+        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNullOrEmpty(publicKey);
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .FailWith("Can't check for assembly signing if {context:assembly} reference is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             var bytes = Subject!.GetName().GetPublicKey() ?? [];
             string assemblyKey = ToHexString(bytes);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected assembly {0} to have public key {1} ", Subject.FullName, publicKey)
-                .ForCondition(bytes.Length != 0)
-                .FailWith("{reason}, but it is unsigned.")
-                .Then
-                .ForCondition(string.Equals(assemblyKey, publicKey, StringComparison.OrdinalIgnoreCase))
-                .FailWith("{reason}, but it has {0} instead.", assemblyKey)
-                .Then
-                .ClearExpectation();
+                .WithExpectation("Expected assembly {0} to have public key {1} ", Subject.FullName, publicKey, chain => chain
+                    .ForCondition(bytes.Length != 0)
+                    .FailWith("{reason}, but it is unsigned.")
+                    .Then
+                    .ForCondition(string.Equals(assemblyKey, publicKey, StringComparison.OrdinalIgnoreCase))
+                    .FailWith("{reason}, but it has {0} instead.", assemblyKey));
         }
 
         return new AndConstraint<AssemblyAssertions>(this);
diff --git a/Src/FluentAssertions/Types/ConstructorInfoAssertions.cs b/Src/FluentAssertions/Types/ConstructorInfoAssertions.cs
index cb66005a01..d3b1a3353e 100644
--- a/Src/FluentAssertions/Types/ConstructorInfoAssertions.cs
+++ b/Src/FluentAssertions/Types/ConstructorInfoAssertions.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Reflection;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Types;
 
@@ -13,8 +14,9 @@ public class ConstructorInfoAssertions : MethodBaseAssertions<ConstructorInfo, C
     /// Initializes a new instance of the <see cref="ConstructorInfoAssertions"/> class.
     /// </summary>
     /// <param name="constructorInfo">The constructorInfo from which to select properties.</param>
-    public ConstructorInfoAssertions(ConstructorInfo constructorInfo)
-        : base(constructorInfo)
+    /// <param name="assertionChain"></param>
+    public ConstructorInfoAssertions(ConstructorInfo constructorInfo, AssertionChain assertionChain)
+        : base(constructorInfo, assertionChain)
     {
     }
 
@@ -23,7 +25,7 @@ internal static string GetDescriptionFor(ConstructorInfo constructorInfo)
         return $"{constructorInfo.DeclaringType}({GetParameterString(constructorInfo)})";
     }
 
-    internal override string SubjectDescription => GetDescriptionFor(Subject);
+    protected override string SubjectDescription => GetDescriptionFor(Subject);
 
     protected override string Identifier => "constructor";
 }
diff --git a/Src/FluentAssertions/Types/MemberInfoAssertions.cs b/Src/FluentAssertions/Types/MemberInfoAssertions.cs
index 082e9de153..7f447ecbd8 100644
--- a/Src/FluentAssertions/Types/MemberInfoAssertions.cs
+++ b/Src/FluentAssertions/Types/MemberInfoAssertions.cs
@@ -19,9 +19,12 @@ public abstract class MemberInfoAssertions<TSubject, TAssertions> : ReferenceTyp
     where TSubject : MemberInfo
     where TAssertions : MemberInfoAssertions<TSubject, TAssertions>
 {
-    protected MemberInfoAssertions(TSubject subject)
-        : base(subject)
+    private readonly AssertionChain assertionChain;
+
+    protected MemberInfoAssertions(TSubject subject, AssertionChain assertionChain)
+        : base(subject, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -80,7 +83,7 @@ public AndWhichConstraint<MemberInfoAssertions<TSubject, TAssertions>, TAttribut
     {
         Guard.ThrowIfArgumentIsNull(isMatchingAttributePredicate);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
@@ -89,11 +92,11 @@ public AndWhichConstraint<MemberInfoAssertions<TSubject, TAssertions>, TAttribut
 
         IEnumerable<TAttribute> attributes = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             attributes = Subject.GetMatchingAttributes(isMatchingAttributePredicate);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(attributes.Any())
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -126,18 +129,18 @@ public AndConstraint<TAssertions> NotBeDecoratedWith<TAttribute>(
     {
         Guard.ThrowIfArgumentIsNull(isMatchingAttributePredicate);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected {Identifier} to not be decorated with {typeof(TAttribute)}{{reason}}" +
                 ", but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             IEnumerable<TAttribute> attributes = Subject.GetMatchingAttributes(isMatchingAttributePredicate);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!attributes.Any())
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -150,5 +153,5 @@ public AndConstraint<TAssertions> NotBeDecoratedWith<TAttribute>(
 
     protected override string Identifier => "member";
 
-    internal virtual string SubjectDescription => $"{Subject.DeclaringType}.{Subject.Name}";
+    protected virtual string SubjectDescription => $"{Subject.DeclaringType}.{Subject.Name}";
 }
diff --git a/Src/FluentAssertions/Types/MethodBaseAssertions.cs b/Src/FluentAssertions/Types/MethodBaseAssertions.cs
index c45591c3c6..3b7c995b5d 100644
--- a/Src/FluentAssertions/Types/MethodBaseAssertions.cs
+++ b/Src/FluentAssertions/Types/MethodBaseAssertions.cs
@@ -17,9 +17,12 @@ public abstract class MethodBaseAssertions<TSubject, TAssertions> : MemberInfoAs
     where TSubject : MethodBase
     where TAssertions : MethodBaseAssertions<TSubject, TAssertions>
 {
-    protected MethodBaseAssertions(TSubject subject)
-        : base(subject)
+    private readonly AssertionChain assertionChain;
+
+    protected MethodBaseAssertions(TSubject subject, AssertionChain assertionChain)
+        : base(subject, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -41,20 +44,23 @@ public AndConstraint<TAssertions> HaveAccessModifier(
     {
         Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith($"Expected method to be {accessModifier}{{reason}}, but {{context:member}} is <null>.");
+            .FailWith($"Expected method to be {accessModifier}{{reason}}, but {{context:method}} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
 
-            Execute.Assertion
+            var subject = assertionChain.HasOverriddenCallerIdentifier
+                ? assertionChain.CallerIdentifier
+                : "method " + Subject.ToFormattedString();
+
+            assertionChain
                 .ForCondition(accessModifier == subjectAccessModifier)
                 .BecauseOf(because, becauseArgs)
-                .FailWith(
-                    $"Expected method {Subject!.Name} to be {accessModifier}{{reason}}, but it is {subjectAccessModifier}.");
+                .FailWith($"Expected {subject} to be {accessModifier}{{reason}}, but it is {subjectAccessModifier}.");
         }
 
         return new AndConstraint<TAssertions>((TAssertions)this);
@@ -78,19 +84,23 @@ public AndConstraint<TAssertions> NotHaveAccessModifier(CSharpAccessModifier acc
     {
         Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith($"Expected method not to be {accessModifier}{{reason}}, but {{context:member}} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
 
-            Execute.Assertion
+            var subject = assertionChain.HasOverriddenCallerIdentifier
+                ? assertionChain.CallerIdentifier
+                : "method " + Subject.ToFormattedString();
+
+            assertionChain
                 .ForCondition(accessModifier != subjectAccessModifier)
                 .BecauseOf(because, becauseArgs)
-                .FailWith($"Expected method {Subject!.Name} not to be {accessModifier}{{reason}}, but it is.");
+                .FailWith($"Expected {subject} not to be {accessModifier}{{reason}}, but it is.");
         }
 
         return new AndConstraint<TAssertions>((TAssertions)this);
diff --git a/Src/FluentAssertions/Types/MethodInfoAssertions.cs b/Src/FluentAssertions/Types/MethodInfoAssertions.cs
index c4dff054eb..9aa4beef1e 100644
--- a/Src/FluentAssertions/Types/MethodInfoAssertions.cs
+++ b/Src/FluentAssertions/Types/MethodInfoAssertions.cs
@@ -13,9 +13,12 @@ namespace FluentAssertions.Types;
 [DebuggerNonUserCode]
 public class MethodInfoAssertions : MethodBaseAssertions<MethodInfo, MethodInfoAssertions>
 {
-    public MethodInfoAssertions(MethodInfo methodInfo)
-        : base(methodInfo)
+    private readonly AssertionChain assertionChain;
+
+    public MethodInfoAssertions(MethodInfo methodInfo, AssertionChain assertionChain)
+        : base(methodInfo, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -30,14 +33,14 @@ public MethodInfoAssertions(MethodInfo methodInfo)
     /// </param>
     public AndConstraint<MethodInfoAssertions> BeVirtual([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected method to be virtual{reason}, but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!Subject.IsNonVirtual())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected method " + SubjectDescription + " to be virtual{reason}, but it is not virtual.");
@@ -58,14 +61,14 @@ public AndConstraint<MethodInfoAssertions> BeVirtual([StringSyntax("CompositeFor
     /// </param>
     public AndConstraint<MethodInfoAssertions> NotBeVirtual([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected method not to be virtual{reason}, but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject.IsNonVirtual())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected method " + SubjectDescription + " not to be virtual{reason}, but it is.");
@@ -86,14 +89,14 @@ public AndConstraint<MethodInfoAssertions> NotBeVirtual([StringSyntax("Composite
     /// </param>
     public AndConstraint<MethodInfoAssertions> BeAsync([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected method to be async{reason}, but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject.IsAsync())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected method " + SubjectDescription + " to be async{reason}, but it is not.");
@@ -114,14 +117,14 @@ public AndConstraint<MethodInfoAssertions> BeAsync([StringSyntax("CompositeForma
     /// </param>
     public AndConstraint<MethodInfoAssertions> NotBeAsync([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected method not to be async{reason}, but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(!Subject.IsAsync())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected method " + SubjectDescription + " not to be async{reason}, but it is.");
@@ -143,14 +146,14 @@ public AndConstraint<MethodInfoAssertions> NotBeAsync([StringSyntax("CompositeFo
     public AndConstraint<MethodBaseAssertions<MethodInfo, MethodInfoAssertions>> ReturnVoid(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the return type of method to be void{reason}, but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(typeof(void) == Subject!.ReturnType)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected the return type of method " + Subject.Name + " to be void{reason}, but it is {0}.",
@@ -177,14 +180,14 @@ public AndConstraint<MethodBaseAssertions<MethodInfo, MethodInfoAssertions>> Ret
     {
         Guard.ThrowIfArgumentIsNull(returnType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the return type of method to be {0}{reason}, but {context:member} is <null>.", returnType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(returnType == Subject!.ReturnType)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected the return type of method " + Subject.Name + " to be {0}{reason}, but it is {1}.",
@@ -224,14 +227,14 @@ public AndConstraint<MethodBaseAssertions<MethodInfo, MethodInfoAssertions>> Ret
     public AndConstraint<MethodBaseAssertions<MethodInfo, MethodInfoAssertions>> NotReturnVoid(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the return type of method not to be void{reason}, but {context:member} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(typeof(void) != Subject!.ReturnType)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected the return type of method " + Subject.Name + " not to be void{reason}, but it is.");
@@ -257,15 +260,15 @@ public AndConstraint<MethodBaseAssertions<MethodInfo, MethodInfoAssertions>> Not
     {
         Guard.ThrowIfArgumentIsNull(returnType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 "Expected the return type of method not to be {0}{reason}, but {context:member} is <null>.", returnType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(returnType != Subject!.ReturnType)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -304,7 +307,7 @@ internal static string GetDescriptionFor(MethodInfo method)
         return $"{returnTypeName} {method.DeclaringType}.{method.Name}";
     }
 
-    internal override string SubjectDescription => GetDescriptionFor(Subject);
+    protected override string SubjectDescription => GetDescriptionFor(Subject);
 
     protected override string Identifier => "method";
 }
diff --git a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs
index dfc2effa49..71b3c51213 100644
--- a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs
+++ b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs
@@ -18,13 +18,16 @@ namespace FluentAssertions.Types;
 [DebuggerNonUserCode]
 public class MethodInfoSelectorAssertions
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="MethodInfoSelectorAssertions"/> class.
     /// </summary>
     /// <param name="methods">The methods to assert.</param>
     /// <exception cref="ArgumentNullException"><paramref name="methods"/> is <see langword="null"/>.</exception>
-    public MethodInfoSelectorAssertions(params MethodInfo[] methods)
+    public MethodInfoSelectorAssertions(AssertionChain assertionChain, params MethodInfo[] methods)
     {
+        this.assertionChain = assertionChain;
         Guard.ThrowIfArgumentIsNull(methods);
 
         SubjectMethods = methods;
@@ -54,7 +57,7 @@ public AndConstraint<MethodInfoSelectorAssertions> BeVirtual([StringSyntax("Comp
             Environment.NewLine +
             GetDescriptionsFor(nonVirtualMethods);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(nonVirtualMethods.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(failureMessage);
@@ -81,7 +84,7 @@ public AndConstraint<MethodInfoSelectorAssertions> NotBeVirtual([StringSyntax("C
             Environment.NewLine +
             GetDescriptionsFor(virtualMethods);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(virtualMethods.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(failureMessage);
@@ -118,7 +121,7 @@ public AndConstraint<MethodInfoSelectorAssertions> BeAsync([StringSyntax("Compos
             Environment.NewLine +
             GetDescriptionsFor(nonAsyncMethods);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(nonAsyncMethods.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(failureMessage);
@@ -145,7 +148,7 @@ public AndConstraint<MethodInfoSelectorAssertions> NotBeAsync([StringSyntax("Com
             Environment.NewLine +
             GetDescriptionsFor(asyncMethods);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(asyncMethods.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(failureMessage);
@@ -199,7 +202,7 @@ public AndConstraint<MethodInfoSelectorAssertions> BeDecoratedWith<TAttribute>(
             Environment.NewLine +
             GetDescriptionsFor(methodsWithoutAttribute);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(methodsWithoutAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(failureMessage, typeof(TAttribute));
@@ -253,7 +256,7 @@ public AndConstraint<MethodInfoSelectorAssertions> NotBeDecoratedWith<TAttribute
             Environment.NewLine +
             GetDescriptionsFor(methodsWithAttribute);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(methodsWithAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(failureMessage, typeof(TAttribute));
@@ -280,7 +283,7 @@ public AndConstraint<MethodInfoSelectorAssertions> Be(CSharpAccessModifier acces
         var message = $"Expected all selected methods to be {accessModifier}{{reason}}, but the following methods are not:" +
             Environment.NewLine + GetDescriptionsFor(methods);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(methods.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(message);
@@ -307,7 +310,7 @@ public AndConstraint<MethodInfoSelectorAssertions> NotBe(CSharpAccessModifier ac
         var message = $"Expected all selected methods to not be {accessModifier}{{reason}}, but the following methods are:" +
             Environment.NewLine + GetDescriptionsFor(methods);
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(methods.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(message);
diff --git a/Src/FluentAssertions/Types/PropertyInfoAssertions.cs b/Src/FluentAssertions/Types/PropertyInfoAssertions.cs
index 0201ccde6b..c5b4fd605e 100644
--- a/Src/FluentAssertions/Types/PropertyInfoAssertions.cs
+++ b/Src/FluentAssertions/Types/PropertyInfoAssertions.cs
@@ -1,9 +1,11 @@
 using System;
+using System.Data.Common;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
+using FluentAssertions.Formatting;
 
 namespace FluentAssertions.Types;
 
@@ -13,9 +15,12 @@ namespace FluentAssertions.Types;
 [DebuggerNonUserCode]
 public class PropertyInfoAssertions : MemberInfoAssertions<PropertyInfo, PropertyInfoAssertions>
 {
-    public PropertyInfoAssertions(PropertyInfo propertyInfo)
-        : base(propertyInfo)
+    private readonly AssertionChain assertionChain;
+
+    public PropertyInfoAssertions(PropertyInfo propertyInfo, AssertionChain assertionChain)
+        : base(propertyInfo, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -31,18 +36,18 @@ public PropertyInfoAssertions(PropertyInfo propertyInfo)
     public AndConstraint<PropertyInfoAssertions> BeVirtual(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+            ? assertionChain.CallerIdentifier
+            : "property " + Subject.ToFormattedString();
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith("Expected property to be virtual{reason}, but {context:property} is <null>.");
-
-        if (success)
-        {
-            Execute.Assertion
-                .ForCondition(Subject.IsVirtual())
-                .BecauseOf(because, becauseArgs)
-                .FailWith($"Expected property {GetDescriptionFor(Subject)} to be virtual{{reason}}, but it is not.");
-        }
+            .FailWith("Expected property to be virtual{reason}, but {context:property} is <null>.")
+            .Then
+            .ForCondition(Subject.IsVirtual())
+            .BecauseOf(because, becauseArgs)
+            .FailWith($"Expected {subjectDescription} to be virtual{{reason}}, but it is not.");
 
         return new AndConstraint<PropertyInfoAssertions>(this);
     }
@@ -57,20 +62,21 @@ public AndConstraint<PropertyInfoAssertions> BeVirtual(
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<PropertyInfoAssertions> NotBeVirtual([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<PropertyInfoAssertions> NotBeVirtual([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+            ? assertionChain.CallerIdentifier
+            : "property " + Subject.ToFormattedString();
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith("Expected property not to be virtual{reason}, but {context:property} is <null>.");
-
-        if (success)
-        {
-            Execute.Assertion
-                .ForCondition(!Subject.IsVirtual())
-                .BecauseOf(because, becauseArgs)
-                .FailWith($"Expected property {GetDescriptionFor(Subject)} not to be virtual{{reason}}, but it is.");
-        }
+            .FailWith("Expected property not to be virtual{reason}, but {context:property} is <null>.")
+            .Then
+            .ForCondition(!Subject.IsVirtual())
+            .BecauseOf(because, becauseArgs)
+            .FailWith($"Expected property {subjectDescription} not to be virtual{{reason}}, but it is.");
 
         return new AndConstraint<PropertyInfoAssertions>(this);
     }
@@ -88,20 +94,20 @@ public AndConstraint<PropertyInfoAssertions> NotBeVirtual([StringSyntax("Composi
     public AndConstraint<PropertyInfoAssertions> BeWritable(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+            ? assertionChain.CallerIdentifier
+            : "property " + Subject.ToFormattedString();
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith("Expected property to have a setter{reason}, but {context:property} is <null>.");
-
-        if (success)
-        {
-            Execute.Assertion
-                .ForCondition(Subject!.CanWrite)
-                .BecauseOf(because, becauseArgs)
-                .FailWith(
-                    "Expected {context:property} {0} to have a setter{reason}.",
-                    Subject);
-        }
+            .FailWith("Expected property to have a setter{reason}, but {context:property} is <null>.")
+            .Then
+            .ForCondition(Subject!.CanWrite)
+            .BecauseOf(because, becauseArgs)
+            .FailWith(
+                $"Expected {subjectDescription} to have a setter{{reason}}.",
+                Subject);
 
         return new AndConstraint<PropertyInfoAssertions>(this);
     }
@@ -124,24 +130,25 @@ public AndConstraint<PropertyInfoAssertions> BeWritable(CSharpAccessModifier acc
     {
         Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
 
-        bool success = Execute.Assertion
+        var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+            ? assertionChain.CallerIdentifier
+            : "property " + Subject.ToFormattedString();
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith($"Expected {Identifier} to be {accessModifier}{{reason}}, but {{context:property}} is <null>.");
+            .FailWith($"Expected {{context:project}} to be {accessModifier}{{reason}}, but it is <null>.")
+            .Then
+            .ForCondition(Subject!.CanWrite)
+            .BecauseOf(because, becauseArgs)
+            .FailWith($"Expected {subjectDescription} to have a setter{{reason}}.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            success = Execute.Assertion
-                .ForCondition(Subject!.CanWrite)
-                .BecauseOf(because, becauseArgs)
-                .FailWith(
-                    "Expected {context:property} {0} to have a setter{reason}.",
-                    Subject);
+            assertionChain.OverrideCallerIdentifier(() => "setter of " + subjectDescription);
+            assertionChain.ReuseOnce();
 
-            if (success)
-            {
-                Subject!.GetSetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
-            }
+            Subject!.GetSetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -160,20 +167,18 @@ public AndConstraint<PropertyInfoAssertions> BeWritable(CSharpAccessModifier acc
     public AndConstraint<PropertyInfoAssertions> NotBeWritable(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+            ? assertionChain.CallerIdentifier
+            : "property " + Subject.ToFormattedString();
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith("Expected property not to have a setter{reason}, but {context:property} is <null>.");
-
-        if (success)
-        {
-            Execute.Assertion
-                .ForCondition(!Subject!.CanWrite)
-                .BecauseOf(because, becauseArgs)
-                .FailWith(
-                    "Expected {context:property} {0} not to have a setter{reason}.",
-                    Subject);
-        }
+            .FailWith("Expected {context:property} not to have a setter{reason}, but it is <null>.")
+            .Then
+            .ForCondition(!Subject!.CanWrite)
+            .BecauseOf(because, becauseArgs)
+            .FailWith($"Did not expect {subjectDescription} to have a setter{{reason}}.");
 
         return new AndConstraint<PropertyInfoAssertions>(this);
     }
@@ -188,18 +193,23 @@ public AndConstraint<PropertyInfoAssertions> NotBeWritable(
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<PropertyInfoAssertions> BeReadable([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<PropertyInfoAssertions> BeReadable([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected property to have a getter{reason}, but {context:property} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion.ForCondition(Subject!.CanRead)
+            var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+                ? assertionChain.CallerIdentifier
+                : "property " + Subject.ToFormattedString();
+
+            assertionChain.ForCondition(Subject!.CanRead)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected property " + Subject.Name + " to have a getter{reason}, but it does not.");
+                .FailWith($"Expected property {subjectDescription} to have a getter{{reason}}, but it does not.");
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -223,21 +233,25 @@ public AndConstraint<PropertyInfoAssertions> BeReadable(CSharpAccessModifier acc
     {
         Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
 
-        bool success = Execute.Assertion
+        var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+            ? assertionChain.CallerIdentifier
+            : "property " + Subject.ToFormattedString();
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith($"Expected {Identifier} to be {accessModifier}{{reason}}, but {{context:property}} is <null>.");
+            .FailWith($"Expected {{context:property}} to be {accessModifier}{{reason}}, but it is <null>.")
+            .Then
+            .ForCondition(Subject!.CanRead)
+            .BecauseOf(because, becauseArgs)
+            .FailWith($"Expected {subjectDescription} to have a getter{{reason}}, but it does not.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            success = Execute.Assertion.ForCondition(Subject!.CanRead)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected property " + Subject.Name + " to have a getter{reason}, but it does not.");
+            assertionChain.OverrideCallerIdentifier(() => "getter of " + subjectDescription);
+            assertionChain.ReuseOnce();
 
-            if (success)
-            {
-                Subject!.GetGetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
-            }
+            Subject!.GetGetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -256,19 +270,22 @@ public AndConstraint<PropertyInfoAssertions> BeReadable(CSharpAccessModifier acc
     public AndConstraint<PropertyInfoAssertions> NotBeReadable(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected property not to have a getter{reason}, but {context:property} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            var subjectDescription = assertionChain.HasOverriddenCallerIdentifier
+                ? assertionChain.CallerIdentifier
+                : "property " + Subject.ToFormattedString();
+
+            assertionChain
                 .ForCondition(!Subject!.CanRead)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
-                    "Expected {context:property} {0} not to have a getter{reason}.",
-                    Subject);
+                    $"Did not expect {subjectDescription} to have a getter{{reason}}.", Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -291,17 +308,17 @@ public AndConstraint<PropertyInfoAssertions> Return(Type propertyType,
     {
         Guard.ThrowIfArgumentIsNull(propertyType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type of property to be {0}{reason}, but {context:property} is <null>.", propertyType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion.ForCondition(Subject!.PropertyType == propertyType)
+            assertionChain.ForCondition(Subject!.PropertyType == propertyType)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected Type of property " + Subject.Name + " to be {0}{reason}, but it is {1}.",
-                    propertyType, Subject.PropertyType);
+                .FailWith("Expected type of property {2} to be {0}{reason}, but it is {1}.",
+                    propertyType, Subject.PropertyType, Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -318,7 +335,8 @@ public AndConstraint<PropertyInfoAssertions> Return(Type propertyType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<PropertyInfoAssertions> Return<TReturn>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<PropertyInfoAssertions> Return<TReturn>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return Return(typeof(TReturn), because, becauseArgs);
     }
@@ -340,17 +358,17 @@ public AndConstraint<PropertyInfoAssertions> NotReturn(Type propertyType,
     {
         Guard.ThrowIfArgumentIsNull(propertyType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type of property not to be {0}{reason}, but {context:property} is <null>.", propertyType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject!.PropertyType != propertyType)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected Type of property " + Subject.Name + " not to be {0}{reason}, but it is.", propertyType);
+                .FailWith("Expected type of property {1} not to be {0}{reason}, but it is.", propertyType, Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -367,24 +385,13 @@ public AndConstraint<PropertyInfoAssertions> NotReturn(Type propertyType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<PropertyInfoAssertions> NotReturn<TReturn>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<PropertyInfoAssertions> NotReturn<TReturn>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotReturn(typeof(TReturn), because, becauseArgs);
     }
 
-    internal static string GetDescriptionFor(PropertyInfo property)
-    {
-        if (property is null)
-        {
-            return string.Empty;
-        }
-
-        var propTypeName = property.PropertyType.Name;
-
-        return $"{propTypeName} {property.DeclaringType}.{property.Name}";
-    }
-
-    internal override string SubjectDescription => GetDescriptionFor(Subject);
+    protected override string SubjectDescription => Formatter.ToString(Subject);
 
     /// <summary>
     /// Returns the type of the subject the assertion applies on.
diff --git a/Src/FluentAssertions/Types/PropertyInfoSelectorAssertions.cs b/Src/FluentAssertions/Types/PropertyInfoSelectorAssertions.cs
index 6605f823e9..4aca174681 100644
--- a/Src/FluentAssertions/Types/PropertyInfoSelectorAssertions.cs
+++ b/Src/FluentAssertions/Types/PropertyInfoSelectorAssertions.cs
@@ -6,6 +6,7 @@
 using System.Reflection;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
+using FluentAssertions.Formatting;
 
 namespace FluentAssertions.Types;
 
@@ -17,6 +18,8 @@ namespace FluentAssertions.Types;
 [DebuggerNonUserCode]
 public class PropertyInfoSelectorAssertions
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Gets the object whose value is being asserted.
     /// </summary>
@@ -27,8 +30,9 @@ public class PropertyInfoSelectorAssertions
     /// </summary>
     /// <param name="properties">The properties to assert.</param>
     /// <exception cref="ArgumentNullException"><paramref name="properties"/> is <see langword="null"/>.</exception>
-    public PropertyInfoSelectorAssertions(params PropertyInfo[] properties)
+    public PropertyInfoSelectorAssertions(AssertionChain assertionChain, params PropertyInfo[] properties)
     {
+        this.assertionChain = assertionChain;
         Guard.ThrowIfArgumentIsNull(properties);
 
         SubjectProperties = properties;
@@ -48,7 +52,7 @@ public AndConstraint<PropertyInfoSelectorAssertions> BeVirtual([StringSyntax("Co
     {
         PropertyInfo[] nonVirtualProperties = GetAllNonVirtualPropertiesFromSelection();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(nonVirtualProperties.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -72,7 +76,7 @@ public AndConstraint<PropertyInfoSelectorAssertions> NotBeVirtual([StringSyntax(
     {
         PropertyInfo[] virtualProperties = GetAllVirtualPropertiesFromSelection();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(virtualProperties.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -96,7 +100,7 @@ public AndConstraint<PropertyInfoSelectorAssertions> BeWritable([StringSyntax("C
     {
         PropertyInfo[] readOnlyProperties = GetAllReadOnlyPropertiesFromSelection();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(readOnlyProperties.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -120,7 +124,7 @@ public AndConstraint<PropertyInfoSelectorAssertions> NotBeWritable([StringSyntax
     {
         PropertyInfo[] writableProperties = GetAllWritablePropertiesFromSelection();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(writableProperties.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -166,7 +170,7 @@ public AndConstraint<PropertyInfoSelectorAssertions> BeDecoratedWith<TAttribute>
     {
         PropertyInfo[] propertiesWithoutAttribute = GetPropertiesWithout<TAttribute>();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(propertiesWithoutAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -193,7 +197,7 @@ public AndConstraint<PropertyInfoSelectorAssertions> NotBeDecoratedWith<TAttribu
     {
         PropertyInfo[] propertiesWithAttribute = GetPropertiesWith<TAttribute>();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(propertiesWithAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -218,7 +222,7 @@ private PropertyInfo[] GetPropertiesWith<TAttribute>()
 
     private static string GetDescriptionsFor(IEnumerable<PropertyInfo> properties)
     {
-        IEnumerable<string> descriptions = properties.Select(property => PropertyInfoAssertions.GetDescriptionFor(property));
+        IEnumerable<string> descriptions = properties.Select(property => Formatter.ToString(property));
 
         return string.Join(Environment.NewLine, descriptions);
     }
diff --git a/Src/FluentAssertions/Types/TypeAssertions.cs b/Src/FluentAssertions/Types/TypeAssertions.cs
index 45cf1618cc..f16fadc14a 100644
--- a/Src/FluentAssertions/Types/TypeAssertions.cs
+++ b/Src/FluentAssertions/Types/TypeAssertions.cs
@@ -17,12 +17,15 @@ namespace FluentAssertions.Types;
 [DebuggerNonUserCode]
 public class TypeAssertions : ReferenceTypeAssertions<Type, TypeAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TypeAssertions"/> class.
     /// </summary>
-    public TypeAssertions(Type type)
-        : base(type)
+    public TypeAssertions(Type type, AssertionChain assertionChain)
+        : base(type, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -35,7 +38,8 @@ public TypeAssertions(Type type)
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TypeAssertions> Be<TExpected>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> Be<TExpected>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return Be(typeof(TExpected), because, becauseArgs);
     }
@@ -54,7 +58,7 @@ public AndConstraint<TypeAssertions> Be<TExpected>([StringSyntax("CompositeForma
     public AndConstraint<TypeAssertions> Be(Type expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject == expected)
             .FailWith(GetFailureMessageIfTypesAreDifferent(Subject, expected));
@@ -74,7 +78,8 @@ public AndConstraint<TypeAssertions> Be(Type expected,
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <returns>An <see cref="AndConstraint{T}"/> which can be used to chain assertions.</returns>
-    public new AndConstraint<TypeAssertions> BeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public new AndConstraint<TypeAssertions> BeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return BeAssignableTo(typeof(T), because, becauseArgs);
     }
@@ -101,7 +106,7 @@ public AndConstraint<TypeAssertions> Be(Type expected,
             ? Subject.IsAssignableToOpenGeneric(type)
             : type.IsAssignableFrom(Subject);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(isAssignable)
             .FailWith("Expected {context:type} {0} to be assignable to {1}{reason}, but it is not.", Subject, type);
@@ -121,7 +126,8 @@ public AndConstraint<TypeAssertions> Be(Type expected,
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <returns>An <see cref="AndConstraint{T}"/> which can be used to chain assertions.</returns>
-    public new AndConstraint<TypeAssertions> NotBeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public new AndConstraint<TypeAssertions> NotBeAssignableTo<T>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBeAssignableTo(typeof(T), because, becauseArgs);
     }
@@ -148,7 +154,7 @@ public AndConstraint<TypeAssertions> Be(Type expected,
             ? Subject.IsAssignableToOpenGeneric(type)
             : type.IsAssignableFrom(Subject);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(!isAssignable)
             .FailWith("Expected {context:type} {0} to not be assignable to {1}{reason}, but it is.", Subject, type);
@@ -193,7 +199,8 @@ private static string GetFailureMessageIfTypesAreDifferent(Type actual, Type exp
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TypeAssertions> NotBe<TUnexpected>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotBe<TUnexpected>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
         return NotBe(typeof(TUnexpected), because, becauseArgs);
     }
@@ -214,7 +221,7 @@ public AndConstraint<TypeAssertions> NotBe(Type unexpected,
     {
         string nameOfUnexpectedType = unexpected is not null ? $"[{unexpected.AssemblyQualifiedName}]" : "<null>";
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject != unexpected)
             .FailWith("Expected type not to be " + nameOfUnexpectedType + "{reason}, but it is.");
@@ -238,7 +245,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute
     {
         IEnumerable<TAttribute> attributes = Subject.GetMatchingAttributes<TAttribute>();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(attributes.Any())
             .FailWith("Expected type {0} to be decorated with {1}{reason}, but the attribute was not found.",
@@ -273,7 +280,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute
 
         IEnumerable<TAttribute> attributes = Subject.GetMatchingAttributes(isMatchingAttributePredicate);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(attributes.Any())
             .FailWith(
@@ -299,7 +306,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<T
     {
         IEnumerable<TAttribute> attributes = Subject.GetMatchingOrInheritedAttributes<TAttribute>();
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(attributes.Any())
             .FailWith("Expected type {0} to be decorated with or inherit {1}{reason}, but the attribute was not found.",
@@ -334,7 +341,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<T
 
         IEnumerable<TAttribute> attributes = Subject.GetMatchingOrInheritedAttributes(isMatchingAttributePredicate);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(attributes.Any())
             .FailWith(
@@ -354,10 +361,11 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<T
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndConstraint<TypeAssertions> NotBeDecoratedWith<TAttribute>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotBeDecoratedWith<TAttribute>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TAttribute : Attribute
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(!Subject.IsDecoratedWith<TAttribute>())
             .FailWith("Expected type {0} to not be decorated with {1}{reason}, but the attribute was found.",
@@ -388,7 +396,7 @@ public AndConstraint<TypeAssertions> NotBeDecoratedWith<TAttribute>(
     {
         Guard.ThrowIfArgumentIsNull(isMatchingAttributePredicate);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(!Subject.IsDecoratedWith(isMatchingAttributePredicate))
             .FailWith(
@@ -413,7 +421,7 @@ public AndConstraint<TypeAssertions> NotBeDecoratedWithOrInherit<TAttribute>(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TAttribute : Attribute
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(!Subject.IsDecoratedWithOrInherit<TAttribute>())
             .FailWith("Expected type {0} to not be decorated with or inherit {1}{reason}, but the attribute was found.",
@@ -445,7 +453,7 @@ public AndConstraint<TypeAssertions> NotBeDecoratedWithOrInherit<TAttribute>(
     {
         Guard.ThrowIfArgumentIsNull(isMatchingAttributePredicate);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(!Subject.IsDecoratedWithOrInherit(isMatchingAttributePredicate))
             .FailWith(
@@ -482,16 +490,17 @@ private bool AssertSubjectImplements(Type interfaceType,
     {
         bool containsInterface = interfaceType.IsAssignableFrom(Subject) && interfaceType != Subject;
 
-        return Execute.Assertion
-                .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected type {0} to implement interface {1}{reason}", Subject, interfaceType)
-                .ForCondition(interfaceType.IsInterface)
-                .FailWith(", but {0} is not an interface.", interfaceType)
-                .Then
-                .ForCondition(containsInterface)
-                .FailWith(", but it does not.")
-                .Then
-                .ClearExpectation();
+        assertionChain
+            .BecauseOf(because, becauseArgs)
+            .WithExpectation("Expected type {0} to implement interface {1}{reason}", Subject, interfaceType, chain => chain
+
+        .ForCondition(interfaceType.IsInterface)
+            .FailWith(", but {0} is not an interface.", interfaceType)
+            .Then
+            .ForCondition(containsInterface)
+            .FailWith(", but it does not."));
+
+        return assertionChain.Succeeded;
     }
 
     /// <summary>
@@ -505,7 +514,8 @@ private bool AssertSubjectImplements(Type interfaceType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndConstraint<TypeAssertions> Implement<TInterface>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> Implement<TInterface>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TInterface : class
     {
         return Implement(typeof(TInterface), because, becauseArgs);
@@ -530,16 +540,15 @@ public AndConstraint<TypeAssertions> NotImplement(Type interfaceType,
 
         bool containsInterface = interfaceType.IsAssignableFrom(Subject) && interfaceType != Subject;
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected type {0} to not implement interface {1}{reason}", Subject, interfaceType)
-            .ForCondition(interfaceType.IsInterface)
+            .WithExpectation("Expected type {0} to not implement interface {1}{reason}", Subject, interfaceType, chain => chain
+
+        .ForCondition(interfaceType.IsInterface)
             .FailWith(", but {0} is not an interface.", interfaceType)
             .Then
             .ForCondition(!containsInterface)
-            .FailWith(", but it does.", interfaceType)
-            .Then
-            .ClearExpectation();
+            .FailWith(", but it does.", interfaceType));
 
         return new AndConstraint<TypeAssertions>(this);
     }
@@ -555,7 +564,8 @@ public AndConstraint<TypeAssertions> NotImplement(Type interfaceType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndConstraint<TypeAssertions> NotImplement<TInterface>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotImplement<TInterface>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TInterface : class
     {
         return NotImplement(typeof(TInterface), because, becauseArgs);
@@ -582,16 +592,15 @@ public AndConstraint<TypeAssertions> BeDerivedFrom(Type baseType,
             ? Subject.IsDerivedFromOpenGeneric(baseType)
             : Subject.IsSubclassOf(baseType);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected type {0} to be derived from {1}{reason}", Subject, baseType)
-            .ForCondition(!baseType.IsInterface)
+            .WithExpectation("Expected type {0} to be derived from {1}{reason}", Subject, baseType, chain => chain
+
+        .ForCondition(!baseType.IsInterface)
             .FailWith(", but {0} is an interface.", baseType)
             .Then
             .ForCondition(isDerivedFrom)
-            .FailWith(", but it is not.")
-            .Then
-            .ClearExpectation();
+            .FailWith(", but it is not."));
 
         return new AndConstraint<TypeAssertions>(this);
     }
@@ -607,7 +616,8 @@ public AndConstraint<TypeAssertions> BeDerivedFrom(Type baseType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndConstraint<TypeAssertions> BeDerivedFrom<TBaseClass>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> BeDerivedFrom<TBaseClass>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TBaseClass : class
     {
         return BeDerivedFrom(typeof(TBaseClass), because, becauseArgs);
@@ -634,16 +644,15 @@ public AndConstraint<TypeAssertions> NotBeDerivedFrom(Type baseType,
             ? Subject.IsDerivedFromOpenGeneric(baseType)
             : Subject.IsSubclassOf(baseType);
 
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
-            .WithExpectation("Expected type {0} not to be derived from {1}{reason}", Subject, baseType)
-            .ForCondition(!baseType.IsInterface)
+            .WithExpectation("Expected type {0} not to be derived from {1}{reason}", Subject, baseType, chain => chain
+
+        .ForCondition(!baseType.IsInterface)
             .FailWith(", but {0} is an interface.", baseType)
             .Then
             .ForCondition(!isDerivedFrom)
-            .FailWith(", but it is.")
-            .Then
-            .ClearExpectation();
+            .FailWith(", but it is."));
 
         return new AndConstraint<TypeAssertions>(this);
     }
@@ -659,7 +668,8 @@ public AndConstraint<TypeAssertions> NotBeDerivedFrom(Type baseType,
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
     /// </param>
-    public AndConstraint<TypeAssertions> NotBeDerivedFrom<TBaseClass>([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotBeDerivedFrom<TBaseClass>([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
         where TBaseClass : class
     {
         return NotBeDerivedFrom(typeof(TBaseClass), because, becauseArgs);
@@ -677,18 +687,19 @@ public AndConstraint<TypeAssertions> NotBeDerivedFrom<TBaseClass>([StringSyntax(
     /// </param>
     /// <exception cref="InvalidOperationException"><see cref="ReferenceTypeAssertions{Type, TypeAssertions}.Subject"/>
     /// is not a class.</exception>
-    public AndConstraint<TypeAssertions> BeSealed([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> BeSealed([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type to be sealed{reason}, but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             AssertThatSubjectIsClass();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject.IsCSharpSealed())
                 .FailWith("Expected type {0} to be sealed{reason}.", Subject);
@@ -709,18 +720,19 @@ public AndConstraint<TypeAssertions> BeSealed([StringSyntax("CompositeFormat")]
     /// </param>
     /// <exception cref="InvalidOperationException"><see cref="ReferenceTypeAssertions{Type, TypeAssertions}.Subject"/>
     /// is not a class.</exception>
-    public AndConstraint<TypeAssertions> NotBeSealed([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotBeSealed([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type not to be sealed{reason}, but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             AssertThatSubjectIsClass();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject.IsCSharpSealed())
                 .FailWith("Expected type {0} not to be sealed{reason}.", Subject);
@@ -741,18 +753,19 @@ public AndConstraint<TypeAssertions> NotBeSealed([StringSyntax("CompositeFormat"
     /// </param>
     /// <exception cref="InvalidOperationException"><see cref="ReferenceTypeAssertions{Type, TypeAssertions}.Subject"/>
     /// is not a class.</exception>
-    public AndConstraint<TypeAssertions> BeAbstract([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> BeAbstract([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type to be abstract{reason}, but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             AssertThatSubjectIsClass();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject.IsCSharpAbstract())
                 .FailWith("Expected {context:type} {0} to be abstract{reason}.", Subject);
@@ -773,18 +786,19 @@ public AndConstraint<TypeAssertions> BeAbstract([StringSyntax("CompositeFormat")
     /// </param>
     /// <exception cref="InvalidOperationException"><see cref="ReferenceTypeAssertions{Type, TypeAssertions}.Subject"/>
     /// is not a class.</exception>
-    public AndConstraint<TypeAssertions> NotBeAbstract([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotBeAbstract([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type not to be abstract{reason}, but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             AssertThatSubjectIsClass();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject.IsCSharpAbstract())
                 .FailWith("Expected type {0} not to be abstract{reason}.", Subject);
@@ -805,18 +819,19 @@ public AndConstraint<TypeAssertions> NotBeAbstract([StringSyntax("CompositeForma
     /// </param>
     /// <exception cref="InvalidOperationException"><see cref="ReferenceTypeAssertions{Type, TypeAssertions}.Subject"/>
     /// is not a class.</exception>
-    public AndConstraint<TypeAssertions> BeStatic([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> BeStatic([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type to be static{reason}, but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             AssertThatSubjectIsClass();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(Subject.IsCSharpStatic())
                 .FailWith("Expected type {0} to be static{reason}.", Subject);
@@ -837,18 +852,19 @@ public AndConstraint<TypeAssertions> BeStatic([StringSyntax("CompositeFormat")]
     /// </param>
     /// <exception cref="InvalidOperationException"><see cref="ReferenceTypeAssertions{Type, TypeAssertions}.Subject"/>
     /// is not a class.</exception>
-    public AndConstraint<TypeAssertions> NotBeStatic([StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    public AndConstraint<TypeAssertions> NotBeStatic([StringSyntax("CompositeFormat")] string because = "",
+        params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected type not to be static{reason}, but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             AssertThatSubjectIsClass();
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(!Subject.IsCSharpStatic())
                 .FailWith("Expected type {0} not to be static{reason}.", Subject);
@@ -880,26 +896,27 @@ public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveProperty(
         Guard.ThrowIfArgumentIsNull(propertyType);
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
-                $"Expected {propertyType.Name} {{context:type}}.{name} to exist{{reason}}, but {{context:type}} is <null>.");
+                $"Cannot determine if a type has a property named {name} if the type is <null>.");
 
         PropertyInfo propertyInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             propertyInfo = Subject.FindPropertyByName(name);
-            var propertyInfoDescription = PropertyInfoAssertions.GetDescriptionFor(propertyInfo);
 
-            Execute.Assertion
+            var subjectDescription = assertionChain.HasOverriddenCallerIdentifier ? assertionChain.CallerIdentifier : Subject!.Name;
+
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(propertyInfo is not null)
-                .FailWith($"Expected {propertyType.Name} {Subject}.{name} to exist{{reason}}, but it does not.")
+                .FailWith($"Expected {subjectDescription} to have a property {name} of type {propertyType.Name}{{reason}}, but it does not.")
                 .Then
                 .ForCondition(propertyInfo.PropertyType == propertyType)
-                .FailWith($"Expected {propertyInfoDescription} to be of type {propertyType}{{reason}}, but it is not.");
+                .FailWith($"Expected property {propertyInfo.Name} to be of type {propertyType}{{reason}}, but it is not.", propertyInfo);
         }
 
         return new AndWhichConstraint<TypeAssertions, PropertyInfo>(this, propertyInfo);
@@ -944,20 +961,21 @@ public AndConstraint<TypeAssertions> NotHaveProperty(string name,
     {
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith($"Expected {{context:type}}.{name} to not exist{{reason}}, but {{context:type}} is <null>.");
+            .FailWith($"Cannot determine if a type has an unexpected property named {name} if the type is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
+            var subjectDescription = assertionChain.HasOverriddenCallerIdentifier ? assertionChain.CallerIdentifier : Subject!.Name;
+
             PropertyInfo propertyInfo = Subject.FindPropertyByName(name);
-            var propertyInfoDescription = PropertyInfoAssertions.GetDescriptionFor(propertyInfo);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(propertyInfo is null)
-                .FailWith($"Expected {propertyInfoDescription} to not exist{{reason}}, but it does.");
+                .FailWith($"Did not expect {subjectDescription} to have a property {propertyInfo?.Name}{{reason}}, but it does.");
         }
 
         return new AndConstraint<TypeAssertions>(this);
@@ -986,27 +1004,22 @@ public AndConstraint<TypeAssertions> HaveExplicitProperty(
         Guard.ThrowIfArgumentIsNull(interfaceType);
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected {{context:type}} to explicitly implement {interfaceType}.{name}{{reason}}" +
                 ", but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded && AssertSubjectImplements(interfaceType, because, becauseArgs))
         {
-            success = AssertSubjectImplements(interfaceType, because, becauseArgs);
-
-            if (success)
-            {
-                var explicitlyImplementsProperty = Subject.HasExplicitlyImplementedProperty(interfaceType, name);
-
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .ForCondition(explicitlyImplementsProperty)
-                    .FailWith(
-                        $"Expected {Subject} to explicitly implement {interfaceType}.{name}{{reason}}, but it does not.");
-            }
+            var explicitlyImplementsProperty = Subject.HasExplicitlyImplementedProperty(interfaceType, name);
+
+            assertionChain
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(explicitlyImplementsProperty)
+                .FailWith(
+                    $"Expected {Subject} to explicitly implement {interfaceType}.{name}{{reason}}, but it does not.");
         }
 
         return new AndConstraint<TypeAssertions>(this);
@@ -1058,28 +1071,23 @@ public AndConstraint<TypeAssertions> NotHaveExplicitProperty(
         Guard.ThrowIfArgumentIsNull(interfaceType);
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected {{context:type}} to not explicitly implement {interfaceType}.{name}{{reason}}" +
                 ", but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded && AssertSubjectImplements(interfaceType, because, becauseArgs))
         {
-            success = AssertSubjectImplements(interfaceType, because, becauseArgs);
-
-            if (success)
-            {
-                var explicitlyImplementsProperty = Subject.HasExplicitlyImplementedProperty(interfaceType, name);
-
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .ForCondition(!explicitlyImplementsProperty)
-                    .FailWith(
-                        $"Expected {Subject} to not explicitly implement {interfaceType}.{name}{{reason}}" +
-                        ", but it does.");
-            }
+            var explicitlyImplementsProperty = Subject.HasExplicitlyImplementedProperty(interfaceType, name);
+
+            assertionChain
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(!explicitlyImplementsProperty)
+                .FailWith(
+                    $"Expected {Subject} to not explicitly implement {interfaceType}.{name}{{reason}}" +
+                    ", but it does.");
         }
 
         return new AndConstraint<TypeAssertions>(this);
@@ -1134,28 +1142,23 @@ public AndConstraint<TypeAssertions> HaveExplicitMethod(
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected {{context:type}} to explicitly implement {interfaceType}.{name}" +
                 $"({GetParameterString(parameterTypes)}){{reason}}, but {{context:type}} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded && AssertSubjectImplements(interfaceType, because, becauseArgs))
         {
-            success = AssertSubjectImplements(interfaceType, because, becauseArgs);
-
-            if (success)
-            {
-                var explicitlyImplementsMethod = Subject.HasMethod($"{interfaceType}.{name}", parameterTypes);
-
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .ForCondition(explicitlyImplementsMethod)
-                    .FailWith(
-                        $"Expected {Subject} to explicitly implement {interfaceType}.{name}" +
-                        $"({GetParameterString(parameterTypes)}){{reason}}, but it does not.");
-            }
+            var explicitlyImplementsMethod = Subject.HasMethod($"{interfaceType}.{name}", parameterTypes);
+
+            assertionChain
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(explicitlyImplementsMethod)
+                .FailWith(
+                    $"Expected {Subject} to explicitly implement {interfaceType}.{name}" +
+                    $"({GetParameterString(parameterTypes)}){{reason}}, but it does not.");
         }
 
         return new AndConstraint<TypeAssertions>(this);
@@ -1212,28 +1215,23 @@ public AndConstraint<TypeAssertions> NotHaveExplicitMethod(
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected {{context:type}} to not explicitly implement {interfaceType}.{name}" +
                 $"({GetParameterString(parameterTypes)}){{reason}}, but {{context:type}} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded && AssertSubjectImplements(interfaceType, because, becauseArgs))
         {
-            success = AssertSubjectImplements(interfaceType, because, becauseArgs);
-
-            if (success)
-            {
-                var explicitlyImplementsMethod = Subject.HasMethod($"{interfaceType}.{name}", parameterTypes);
-
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .ForCondition(!explicitlyImplementsMethod)
-                    .FailWith(
-                        $"Expected {Subject} to not explicitly implement {interfaceType}.{name}" +
-                        $"({GetParameterString(parameterTypes)}){{reason}}, but it does.");
-            }
+            var explicitlyImplementsMethod = Subject.HasMethod($"{interfaceType}.{name}", parameterTypes);
+
+            assertionChain
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(!explicitlyImplementsMethod)
+                .FailWith(
+                    $"Expected {Subject} to not explicitly implement {interfaceType}.{name}" +
+                    $"({GetParameterString(parameterTypes)}){{reason}}, but it does.");
         }
 
         return new AndConstraint<TypeAssertions>(this);
@@ -1286,32 +1284,34 @@ public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveIndexer(
         Guard.ThrowIfArgumentIsNull(indexerType);
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        string parameterString = GetParameterString(parameterTypes);
+
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
-                $"Expected {indexerType.Name} {{context:type}}[{GetParameterString(parameterTypes)}] to exist{{reason}}" +
+                $"Expected {indexerType.Name} {{context:type}}[{parameterString}] to exist{{reason}}" +
                 ", but {context:type} is <null>.");
 
         PropertyInfo propertyInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             propertyInfo = Subject.GetIndexerByParameterTypes(parameterTypes);
-            var propertyInfoDescription = PropertyInfoAssertions.GetDescriptionFor(propertyInfo);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(propertyInfo is not null)
                 .FailWith(
-                    $"Expected {indexerType.Name} {Subject}[{GetParameterString(parameterTypes)}] to exist{{reason}}" +
+                    $"Expected {indexerType.Name} {Subject}[{parameterString}] to exist{{reason}}" +
                     ", but it does not.")
                 .Then
                 .ForCondition(propertyInfo.PropertyType == indexerType)
-                .FailWith($"Expected {propertyInfoDescription} to be of type {indexerType}{{reason}}, but it is not.");
+                .FailWith("Expected {0} to be of type {1}{reason}, but it is not.", propertyInfo, indexerType);
         }
 
-        return new AndWhichConstraint<TypeAssertions, PropertyInfo>(this, propertyInfo);
+        return new AndWhichConstraint<TypeAssertions, PropertyInfo>(this, propertyInfo, assertionChain,
+            $"[{parameterString}]");
     }
 
     /// <summary>
@@ -1333,18 +1333,18 @@ public AndConstraint<TypeAssertions> NotHaveIndexer(
     {
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected indexer {{context:type}}[{GetParameterString(parameterTypes)}] to not exist{{reason}}" +
                 ", but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             PropertyInfo propertyInfo = Subject.GetIndexerByParameterTypes(parameterTypes);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(propertyInfo is null)
                 .FailWith(
@@ -1378,7 +1378,7 @@ public AndWhichConstraint<TypeAssertions, MethodInfo> HaveMethod(
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
@@ -1387,11 +1387,11 @@ public AndWhichConstraint<TypeAssertions, MethodInfo> HaveMethod(
 
         MethodInfo methodInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             methodInfo = Subject.GetMethod(name, parameterTypes);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(methodInfo is not null)
                 .FailWith(
@@ -1425,19 +1425,19 @@ public AndConstraint<TypeAssertions> NotHaveMethod(
         Guard.ThrowIfArgumentIsNullOrEmpty(name);
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 $"Expected method {{context:type}}.{name}({GetParameterString(parameterTypes)}) to not exist{{reason}}" +
                 ", but {context:type} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             MethodInfo methodInfo = Subject.GetMethod(name, parameterTypes);
             var methodInfoDescription = MethodInfoAssertions.GetDescriptionFor(methodInfo);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(methodInfo is null)
                 .FailWith(
@@ -1466,7 +1466,7 @@ public AndWhichConstraint<TypeAssertions, ConstructorInfo> HaveConstructor(
     {
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
@@ -1475,11 +1475,11 @@ public AndWhichConstraint<TypeAssertions, ConstructorInfo> HaveConstructor(
 
         ConstructorInfo constructorInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             constructorInfo = Subject.GetConstructor(parameterTypes);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(constructorInfo is not null)
                 .FailWith(
@@ -1524,7 +1524,7 @@ public AndWhichConstraint<TypeAssertions, ConstructorInfo> NotHaveConstructor(
     {
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
@@ -1533,11 +1533,11 @@ public AndWhichConstraint<TypeAssertions, ConstructorInfo> NotHaveConstructor(
 
         ConstructorInfo constructorInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             constructorInfo = Subject.GetConstructor(parameterTypes);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(constructorInfo is null)
                 .FailWith(
@@ -1588,16 +1588,16 @@ public AndConstraint<TypeAssertions> HaveAccessModifier(
     {
         Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith($"Expected {{context:type}} to be {accessModifier}{{reason}}, but {{context:type}} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
 
-            Execute.Assertion.ForCondition(accessModifier == subjectAccessModifier)
+            assertionChain.ForCondition(accessModifier == subjectAccessModifier)
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(accessModifier == subjectAccessModifier)
                 .FailWith(
@@ -1627,16 +1627,16 @@ public AndConstraint<TypeAssertions> NotHaveAccessModifier(
     {
         Guard.ThrowIfArgumentIsOutOfRange(accessModifier);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith($"Expected {{context:type}} not to be {accessModifier}{{reason}}, but {{context:type}} is <null>.");
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(accessModifier != subjectAccessModifier)
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(accessModifier != subjectAccessModifier)
@@ -1687,7 +1687,7 @@ public AndWhichConstraint<TypeAssertions, MethodInfo> HaveImplicitConversionOper
         Guard.ThrowIfArgumentIsNull(sourceType);
         Guard.ThrowIfArgumentIsNull(targetType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected public static implicit {0}({1}) to exist{reason}, but {context:type} is <null>.",
@@ -1695,18 +1695,18 @@ public AndWhichConstraint<TypeAssertions, MethodInfo> HaveImplicitConversionOper
 
         MethodInfo methodInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             methodInfo = Subject.GetImplicitConversionOperator(sourceType, targetType);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(methodInfo is not null)
                 .FailWith("Expected public static implicit {0}({1}) to exist{reason}, but it does not.",
                     targetType, sourceType);
         }
 
-        return new AndWhichConstraint<TypeAssertions, MethodInfo>(this, methodInfo);
+        return new AndWhichConstraint<TypeAssertions, MethodInfo>(this, methodInfo, assertionChain);
     }
 
     /// <summary>
@@ -1750,17 +1750,17 @@ public AndConstraint<TypeAssertions> NotHaveImplicitConversionOperator(
         Guard.ThrowIfArgumentIsNull(sourceType);
         Guard.ThrowIfArgumentIsNull(targetType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected public static implicit {0}({1}) to not exist{reason}, but {context:type} is <null>.",
                 targetType, sourceType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             MethodInfo methodInfo = Subject.GetImplicitConversionOperator(sourceType, targetType);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(methodInfo is null)
                 .FailWith("Expected public static implicit {0}({1}) to not exist{reason}, but it does.",
@@ -1811,7 +1811,7 @@ public AndWhichConstraint<TypeAssertions, MethodInfo> HaveExplicitConversionOper
         Guard.ThrowIfArgumentIsNull(sourceType);
         Guard.ThrowIfArgumentIsNull(targetType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected public static explicit {0}({1}) to exist{reason}, but {context:type} is <null>.",
@@ -1819,11 +1819,11 @@ public AndWhichConstraint<TypeAssertions, MethodInfo> HaveExplicitConversionOper
 
         MethodInfo methodInfo = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             methodInfo = Subject.GetExplicitConversionOperator(sourceType, targetType);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(methodInfo is not null)
                 .FailWith("Expected public static explicit {0}({1}) to exist{reason}, but it does not.",
@@ -1874,17 +1874,17 @@ public AndConstraint<TypeAssertions> NotHaveExplicitConversionOperator(
         Guard.ThrowIfArgumentIsNull(sourceType);
         Guard.ThrowIfArgumentIsNull(targetType);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected public static explicit {0}({1}) to not exist{reason}, but {context:type} is <null>.",
                 targetType, sourceType);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             MethodInfo methodInfo = Subject.GetExplicitConversionOperator(sourceType, targetType);
 
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(methodInfo is null)
                 .FailWith("Expected public static explicit {0}({1}) to not exist{reason}, but it does.",
diff --git a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs
index 1fa57f2532..41711ae15f 100644
--- a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs
+++ b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs
@@ -18,12 +18,15 @@ namespace FluentAssertions.Types;
 [DebuggerNonUserCode]
 public class TypeSelectorAssertions
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TypeSelectorAssertions"/> class.
     /// </summary>
     /// <exception cref="ArgumentNullException"><paramref name="types"/> is or contains <see langword="null"/>.</exception>
-    public TypeSelectorAssertions(params Type[] types)
+    public TypeSelectorAssertions(AssertionChain assertionChain, params Type[] types)
     {
+        this.assertionChain = assertionChain;
         Guard.ThrowIfArgumentIsNull(types);
         Guard.ThrowIfArgumentContainsNull(types);
 
@@ -52,7 +55,7 @@ public AndConstraint<TypeSelectorAssertions> BeDecoratedWith<TAttribute>([String
             .Where(type => !type.IsDecoratedWith<TAttribute>())
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithoutAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to be decorated with {0}{reason}," +
@@ -89,7 +92,7 @@ public AndConstraint<TypeSelectorAssertions> BeDecoratedWith<TAttribute>(
             .Where(type => !type.IsDecoratedWith(isMatchingAttributePredicate))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithoutMatchingAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to be decorated with {0} that matches {1}{reason}," +
@@ -119,7 +122,7 @@ public AndConstraint<TypeSelectorAssertions> BeDecoratedWithOrInherit<TAttribute
             .Where(type => !type.IsDecoratedWithOrInherit<TAttribute>())
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithoutAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to be decorated with or inherit {0}{reason}," +
@@ -156,7 +159,7 @@ public AndConstraint<TypeSelectorAssertions> BeDecoratedWithOrInherit<TAttribute
             .Where(type => !type.IsDecoratedWithOrInherit(isMatchingAttributePredicate))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithoutMatchingAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to be decorated with or inherit {0} that matches {1}{reason}," +
@@ -185,7 +188,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeDecoratedWith<TAttribute>([Str
             .Where(type => type.IsDecoratedWith<TAttribute>())
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to not be decorated with {0}{reason}," +
@@ -222,7 +225,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeDecoratedWith<TAttribute>(
             .Where(type => type.IsDecoratedWith(isMatchingAttributePredicate))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithMatchingAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to not be decorated with {0} that matches {1}{reason}," +
@@ -252,7 +255,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeDecoratedWithOrInherit<TAttrib
             .Where(type => type.IsDecoratedWithOrInherit<TAttribute>())
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to not be decorated with or inherit {0}{reason}," +
@@ -289,7 +292,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeDecoratedWithOrInherit<TAttrib
             .Where(type => type.IsDecoratedWithOrInherit(isMatchingAttributePredicate))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesWithMatchingAttribute.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to not be decorated with or inherit {0} that matches {1}{reason}," +
@@ -315,7 +318,7 @@ public AndConstraint<TypeSelectorAssertions> BeSealed([StringSyntax("CompositeFo
     {
         var notSealedTypes = Subject.Where(type => !type.IsCSharpSealed()).ToArray();
 
-        Execute.Assertion.ForCondition(notSealedTypes.Length == 0)
+        assertionChain.ForCondition(notSealedTypes.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to be sealed{reason}, but the following types are not:" + Environment.NewLine + "{0}.",
                 GetDescriptionsFor(notSealedTypes));
@@ -337,7 +340,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeSealed([StringSyntax("Composit
     {
         var sealedTypes = Subject.Where(type => type.IsCSharpSealed()).ToArray();
 
-        Execute.Assertion.ForCondition(sealedTypes.Length == 0)
+        assertionChain.ForCondition(sealedTypes.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types not to be sealed{reason}, but the following types are:" + Environment.NewLine + "{0}.",
                 GetDescriptionsFor(sealedTypes));
@@ -365,7 +368,7 @@ public AndConstraint<TypeSelectorAssertions> BeInNamespace(string @namespace,
             .Where(t => t.Namespace != @namespace)
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesNotInNamespace.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected all types to be in namespace {0}{reason}," +
@@ -396,7 +399,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeInNamespace(string @namespace,
             .Where(t => t.Namespace == @namespace)
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesInNamespace.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected no types to be in namespace {0}{reason}," +
@@ -427,7 +430,7 @@ public AndConstraint<TypeSelectorAssertions> BeUnderNamespace(string @namespace,
             .Where(t => !t.IsUnderNamespace(@namespace))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesNotUnderNamespace.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected the namespaces of all types to start with {0}{reason}," +
@@ -459,7 +462,7 @@ public AndConstraint<TypeSelectorAssertions> NotBeUnderNamespace(string @namespa
             .Where(t => t.IsUnderNamespace(@namespace))
             .ToArray();
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(typesUnderNamespace.Length == 0)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected the namespaces of all types to not start with {0}{reason}," +
diff --git a/Src/FluentAssertions/Xml/Equivalency/XmlReaderValidator.cs b/Src/FluentAssertions/Xml/Equivalency/XmlReaderValidator.cs
index 52a223417e..b82b4bba6f 100644
--- a/Src/FluentAssertions/Xml/Equivalency/XmlReaderValidator.cs
+++ b/Src/FluentAssertions/Xml/Equivalency/XmlReaderValidator.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Xml;
 using FluentAssertions.Execution;
@@ -9,16 +8,17 @@ namespace FluentAssertions.Xml.Equivalency;
 
 internal class XmlReaderValidator
 {
-    private readonly AssertionScope assertion;
+    private readonly AssertionChain assertionChain;
     private readonly XmlReader subjectReader;
     private readonly XmlReader expectationReader;
     private XmlIterator subjectIterator;
     private XmlIterator expectationIterator;
     private Node currentNode = Node.CreateRoot();
 
-    public XmlReaderValidator(XmlReader subjectReader, XmlReader expectationReader, [StringSyntax("CompositeFormat")] string because, object[] becauseArgs)
+    public XmlReaderValidator(AssertionChain assertionChain, XmlReader subjectReader, XmlReader expectationReader, string because, object[] becauseArgs)
     {
-        assertion = Execute.Assertion.BecauseOf(because, becauseArgs);
+        this.assertionChain = assertionChain;
+        assertionChain.BecauseOf(because, becauseArgs);
 
         this.subjectReader = subjectReader;
         this.expectationReader = expectationReader;
@@ -30,12 +30,12 @@ public void Validate(bool shouldBeEquivalent)
 
         if (shouldBeEquivalent && failure is not null)
         {
-            assertion.FailWith(failure.FormatString, failure.FormatParams);
+            assertionChain.FailWith(failure.FormatString, failure.FormatParams);
         }
 
         if (!shouldBeEquivalent && failure is null)
         {
-            assertion.FailWith("Did not expect {context:subject} to be equivalent{reason}, but it is.");
+            assertionChain.FailWith("Did not expect {context:subject} to be equivalent{reason}, but it is.");
         }
     }
 
diff --git a/Src/FluentAssertions/Xml/XAttributeAssertions.cs b/Src/FluentAssertions/Xml/XAttributeAssertions.cs
index 807ee8ee75..5c63862d5c 100644
--- a/Src/FluentAssertions/Xml/XAttributeAssertions.cs
+++ b/Src/FluentAssertions/Xml/XAttributeAssertions.cs
@@ -12,12 +12,15 @@ namespace FluentAssertions.Xml;
 [DebuggerNonUserCode]
 public class XAttributeAssertions : ReferenceTypeAssertions<XAttribute, XAttributeAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="XAttributeAssertions" /> class.
     /// </summary>
-    public XAttributeAssertions(XAttribute attribute)
-        : base(attribute)
+    public XAttributeAssertions(XAttribute attribute, AssertionChain assertionChain)
+        : base(attribute, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -34,7 +37,7 @@ public XAttributeAssertions(XAttribute attribute)
     public AndConstraint<XAttributeAssertions> Be(XAttribute expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject?.Name == expected?.Name && Subject?.Value == expected?.Value)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to be {0}{reason}, but found {1}.", expected, Subject);
@@ -57,7 +60,7 @@ public AndConstraint<XAttributeAssertions> Be(XAttribute expected,
     public AndConstraint<XAttributeAssertions> NotBe(XAttribute unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(!(Subject?.Name == unexpected?.Name && Subject?.Value == unexpected?.Value))
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context} to be {0}{reason}.", unexpected);
@@ -79,14 +82,14 @@ public AndConstraint<XAttributeAssertions> NotBe(XAttribute unexpected,
     public AndConstraint<XAttributeAssertions> HaveValue(string expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the attribute to have value {0}{reason}, but {context:member} is <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject!.Value == expected)
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context} \"{0}\" to have value {1}{reason}, but found {2}.",
diff --git a/Src/FluentAssertions/Xml/XDocumentAssertions.cs b/Src/FluentAssertions/Xml/XDocumentAssertions.cs
index 98b2662d7a..f4c39fb40d 100644
--- a/Src/FluentAssertions/Xml/XDocumentAssertions.cs
+++ b/Src/FluentAssertions/Xml/XDocumentAssertions.cs
@@ -18,12 +18,15 @@ namespace FluentAssertions.Xml;
 [DebuggerNonUserCode]
 public class XDocumentAssertions : ReferenceTypeAssertions<XDocument, XDocumentAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="XDocumentAssertions" /> class.
     /// </summary>
-    public XDocumentAssertions(XDocument document)
-        : base(document)
+    public XDocumentAssertions(XDocument document, AssertionChain assertionChain)
+        : base(document, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -41,7 +44,7 @@ public XDocumentAssertions(XDocument document)
     public AndConstraint<XDocumentAssertions> Be(XDocument expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Equals(Subject, expected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:subject} to be {0}{reason}, but found {1}.", expected, Subject);
@@ -64,7 +67,7 @@ public AndConstraint<XDocumentAssertions> Be(XDocument expected,
     public AndConstraint<XDocumentAssertions> NotBe(XDocument unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(!Equals(Subject, unexpected))
             .FailWith("Did not expect {context:subject} to be {0}{reason}.", unexpected);
@@ -90,7 +93,7 @@ public AndConstraint<XDocumentAssertions> BeEquivalentTo(XDocument expected,
         using (XmlReader subjectReader = Subject?.CreateReader())
         using (XmlReader otherReader = expected?.CreateReader())
         {
-            var xmlReaderValidator = new XmlReaderValidator(subjectReader, otherReader, because, becauseArgs);
+            var xmlReaderValidator = new XmlReaderValidator(assertionChain, subjectReader, otherReader, because, becauseArgs);
             xmlReaderValidator.Validate(shouldBeEquivalent: true);
         }
 
@@ -115,7 +118,7 @@ public AndConstraint<XDocumentAssertions> NotBeEquivalentTo(XDocument unexpected
         using (XmlReader subjectReader = Subject?.CreateReader())
         using (XmlReader otherReader = unexpected?.CreateReader())
         {
-            var xmlReaderValidator = new XmlReaderValidator(subjectReader, otherReader, because, becauseArgs);
+            var xmlReaderValidator = new XmlReaderValidator(assertionChain, subjectReader, otherReader, because, becauseArgs);
             xmlReaderValidator.Validate(shouldBeEquivalent: false);
         }
 
@@ -171,14 +174,14 @@ public AndWhichConstraint<XDocumentAssertions, XElement> HaveRoot(XName expected
 
         XElement root = Subject.Root;
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(root is not null && root.Name == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith(
                 "Expected {context:subject} to have root element {0}{reason}, but found {1}.",
                 expected.ToString(), Subject);
 
-        return new AndWhichConstraint<XDocumentAssertions, XElement>(this, root);
+        return new AndWhichConstraint<XDocumentAssertions, XElement>(this, root, assertionChain, $"/{expected}");
     }
 
     /// <summary>
@@ -259,7 +262,7 @@ public AndWhichConstraint<XDocumentAssertions, XElement> HaveElement(XName expec
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected),
             "Cannot assert the document has an element if the expected name is <null>.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject.Root is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -268,11 +271,11 @@ public AndWhichConstraint<XDocumentAssertions, XElement> HaveElement(XName expec
 
         XElement xElement = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             xElement = Subject.Root!.Element(expected);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(xElement is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -280,7 +283,7 @@ public AndWhichConstraint<XDocumentAssertions, XElement> HaveElement(XName expec
                     expected.ToString());
         }
 
-        return new AndWhichConstraint<XDocumentAssertions, XElement>(this, xElement);
+        return new AndWhichConstraint<XDocumentAssertions, XElement>(this, xElement, assertionChain, "/" + expected);
     }
 
     /// <summary>
@@ -308,30 +311,30 @@ public AndWhichConstraint<XDocumentAssertions, IEnumerable<XElement>> HaveElemen
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected),
             "Cannot assert the document has an element count if the element name is <null>.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Cannot assert the count if the document itself is <null>.");
 
         IEnumerable<XElement> xElements = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             var root = Subject!.Root;
 
-            success = Execute.Assertion
+            assertionChain
                 .ForCondition(root is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
                     "Expected {context:subject} to have root element containing a child {0}{reason}, but it has no root element.",
                     expected.ToString());
 
-            if (success)
+            if (assertionChain.Succeeded)
             {
                 xElements = root!.Elements(expected);
                 int actual = xElements.Count();
 
-                Execute.Assertion
+                assertionChain
                     .ForConstraint(occurrenceConstraint, actual)
                     .BecauseOf(because, becauseArgs)
                     .FailWith(
@@ -341,7 +344,7 @@ public AndWhichConstraint<XDocumentAssertions, IEnumerable<XElement>> HaveElemen
             }
         }
 
-        return new AndWhichConstraint<XDocumentAssertions, IEnumerable<XElement>>(this, xElements);
+        return new AndWhichConstraint<XDocumentAssertions, IEnumerable<XElement>>(this, xElements, assertionChain, "/" + expected);
     }
 
     /// <summary>
diff --git a/Src/FluentAssertions/Xml/XElementAssertions.cs b/Src/FluentAssertions/Xml/XElementAssertions.cs
index 3381c4703b..c01c43748d 100644
--- a/Src/FluentAssertions/Xml/XElementAssertions.cs
+++ b/Src/FluentAssertions/Xml/XElementAssertions.cs
@@ -18,12 +18,15 @@ namespace FluentAssertions.Xml;
 [DebuggerNonUserCode]
 public class XElementAssertions : ReferenceTypeAssertions<XElement, XElementAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="XElementAssertions" /> class.
     /// </summary>
-    public XElementAssertions(XElement xElement)
-        : base(xElement)
+    public XElementAssertions(XElement xElement, AssertionChain assertionChain)
+        : base(xElement, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -42,7 +45,7 @@ public XElementAssertions(XElement xElement)
     public AndConstraint<XElementAssertions> Be(XElement expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(XNode.DeepEquals(Subject, expected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:subject} to be {0}{reason}, but found {1}.", expected, Subject);
@@ -66,7 +69,7 @@ public AndConstraint<XElementAssertions> Be(XElement expected,
     public AndConstraint<XElementAssertions> NotBe(XElement unexpected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition((Subject is null && unexpected is not null) || !XNode.DeepEquals(Subject, unexpected))
             .BecauseOf(because, becauseArgs)
             .FailWith("Did not expect {context:subject} to be {0}{reason}.", unexpected);
@@ -93,7 +96,7 @@ public AndConstraint<XElementAssertions> BeEquivalentTo(XElement expected,
         using (XmlReader subjectReader = Subject?.CreateReader())
         using (XmlReader expectedReader = expected?.CreateReader())
         {
-            var xmlReaderValidator = new XmlReaderValidator(subjectReader, expectedReader, because, becauseArgs);
+            var xmlReaderValidator = new XmlReaderValidator(assertionChain, subjectReader, expectedReader, because, becauseArgs);
             xmlReaderValidator.Validate(shouldBeEquivalent: true);
         }
 
@@ -119,7 +122,7 @@ public AndConstraint<XElementAssertions> NotBeEquivalentTo(XElement unexpected,
         using (XmlReader subjectReader = Subject?.CreateReader())
         using (XmlReader otherReader = unexpected?.CreateReader())
         {
-            var xmlReaderValidator = new XmlReaderValidator(subjectReader, otherReader, because, becauseArgs);
+            var xmlReaderValidator = new XmlReaderValidator(assertionChain, subjectReader, otherReader, because, becauseArgs);
             xmlReaderValidator.Validate(shouldBeEquivalent: false);
         }
 
@@ -140,14 +143,14 @@ public AndConstraint<XElementAssertions> NotBeEquivalentTo(XElement unexpected,
     public AndConstraint<XElementAssertions> HaveValue(string expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith("Expected the element to have value {0}{reason}, but {context:member} is <null>.", expected);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(Subject!.Value == expected)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -202,18 +205,18 @@ public AndConstraint<XElementAssertions> HaveAttribute(XName expectedName, strin
 
         string expectedText = expectedName.ToString();
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
                 "Expected attribute {0} in element to have value {1}{reason}, but {context:member} is <null>.",
                 expectedText, expectedValue);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             XAttribute attribute = Subject!.Attribute(expectedName);
 
-            success = Execute.Assertion
+            assertionChain
                 .ForCondition(attribute is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -221,9 +224,9 @@ public AndConstraint<XElementAssertions> HaveAttribute(XName expectedName, strin
                     + " but found no such attribute in {2}",
                     expectedText, expectedValue, Subject);
 
-            if (success)
+            if (assertionChain.Succeeded)
             {
-                Execute.Assertion
+                assertionChain
                     .ForCondition(attribute!.Value == expectedValue)
                     .BecauseOf(because, becauseArgs)
                     .FailWith(
@@ -275,7 +278,7 @@ public AndWhichConstraint<XElementAssertions, XElement> HaveElement(XName expect
     {
         Guard.ThrowIfArgumentIsNull(expected);
 
-        bool success = Execute.Assertion
+        assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
             .FailWith(
@@ -284,11 +287,11 @@ public AndWhichConstraint<XElementAssertions, XElement> HaveElement(XName expect
 
         XElement xElement = null;
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             xElement = Subject!.Element(expected);
 
-            Execute.Assertion
+            assertionChain
                 .ForCondition(xElement is not null)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -296,7 +299,7 @@ public AndWhichConstraint<XElementAssertions, XElement> HaveElement(XName expect
                     expected.ToString().EscapePlaceholders());
         }
 
-        return new AndWhichConstraint<XElementAssertions, XElement>(this, xElement);
+        return new AndWhichConstraint<XElementAssertions, XElement>(this, xElement, assertionChain, "/" + expected);
     }
 
     /// <summary>
@@ -324,7 +327,7 @@ public AndWhichConstraint<XElementAssertions, IEnumerable<XElement>> HaveElement
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected),
             "Cannot assert the element has an element count if the element name is <null>.");
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -333,12 +336,12 @@ public AndWhichConstraint<XElementAssertions, IEnumerable<XElement>> HaveElement
 
         IEnumerable<XElement> xElements = [];
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
             xElements = Subject!.Elements(expected);
             int actual = xElements.Count();
 
-            Execute.Assertion
+            assertionChain
                 .ForConstraint(occurrenceConstraint, actual)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -347,7 +350,7 @@ public AndWhichConstraint<XElementAssertions, IEnumerable<XElement>> HaveElement
                     expected.ToString());
         }
 
-        return new AndWhichConstraint<XElementAssertions, IEnumerable<XElement>>(this, xElements);
+        return new AndWhichConstraint<XElementAssertions, IEnumerable<XElement>>(this, xElements, assertionChain, "/" + expected);
     }
 
     /// <summary>
diff --git a/Src/FluentAssertions/Xml/XmlElementAssertions.cs b/Src/FluentAssertions/Xml/XmlElementAssertions.cs
index 60bfd53dff..651eda0fd0 100644
--- a/Src/FluentAssertions/Xml/XmlElementAssertions.cs
+++ b/Src/FluentAssertions/Xml/XmlElementAssertions.cs
@@ -13,13 +13,16 @@ namespace FluentAssertions.Xml;
 [DebuggerNonUserCode]
 public class XmlElementAssertions : XmlNodeAssertions<XmlElement, XmlElementAssertions>
 {
+    private readonly AssertionChain assertionChain;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="XmlElementAssertions"/> class.
     /// </summary>
     /// <param name="xmlElement"></param>
-    public XmlElementAssertions(XmlElement xmlElement)
-        : base(xmlElement)
+    public XmlElementAssertions(XmlElement xmlElement, AssertionChain assertionChain)
+        : base(xmlElement, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -37,7 +40,7 @@ public XmlElementAssertions(XmlElement xmlElement)
     public AndConstraint<XmlElementAssertions> HaveInnerText(string expected,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        assertionChain
             .ForCondition(Subject.InnerText == expected)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -94,7 +97,7 @@ public AndConstraint<XmlElementAssertions> HaveAttributeWithNamespace(
             (string.IsNullOrEmpty(expectedNamespace) ? string.Empty : $"{{{expectedNamespace}}}")
             + expectedName;
 
-        bool success = Execute.Assertion
+        assertionChain
             .ForCondition(attribute is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith(
@@ -102,9 +105,9 @@ public AndConstraint<XmlElementAssertions> HaveAttributeWithNamespace(
                 + " with value {1}{reason}, but found no such attribute in {2}",
                 expectedFormattedName, expectedValue, Subject);
 
-        if (success)
+        if (assertionChain.Succeeded)
         {
-            Execute.Assertion
+            assertionChain
                 .ForCondition(attribute!.Value == expectedValue)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
@@ -158,14 +161,14 @@ public AndWhichConstraint<XmlElementAssertions, XmlElement> HaveElementWithNames
             (string.IsNullOrEmpty(expectedNamespace) ? string.Empty : $"{{{expectedNamespace}}}")
             + expectedName;
 
-        Execute.Assertion
+        assertionChain
             .ForCondition(element is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith(
                 "Expected {context:subject} to have child element {0}{reason}, but no such child element was found.",
                 expectedFormattedName.EscapePlaceholders());
 
-        return new AndWhichConstraint<XmlElementAssertions, XmlElement>(this, element);
+        return new AndWhichConstraint<XmlElementAssertions, XmlElement>(this, element, assertionChain, "/" + expectedName);
     }
 
     protected override string Identifier => "XML element";
diff --git a/Src/FluentAssertions/Xml/XmlNodeAssertions.cs b/Src/FluentAssertions/Xml/XmlNodeAssertions.cs
index 779317b295..1a3356ee65 100644
--- a/Src/FluentAssertions/Xml/XmlNodeAssertions.cs
+++ b/Src/FluentAssertions/Xml/XmlNodeAssertions.cs
@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Xml;
+using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 using FluentAssertions.Xml.Equivalency;
 
@@ -12,8 +13,8 @@ namespace FluentAssertions.Xml;
 [DebuggerNonUserCode]
 public class XmlNodeAssertions : XmlNodeAssertions<XmlNode, XmlNodeAssertions>
 {
-    public XmlNodeAssertions(XmlNode xmlNode)
-        : base(xmlNode)
+    public XmlNodeAssertions(XmlNode xmlNode, AssertionChain assertionChain)
+        : base(xmlNode, assertionChain)
     {
     }
 }
@@ -26,9 +27,12 @@ public class XmlNodeAssertions<TSubject, TAssertions> : ReferenceTypeAssertions<
     where TSubject : XmlNode
     where TAssertions : XmlNodeAssertions<TSubject, TAssertions>
 {
-    public XmlNodeAssertions(TSubject xmlNode)
-        : base(xmlNode)
+    private readonly AssertionChain assertionChain;
+
+    public XmlNodeAssertions(TSubject xmlNode, AssertionChain assertionChain)
+        : base(xmlNode, assertionChain)
     {
+        this.assertionChain = assertionChain;
     }
 
     /// <summary>
@@ -48,7 +52,7 @@ public AndConstraint<TAssertions> BeEquivalentTo(XmlNode expected,
         using (var subjectReader = new XmlNodeReader(Subject))
         using (var expectedReader = new XmlNodeReader(expected))
         {
-            var xmlReaderValidator = new XmlReaderValidator(subjectReader, expectedReader, because, becauseArgs);
+            var xmlReaderValidator = new XmlReaderValidator(assertionChain, subjectReader, expectedReader, because, becauseArgs);
             xmlReaderValidator.Validate(shouldBeEquivalent: true);
         }
 
@@ -73,7 +77,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo(XmlNode unexpected,
         using (var subjectReader = new XmlNodeReader(Subject))
         using (var unexpectedReader = new XmlNodeReader(unexpected))
         {
-            var xmlReaderValidator = new XmlReaderValidator(subjectReader, unexpectedReader, because, becauseArgs);
+            var xmlReaderValidator = new XmlReaderValidator(assertionChain, subjectReader, unexpectedReader, because, becauseArgs);
             xmlReaderValidator.Validate(shouldBeEquivalent: false);
         }
 
diff --git a/Src/FluentAssertions/XmlAssertionExtensions.cs b/Src/FluentAssertions/XmlAssertionExtensions.cs
index 2db9562915..79da764778 100644
--- a/Src/FluentAssertions/XmlAssertionExtensions.cs
+++ b/Src/FluentAssertions/XmlAssertionExtensions.cs
@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Xml;
+using FluentAssertions.Execution;
 using FluentAssertions.Xml;
 
 namespace FluentAssertions;
@@ -10,11 +11,11 @@ public static class XmlAssertionExtensions
 {
     public static XmlNodeAssertions Should([NotNull] this XmlNode actualValue)
     {
-        return new XmlNodeAssertions(actualValue);
+        return new XmlNodeAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 
     public static XmlElementAssertions Should([NotNull] this XmlElement actualValue)
     {
-        return new XmlElementAssertions(actualValue);
+        return new XmlElementAssertions(actualValue, AssertionChain.GetOrCreate());
     }
 }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
index ce88279d5e..d80352ffdd 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
@@ -15,12 +15,14 @@ namespace FluentAssertions
         public AndConstraint(TParent parent) { }
         public TParent And { get; }
     }
-    public class AndWhichConstraint<TParentConstraint, TMatchedElement> : FluentAssertions.AndConstraint<TParentConstraint>
+    public class AndWhichConstraint<TParent, TSubject> : FluentAssertions.AndConstraint<TParent>
     {
-        public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable<TMatchedElement> matchedConstraint) { }
-        public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { }
-        public TMatchedElement Subject { get; }
-        public TMatchedElement Which { get; }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects) { }
+        public AndWhichConstraint(TParent parent, TSubject subject) { }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix) { }
+        public AndWhichConstraint(TParent parent, TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix = "") { }
+        public TSubject Subject { get; }
+        public TSubject Which { get; }
     }
     public static class AssertionExtensions
     {
@@ -67,7 +69,6 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.Func<System.Threading.Tasks.Task> action) { }
         public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { }
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
-        public static FluentAssertions.Streams.BufferedStreamAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.IO.Stream actualValue) { }
         public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Types.AssemblyAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.Reflection.Assembly assembly) { }
@@ -376,18 +377,18 @@ namespace FluentAssertions.Collections
 {
     public class GenericCollectionAssertions<T> : FluentAssertions.Collections.GenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.GenericCollectionAssertions<T>>
     {
-        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue) { }
+        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TCollection, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TExpectation>> AllBeAssignableTo<TExpectation>(string because = "", params object[] becauseArgs) { }
@@ -461,7 +462,7 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> NotBeSubsetOf(System.Collections.Generic.IEnumerable<T> unexpectedSuperset, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Collections.Generic.IEnumerable<T> unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Linq.Expressions.Expression<System.Func<T, bool>> predicate, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndWhichConstraint<TAssertions, T> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainInConsecutiveOrder(params T[] unexpected) { }
@@ -492,13 +493,13 @@ namespace FluentAssertions.Collections
     public class GenericDictionaryAssertions<TCollection, TKey, TValue> : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue>>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, System.Collections.Generic.KeyValuePair<TKey, TValue>, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
         where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
@@ -510,8 +511,8 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(params TKey[] expected) { }
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(System.Collections.Generic.IEnumerable<TKey> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TValue> ContainValue(TValue expected, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(params TValue[] expected) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(params TValue[] expected) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Equal<T>(T expected, string because = "", params object[] becauseArgs)
             where T : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(params System.Collections.Generic.KeyValuePair<TKey, TValue>[] items) { }
@@ -529,18 +530,18 @@ namespace FluentAssertions.Collections
     }
     public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions<System.Collections.Generic.IEnumerable<string>>
     {
-        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue) { }
+        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection> : FluentAssertions.Collections.StringCollectionAssertions<TCollection, FluentAssertions.Collections.StringCollectionAssertions<TCollection>>
         where TCollection : System.Collections.Generic.IEnumerable<string>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, string, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<string>
         where TAssertions : FluentAssertions.Collections.StringCollectionAssertions<TCollection, TAssertions>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<string>, FluentAssertions.Equivalency.EquivalencyOptions<string>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(params string[] expectation) { }
@@ -553,18 +554,18 @@ namespace FluentAssertions.Collections
     }
     public class SubsequentOrderingAssertions<T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.SubsequentOrderingAssertions<T>>
     {
-        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, System.Collections.Generic.IComparer<TSelector> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInDescendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
@@ -705,7 +706,7 @@ namespace FluentAssertions.Equivalency
     {
         protected EquivalencyStep() { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
-        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested);
+        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator);
     }
     public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext
     {
@@ -797,7 +798,7 @@ namespace FluentAssertions.Equivalency
     }
     public interface IMemberMatchingRule
     {
-        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options);
+        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options, FluentAssertions.Execution.AssertionChain assertionChain);
     }
     public interface IMemberSelectionRule
     {
@@ -959,7 +960,7 @@ namespace FluentAssertions.Equivalency.Steps
 {
     public class AssertionRuleEquivalencyStep<TSubject> : FluentAssertions.Equivalency.IEquivalencyStep
     {
-        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertion) { }
+        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertionAction) { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
         public override string ToString() { }
     }
@@ -972,7 +973,7 @@ namespace FluentAssertions.Equivalency.Steps
     public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Collections.IDictionary>
     {
         public DictionaryEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep
     {
@@ -1033,17 +1034,17 @@ namespace FluentAssertions.Equivalency.Steps
     public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XAttribute>
     {
         public XAttributeEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XDocument>
     {
         public XDocumentEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XElement>
     {
         public XElementEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
 }
 namespace FluentAssertions.Equivalency.Tracing
@@ -1073,7 +1074,7 @@ namespace FluentAssertions.Events
 {
     public class EventAssertions<T> : FluentAssertions.Primitives.ReferenceTypeAssertions<T, FluentAssertions.Events.EventAssertions<T>>
     {
-        protected EventAssertions(FluentAssertions.Events.IMonitor<T> monitor) { }
+        protected EventAssertions(FluentAssertions.Events.IMonitor<T> monitor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.Events.IMonitor<T> Monitor { get; }
         public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { }
@@ -1119,76 +1120,65 @@ namespace FluentAssertions.Events
 }
 namespace FluentAssertions.Execution
 {
+    public sealed class AssertionChain
+    {
+        public string CallerIdentifier { get; }
+        public bool HasOverriddenCallerIdentifier { get; }
+        public bool PreviousAssertionSucceeded { get; }
+        public bool Succeeded { get; }
+        public FluentAssertions.Execution.AssertionChain UsingLineBreaks { get; }
+        public void AddPreFormattedFailure(string failure) { }
+        public void AddReportable(string key, System.Func<string> getValue) { }
+        public void AddReportable(string key, string value) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(FluentAssertions.Execution.Reason reason) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(string because, params object[] becauseArgs) { }
+        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> getFailureReason) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
+        public FluentAssertions.Execution.AssertionChain ForCondition(bool condition) { }
+        public FluentAssertions.Execution.AssertionChain ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
+        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
+        public void OverrideCallerIdentifier(System.Func<string> getCallerIdentifier) { }
+        public void ReuseOnce() { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPostfix(string postfix) { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPrefix(string prefix) { }
+        public FluentAssertions.Execution.AssertionChain WithDefaultIdentifier(string identifier) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, object arg2, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.AssertionChain WithReportable(string name, System.Func<string> content) { }
+        public static FluentAssertions.Execution.AssertionChain GetOrCreate() { }
+    }
     [System.Serializable]
     public class AssertionFailedException : System.Exception
     {
         public AssertionFailedException(string message) { }
         protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
     }
-    public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
+    public sealed class AssertionScope : System.IDisposable
     {
         public AssertionScope() { }
         public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { }
-        public AssertionScope(System.Lazy<string> context) { }
-        public AssertionScope(string context) { }
-        public string CallerIdentity { get; }
-        public System.Lazy<string> Context { get; set; }
+        public AssertionScope(System.Func<string> name) { }
+        public AssertionScope(string name) { }
         public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; }
-        public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; }
+        public System.Func<string> Name { get; }
         public static FluentAssertions.Execution.AssertionScope Current { get; }
-        public void AddNonReportable(string key, object value) { }
         public void AddPreFormattedFailure(string formattedFailureMessage) { }
-        public void AddReportable(string key, System.Func<string> valueFunc) { }
-        public void AddReportable(string key, string value) { }
         public void AppendTracing(string tracingBlock) { }
-        public void AssumeSingleCaller() { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
         public string[] Discard() { }
         public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public T Get<T>(string key) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
         public bool HasFailures() { }
-        public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { }
     }
     public class Continuation
     {
-        public FluentAssertions.Execution.IAssertionScope Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { }
+        public FluentAssertions.Execution.AssertionChain Then { get; }
     }
     public class ContinuationOfGiven<TSubject>
     {
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.GivenSelector<TSubject> Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven<TSubject> continuationOfGiven) { }
-    }
-    public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
-    {
-        public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
-        public string[] Discard() { }
-        public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
-        public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { }
-    }
-    public static class Execute
-    {
-        public static FluentAssertions.Execution.AssertionScope Assertion { get; }
     }
     public class FailReason
     {
@@ -1198,29 +1188,13 @@ namespace FluentAssertions.Execution
     }
     public class GivenSelector<T>
     {
-        public FluentAssertions.Execution.ContinuationOfGiven<T> ClearExpectation() { }
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params System.Func<T, object>[] args) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params object[] args) { }
         public FluentAssertions.Execution.GivenSelector<T> ForCondition(System.Func<T, bool> predicate) { }
         public FluentAssertions.Execution.GivenSelector<TOut> Given<TOut>(System.Func<T, TOut> selector) { }
     }
-    public interface IAssertionScope : System.IDisposable
-    {
-        FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs);
-        FluentAssertions.Execution.Continuation ClearExpectation();
-        string[] Discard();
-        FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc);
-        FluentAssertions.Execution.Continuation FailWith(string message);
-        FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders);
-        FluentAssertions.Execution.Continuation FailWith(string message, params object[] args);
-        FluentAssertions.Execution.IAssertionScope ForCondition(bool condition);
-        FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences);
-        FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector);
-        FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier);
-        FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args);
-    }
     public interface IAssertionStrategy
     {
         System.Collections.Generic.IEnumerable<string> FailureMessages { get; }
@@ -1463,6 +1437,12 @@ namespace FluentAssertions.Formatting
         public MaxLinesExceededException(string message) { }
         public MaxLinesExceededException(string message, System.Exception innerException) { }
     }
+    public class MethodInfoFormatter : FluentAssertions.Formatting.IValueFormatter
+    {
+        public MethodInfoFormatter() { }
+        public bool CanHandle(object value) { }
+        public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { }
+    }
     public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter
     {
         public MultidimensionalArrayFormatter() { }
@@ -1569,12 +1549,12 @@ namespace FluentAssertions.Numeric
 {
     public class ComparableTypeAssertions<T> : FluentAssertions.Numeric.ComparableTypeAssertions<T, FluentAssertions.Numeric.ComparableTypeAssertions<T>>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class ComparableTypeAssertions<T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.IComparable<T>, TAssertions>
         where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions<T, TAssertions>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
@@ -1594,13 +1574,13 @@ namespace FluentAssertions.Numeric
     public class NullableNumericAssertions<T> : FluentAssertions.Numeric.NullableNumericAssertions<T, FluentAssertions.Numeric.NullableNumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableNumericAssertions<T, TAssertions> : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions<T, TAssertions>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Match(System.Linq.Expressions.Expression<System.Func<T?, bool>> predicate, string because = "", params object[] becauseArgs) { }
@@ -1610,13 +1590,14 @@ namespace FluentAssertions.Numeric
     public class NumericAssertions<T> : FluentAssertions.Numeric.NumericAssertions<T, FluentAssertions.Numeric.NumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         public T? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(T? expected, string because = "", params object[] becauseArgs) { }
@@ -1642,12 +1623,12 @@ namespace FluentAssertions.Primitives
 {
     public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions<FluentAssertions.Primitives.BooleanAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public bool? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeFalse(string because = "", params object[] becauseArgs) { }
@@ -1658,12 +1639,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions<FluentAssertions.Primitives.DateTimeAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTime? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { }
@@ -1708,12 +1689,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<FluentAssertions.Primitives.DateTimeOffsetAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTimeOffset? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { }
@@ -1763,7 +1744,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeOffsetRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1771,7 +1752,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1779,13 +1760,13 @@ namespace FluentAssertions.Primitives
     public class EnumAssertions<TEnum> : FluentAssertions.Primitives.EnumAssertions<TEnum, FluentAssertions.Primitives.EnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TEnum? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum? expected, string because = "", params object[] becauseArgs) { }
@@ -1812,12 +1793,12 @@ namespace FluentAssertions.Primitives
     }
     public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions<FluentAssertions.Primitives.GuidAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.GuidAssertions<TAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.Guid? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
@@ -1829,12 +1810,12 @@ namespace FluentAssertions.Primitives
     }
     public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
     {
-        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
         where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
     {
-        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
@@ -1846,12 +1827,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableBooleanAssertions<TAssertions> : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<TAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1863,12 +1844,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<FluentAssertions.Primitives.NullableDateTimeAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<TAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1876,12 +1857,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<FluentAssertions.Primitives.NullableDateTimeOffsetAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeOffsetAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<TAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1890,13 +1871,13 @@ namespace FluentAssertions.Primitives
     public class NullableEnumAssertions<TEnum> : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, FluentAssertions.Primitives.NullableEnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableEnumAssertions<TEnum, TAssertions> : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, TAssertions>
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1904,12 +1885,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions<FluentAssertions.Primitives.NullableGuidAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableGuidAssertions<TAssertions> : FluentAssertions.Primitives.GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions<TAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1918,12 +1899,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableSimpleTimeSpanAssertions<TAssertions> : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<TAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1932,7 +1913,7 @@ namespace FluentAssertions.Primitives
     }
     public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions<object, FluentAssertions.Primitives.ObjectAssertions>
     {
-        public ObjectAssertions(object value) { }
+        public ObjectAssertions(object value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> Be<TExpectation>(TExpectation expected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeOneOf<TExpectation>(System.Collections.Generic.IEnumerable<TExpectation> validValues, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> NotBe<TExpectation>(TExpectation unexpected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
@@ -1940,7 +1921,7 @@ namespace FluentAssertions.Primitives
     public class ObjectAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ObjectAssertions<TSubject, TAssertions>
     {
-        public ObjectAssertions(TSubject value) { }
+        public ObjectAssertions(TSubject value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, System.Collections.Generic.IEqualityComparer<TSubject> comparer, string because = "", params object[] becauseArgs) { }
@@ -1958,7 +1939,8 @@ namespace FluentAssertions.Primitives
     public abstract class ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
     {
-        protected ReferenceTypeAssertions(TSubject subject) { }
+        protected ReferenceTypeAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         protected abstract string Identifier { get; }
         public TSubject Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { }
@@ -1982,12 +1964,12 @@ namespace FluentAssertions.Primitives
     }
     public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<FluentAssertions.Primitives.SimpleTimeSpanAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.TimeSpan? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
@@ -2003,12 +1985,12 @@ namespace FluentAssertions.Primitives
     }
     public class StringAssertions : FluentAssertions.Primitives.StringAssertions<FluentAssertions.Primitives.StringAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringAssertions<TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<string, TAssertions>
         where TAssertions : FluentAssertions.Primitives.StringAssertions<TAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEmpty(string because = "", params object[] becauseArgs) { }
@@ -2084,8 +2066,8 @@ namespace FluentAssertions.Specialized
 {
     public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions<System.Action, FluentAssertions.Specialized.ActionAssertions>
     {
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2095,7 +2077,7 @@ namespace FluentAssertions.Specialized
         where TTask : System.Threading.Tasks.Task
         where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<TTask, TAssertions>
     {
-        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotThrowAsync<TException>(string because = "", params object[] becauseArgs)
@@ -2121,7 +2103,7 @@ namespace FluentAssertions.Specialized
         where TDelegate : System.Delegate
         where TAssertions : FluentAssertions.Specialized.DelegateAssertions<TDelegate, TAssertions>
     {
-        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
+        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected abstract void InvokeSubject();
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
@@ -2133,7 +2115,7 @@ namespace FluentAssertions.Specialized
     public class ExceptionAssertions<TException> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Collections.Generic.IEnumerable<TException>, FluentAssertions.Specialized.ExceptionAssertions<TException>>
         where TException : System.Exception
     {
-        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions) { }
+        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TException And { get; }
         protected override string Identifier { get; }
         public TException Which { get; }
@@ -2155,7 +2137,7 @@ namespace FluentAssertions.Specialized
     }
     public class ExecutionTimeAssertions
     {
-        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { }
+        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
@@ -2165,8 +2147,8 @@ namespace FluentAssertions.Specialized
     }
     public class FunctionAssertions<T> : FluentAssertions.Specialized.DelegateAssertions<System.Func<T>, FluentAssertions.Specialized.FunctionAssertions<T>>
     {
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2174,8 +2156,8 @@ namespace FluentAssertions.Specialized
     }
     public class GenericAsyncFunctionAssertions<TResult> : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task<TResult>, FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>>
     {
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2191,8 +2173,8 @@ namespace FluentAssertions.Specialized
     }
     public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task, FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>
     {
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2204,33 +2186,23 @@ namespace FluentAssertions.Specialized
     }
     public class TaskCompletionSourceAssertions<T> : FluentAssertions.Specialized.TaskCompletionSourceAssertionsBase
     {
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs) { }
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Common.IClock clock) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
     }
 }
 namespace FluentAssertions.Streams
 {
-    public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions<FluentAssertions.Streams.BufferedStreamAssertions>
-    {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
-    }
-    public class BufferedStreamAssertions<TAssertions> : FluentAssertions.Streams.StreamAssertions<System.IO.BufferedStream, TAssertions>
-        where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
-    {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
-        protected override string Identifier { get; }
-    }
     public class StreamAssertions : FluentAssertions.Streams.StreamAssertions<System.IO.Stream, FluentAssertions.Streams.StreamAssertions>
     {
-        public StreamAssertions(System.IO.Stream stream) { }
+        public StreamAssertions(System.IO.Stream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StreamAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.IO.Stream
         where TAssertions : FluentAssertions.Streams.StreamAssertions<TSubject, TAssertions>
     {
-        public StreamAssertions(TSubject stream) { }
+        public StreamAssertions(TSubject stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeReadOnly(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
@@ -2256,7 +2228,7 @@ namespace FluentAssertions.Types
     }
     public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Reflection.Assembly, FluentAssertions.Types.AssemblyAssertions>
     {
-        public AssemblyAssertions(System.Reflection.Assembly assembly) { }
+        public AssemblyAssertions(System.Reflection.Assembly assembly, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeSignedWithPublicKey(string publicKey, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeUnsigned(string because = "", params object[] becauseArgs) { }
@@ -2266,15 +2238,17 @@ namespace FluentAssertions.Types
     }
     public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.ConstructorInfo, FluentAssertions.Types.ConstructorInfoAssertions>
     {
-        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { }
+        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
     }
     public abstract class MemberInfoAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Reflection.MemberInfo
         where TAssertions : FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>
     {
-        protected MemberInfoAssertions(TSubject subject) { }
+        protected MemberInfoAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected virtual string SubjectDescription { get; }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(System.Linq.Expressions.Expression<System.Func<TAttribute, bool>> isMatchingAttributePredicate, string because = "", params object[] becauseArgs)
@@ -2288,14 +2262,15 @@ namespace FluentAssertions.Types
         where TSubject : System.Reflection.MethodBase
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
-        protected MethodBaseAssertions(TSubject subject) { }
+        protected MethodBaseAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
     public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.MethodInfo, FluentAssertions.Types.MethodInfoAssertions>
     {
-        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { }
+        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeAsync(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> NotBeAsync(string because = "", params object[] becauseArgs) { }
@@ -2338,7 +2313,7 @@ namespace FluentAssertions.Types
     }
     public class MethodInfoSelectorAssertions
     {
-        public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { }
+        public MethodInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.MethodInfo[] methods) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> SubjectMethods { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoSelectorAssertions> Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
@@ -2359,8 +2334,9 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions<System.Reflection.PropertyInfo, FluentAssertions.Types.PropertyInfoAssertions>
     {
-        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { }
+        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
@@ -2401,7 +2377,7 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoSelectorAssertions
     {
-        public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { }
+        public PropertyInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.PropertyInfo[] properties) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.PropertyInfo> SubjectProperties { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
@@ -2416,7 +2392,7 @@ namespace FluentAssertions.Types
     }
     public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Type, FluentAssertions.Types.TypeAssertions>
     {
-        public TypeAssertions(System.Type type) { }
+        public TypeAssertions(System.Type type, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be(System.Type expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be<TExpected>(string because = "", params object[] becauseArgs) { }
@@ -2534,7 +2510,7 @@ namespace FluentAssertions.Types
     }
     public class TypeSelectorAssertions
     {
-        public TypeSelectorAssertions(params System.Type[] types) { }
+        public TypeSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Type[] types) { }
         public System.Collections.Generic.IEnumerable<System.Type> Subject { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
@@ -2565,7 +2541,7 @@ namespace FluentAssertions.Xml
 {
     public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XAttribute, FluentAssertions.Xml.XAttributeAssertions>
     {
-        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { }
+        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> HaveValue(string expected, string because = "", params object[] becauseArgs) { }
@@ -2573,7 +2549,7 @@ namespace FluentAssertions.Xml
     }
     public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XDocument, FluentAssertions.Xml.XDocumentAssertions>
     {
-        public XDocumentAssertions(System.Xml.Linq.XDocument document) { }
+        public XDocumentAssertions(System.Xml.Linq.XDocument document, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
@@ -2588,7 +2564,7 @@ namespace FluentAssertions.Xml
     }
     public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XElement, FluentAssertions.Xml.XElementAssertions>
     {
-        public XElementAssertions(System.Xml.Linq.XElement xElement) { }
+        public XElementAssertions(System.Xml.Linq.XElement xElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
@@ -2604,7 +2580,7 @@ namespace FluentAssertions.Xml
     }
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
-        public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        public XmlElementAssertions(System.Xml.XmlElement xmlElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
@@ -2614,13 +2590,13 @@ namespace FluentAssertions.Xml
     }
     public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlNode, FluentAssertions.Xml.XmlNodeAssertions>
     {
-        public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { }
+        public XmlNodeAssertions(System.Xml.XmlNode xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class XmlNodeAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Xml.XmlNode
         where TAssertions : FluentAssertions.Xml.XmlNodeAssertions<TSubject, TAssertions>
     {
-        public XmlNodeAssertions(TSubject xmlNode) { }
+        public XmlNodeAssertions(TSubject xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt
index c9ad572ad9..156569c2ba 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt
@@ -15,12 +15,14 @@ namespace FluentAssertions
         public AndConstraint(TParent parent) { }
         public TParent And { get; }
     }
-    public class AndWhichConstraint<TParentConstraint, TMatchedElement> : FluentAssertions.AndConstraint<TParentConstraint>
+    public class AndWhichConstraint<TParent, TSubject> : FluentAssertions.AndConstraint<TParent>
     {
-        public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable<TMatchedElement> matchedConstraint) { }
-        public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { }
-        public TMatchedElement Subject { get; }
-        public TMatchedElement Which { get; }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects) { }
+        public AndWhichConstraint(TParent parent, TSubject subject) { }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix) { }
+        public AndWhichConstraint(TParent parent, TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix = "") { }
+        public TSubject Subject { get; }
+        public TSubject Which { get; }
     }
     public static class AssertionExtensions
     {
@@ -389,18 +391,18 @@ namespace FluentAssertions.Collections
 {
     public class GenericCollectionAssertions<T> : FluentAssertions.Collections.GenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.GenericCollectionAssertions<T>>
     {
-        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue) { }
+        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TCollection, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TExpectation>> AllBeAssignableTo<TExpectation>(string because = "", params object[] becauseArgs) { }
@@ -474,7 +476,7 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> NotBeSubsetOf(System.Collections.Generic.IEnumerable<T> unexpectedSuperset, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Collections.Generic.IEnumerable<T> unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Linq.Expressions.Expression<System.Func<T, bool>> predicate, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndWhichConstraint<TAssertions, T> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainInConsecutiveOrder(params T[] unexpected) { }
@@ -505,13 +507,13 @@ namespace FluentAssertions.Collections
     public class GenericDictionaryAssertions<TCollection, TKey, TValue> : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue>>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, System.Collections.Generic.KeyValuePair<TKey, TValue>, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
         where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
@@ -523,8 +525,8 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(params TKey[] expected) { }
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(System.Collections.Generic.IEnumerable<TKey> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TValue> ContainValue(TValue expected, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(params TValue[] expected) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(params TValue[] expected) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Equal<T>(T expected, string because = "", params object[] becauseArgs)
             where T : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(params System.Collections.Generic.KeyValuePair<TKey, TValue>[] items) { }
@@ -542,18 +544,18 @@ namespace FluentAssertions.Collections
     }
     public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions<System.Collections.Generic.IEnumerable<string>>
     {
-        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue) { }
+        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection> : FluentAssertions.Collections.StringCollectionAssertions<TCollection, FluentAssertions.Collections.StringCollectionAssertions<TCollection>>
         where TCollection : System.Collections.Generic.IEnumerable<string>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, string, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<string>
         where TAssertions : FluentAssertions.Collections.StringCollectionAssertions<TCollection, TAssertions>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<string>, FluentAssertions.Equivalency.EquivalencyOptions<string>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(params string[] expectation) { }
@@ -566,18 +568,18 @@ namespace FluentAssertions.Collections
     }
     public class SubsequentOrderingAssertions<T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.SubsequentOrderingAssertions<T>>
     {
-        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, System.Collections.Generic.IComparer<TSelector> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInDescendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
@@ -718,7 +720,7 @@ namespace FluentAssertions.Equivalency
     {
         protected EquivalencyStep() { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
-        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested);
+        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator);
     }
     public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext
     {
@@ -810,7 +812,7 @@ namespace FluentAssertions.Equivalency
     }
     public interface IMemberMatchingRule
     {
-        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options);
+        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options, FluentAssertions.Execution.AssertionChain assertionChain);
     }
     public interface IMemberSelectionRule
     {
@@ -972,7 +974,7 @@ namespace FluentAssertions.Equivalency.Steps
 {
     public class AssertionRuleEquivalencyStep<TSubject> : FluentAssertions.Equivalency.IEquivalencyStep
     {
-        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertion) { }
+        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertionAction) { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
         public override string ToString() { }
     }
@@ -985,7 +987,7 @@ namespace FluentAssertions.Equivalency.Steps
     public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Collections.IDictionary>
     {
         public DictionaryEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep
     {
@@ -1046,17 +1048,17 @@ namespace FluentAssertions.Equivalency.Steps
     public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XAttribute>
     {
         public XAttributeEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XDocument>
     {
         public XDocumentEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XElement>
     {
         public XElementEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
 }
 namespace FluentAssertions.Equivalency.Tracing
@@ -1086,7 +1088,7 @@ namespace FluentAssertions.Events
 {
     public class EventAssertions<T> : FluentAssertions.Primitives.ReferenceTypeAssertions<T, FluentAssertions.Events.EventAssertions<T>>
     {
-        protected EventAssertions(FluentAssertions.Events.IMonitor<T> monitor) { }
+        protected EventAssertions(FluentAssertions.Events.IMonitor<T> monitor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.Events.IMonitor<T> Monitor { get; }
         public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { }
@@ -1132,76 +1134,65 @@ namespace FluentAssertions.Events
 }
 namespace FluentAssertions.Execution
 {
+    public sealed class AssertionChain
+    {
+        public string CallerIdentifier { get; }
+        public bool HasOverriddenCallerIdentifier { get; }
+        public bool PreviousAssertionSucceeded { get; }
+        public bool Succeeded { get; }
+        public FluentAssertions.Execution.AssertionChain UsingLineBreaks { get; }
+        public void AddPreFormattedFailure(string failure) { }
+        public void AddReportable(string key, System.Func<string> getValue) { }
+        public void AddReportable(string key, string value) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(FluentAssertions.Execution.Reason reason) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(string because, params object[] becauseArgs) { }
+        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> getFailureReason) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
+        public FluentAssertions.Execution.AssertionChain ForCondition(bool condition) { }
+        public FluentAssertions.Execution.AssertionChain ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
+        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
+        public void OverrideCallerIdentifier(System.Func<string> getCallerIdentifier) { }
+        public void ReuseOnce() { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPostfix(string postfix) { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPrefix(string prefix) { }
+        public FluentAssertions.Execution.AssertionChain WithDefaultIdentifier(string identifier) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, object arg2, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.AssertionChain WithReportable(string name, System.Func<string> content) { }
+        public static FluentAssertions.Execution.AssertionChain GetOrCreate() { }
+    }
     [System.Serializable]
     public class AssertionFailedException : System.Exception
     {
         public AssertionFailedException(string message) { }
         protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
     }
-    public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
+    public sealed class AssertionScope : System.IDisposable
     {
         public AssertionScope() { }
         public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { }
-        public AssertionScope(System.Lazy<string> context) { }
-        public AssertionScope(string context) { }
-        public string CallerIdentity { get; }
-        public System.Lazy<string> Context { get; set; }
+        public AssertionScope(System.Func<string> name) { }
+        public AssertionScope(string name) { }
         public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; }
-        public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; }
+        public System.Func<string> Name { get; }
         public static FluentAssertions.Execution.AssertionScope Current { get; }
-        public void AddNonReportable(string key, object value) { }
         public void AddPreFormattedFailure(string formattedFailureMessage) { }
-        public void AddReportable(string key, System.Func<string> valueFunc) { }
-        public void AddReportable(string key, string value) { }
         public void AppendTracing(string tracingBlock) { }
-        public void AssumeSingleCaller() { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
         public string[] Discard() { }
         public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public T Get<T>(string key) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
         public bool HasFailures() { }
-        public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { }
     }
     public class Continuation
     {
-        public FluentAssertions.Execution.IAssertionScope Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { }
+        public FluentAssertions.Execution.AssertionChain Then { get; }
     }
     public class ContinuationOfGiven<TSubject>
     {
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.GivenSelector<TSubject> Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven<TSubject> continuationOfGiven) { }
-    }
-    public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
-    {
-        public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
-        public string[] Discard() { }
-        public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
-        public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { }
-    }
-    public static class Execute
-    {
-        public static FluentAssertions.Execution.AssertionScope Assertion { get; }
     }
     public class FailReason
     {
@@ -1211,29 +1202,13 @@ namespace FluentAssertions.Execution
     }
     public class GivenSelector<T>
     {
-        public FluentAssertions.Execution.ContinuationOfGiven<T> ClearExpectation() { }
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params System.Func<T, object>[] args) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params object[] args) { }
         public FluentAssertions.Execution.GivenSelector<T> ForCondition(System.Func<T, bool> predicate) { }
         public FluentAssertions.Execution.GivenSelector<TOut> Given<TOut>(System.Func<T, TOut> selector) { }
     }
-    public interface IAssertionScope : System.IDisposable
-    {
-        FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs);
-        FluentAssertions.Execution.Continuation ClearExpectation();
-        string[] Discard();
-        FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc);
-        FluentAssertions.Execution.Continuation FailWith(string message);
-        FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders);
-        FluentAssertions.Execution.Continuation FailWith(string message, params object[] args);
-        FluentAssertions.Execution.IAssertionScope ForCondition(bool condition);
-        FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences);
-        FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector);
-        FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier);
-        FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args);
-    }
     public interface IAssertionStrategy
     {
         System.Collections.Generic.IEnumerable<string> FailureMessages { get; }
@@ -1482,6 +1457,12 @@ namespace FluentAssertions.Formatting
         public MaxLinesExceededException(string message) { }
         public MaxLinesExceededException(string message, System.Exception innerException) { }
     }
+    public class MethodInfoFormatter : FluentAssertions.Formatting.IValueFormatter
+    {
+        public MethodInfoFormatter() { }
+        public bool CanHandle(object value) { }
+        public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { }
+    }
     public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter
     {
         public MultidimensionalArrayFormatter() { }
@@ -1594,12 +1575,12 @@ namespace FluentAssertions.Numeric
 {
     public class ComparableTypeAssertions<T> : FluentAssertions.Numeric.ComparableTypeAssertions<T, FluentAssertions.Numeric.ComparableTypeAssertions<T>>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class ComparableTypeAssertions<T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.IComparable<T>, TAssertions>
         where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions<T, TAssertions>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
@@ -1619,13 +1600,13 @@ namespace FluentAssertions.Numeric
     public class NullableNumericAssertions<T> : FluentAssertions.Numeric.NullableNumericAssertions<T, FluentAssertions.Numeric.NullableNumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableNumericAssertions<T, TAssertions> : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions<T, TAssertions>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Match(System.Linq.Expressions.Expression<System.Func<T?, bool>> predicate, string because = "", params object[] becauseArgs) { }
@@ -1635,13 +1616,14 @@ namespace FluentAssertions.Numeric
     public class NumericAssertions<T> : FluentAssertions.Numeric.NumericAssertions<T, FluentAssertions.Numeric.NumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         public T? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(T? expected, string because = "", params object[] becauseArgs) { }
@@ -1667,12 +1649,12 @@ namespace FluentAssertions.Primitives
 {
     public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions<FluentAssertions.Primitives.BooleanAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public bool? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeFalse(string because = "", params object[] becauseArgs) { }
@@ -1683,12 +1665,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateOnlyAssertions : FluentAssertions.Primitives.DateOnlyAssertions<FluentAssertions.Primitives.DateOnlyAssertions>
     {
-        public DateOnlyAssertions(System.DateOnly? value) { }
+        public DateOnlyAssertions(System.DateOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateOnlyAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateOnlyAssertions<TAssertions>
     {
-        public DateOnlyAssertions(System.DateOnly? value) { }
+        public DateOnlyAssertions(System.DateOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateOnly? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateOnly expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateOnly? expected, string because = "", params object[] becauseArgs) { }
@@ -1716,12 +1698,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions<FluentAssertions.Primitives.DateTimeAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTime? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { }
@@ -1766,12 +1748,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<FluentAssertions.Primitives.DateTimeOffsetAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTimeOffset? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { }
@@ -1821,7 +1803,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeOffsetRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1829,7 +1811,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1837,13 +1819,13 @@ namespace FluentAssertions.Primitives
     public class EnumAssertions<TEnum> : FluentAssertions.Primitives.EnumAssertions<TEnum, FluentAssertions.Primitives.EnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TEnum? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum? expected, string because = "", params object[] becauseArgs) { }
@@ -1870,12 +1852,12 @@ namespace FluentAssertions.Primitives
     }
     public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions<FluentAssertions.Primitives.GuidAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.GuidAssertions<TAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.Guid? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
@@ -1887,12 +1869,12 @@ namespace FluentAssertions.Primitives
     }
     public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
     {
-        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
         where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
     {
-        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
@@ -1904,12 +1886,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableBooleanAssertions<TAssertions> : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<TAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1921,12 +1903,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateOnlyAssertions : FluentAssertions.Primitives.NullableDateOnlyAssertions<FluentAssertions.Primitives.NullableDateOnlyAssertions>
     {
-        public NullableDateOnlyAssertions(System.DateOnly? value) { }
+        public NullableDateOnlyAssertions(System.DateOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateOnlyAssertions<TAssertions> : FluentAssertions.Primitives.DateOnlyAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateOnlyAssertions<TAssertions>
     {
-        public NullableDateOnlyAssertions(System.DateOnly? value) { }
+        public NullableDateOnlyAssertions(System.DateOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1934,12 +1916,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<FluentAssertions.Primitives.NullableDateTimeAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<TAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1947,12 +1929,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<FluentAssertions.Primitives.NullableDateTimeOffsetAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeOffsetAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<TAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1961,13 +1943,13 @@ namespace FluentAssertions.Primitives
     public class NullableEnumAssertions<TEnum> : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, FluentAssertions.Primitives.NullableEnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableEnumAssertions<TEnum, TAssertions> : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, TAssertions>
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1975,12 +1957,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions<FluentAssertions.Primitives.NullableGuidAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableGuidAssertions<TAssertions> : FluentAssertions.Primitives.GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions<TAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1989,12 +1971,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableSimpleTimeSpanAssertions<TAssertions> : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<TAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -2003,12 +1985,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableTimeOnlyAssertions : FluentAssertions.Primitives.NullableTimeOnlyAssertions<FluentAssertions.Primitives.NullableTimeOnlyAssertions>
     {
-        public NullableTimeOnlyAssertions(System.TimeOnly? value) { }
+        public NullableTimeOnlyAssertions(System.TimeOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableTimeOnlyAssertions<TAssertions> : FluentAssertions.Primitives.TimeOnlyAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableTimeOnlyAssertions<TAssertions>
     {
-        public NullableTimeOnlyAssertions(System.TimeOnly? value) { }
+        public NullableTimeOnlyAssertions(System.TimeOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -2016,7 +1998,7 @@ namespace FluentAssertions.Primitives
     }
     public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions<object, FluentAssertions.Primitives.ObjectAssertions>
     {
-        public ObjectAssertions(object value) { }
+        public ObjectAssertions(object value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> Be<TExpectation>(TExpectation expected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeOneOf<TExpectation>(System.Collections.Generic.IEnumerable<TExpectation> validValues, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> NotBe<TExpectation>(TExpectation unexpected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
@@ -2024,7 +2006,7 @@ namespace FluentAssertions.Primitives
     public class ObjectAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ObjectAssertions<TSubject, TAssertions>
     {
-        public ObjectAssertions(TSubject value) { }
+        public ObjectAssertions(TSubject value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, System.Collections.Generic.IEqualityComparer<TSubject> comparer, string because = "", params object[] becauseArgs) { }
@@ -2042,7 +2024,8 @@ namespace FluentAssertions.Primitives
     public abstract class ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
     {
-        protected ReferenceTypeAssertions(TSubject subject) { }
+        protected ReferenceTypeAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         protected abstract string Identifier { get; }
         public TSubject Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { }
@@ -2066,12 +2049,12 @@ namespace FluentAssertions.Primitives
     }
     public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<FluentAssertions.Primitives.SimpleTimeSpanAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.TimeSpan? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
@@ -2087,12 +2070,12 @@ namespace FluentAssertions.Primitives
     }
     public class StringAssertions : FluentAssertions.Primitives.StringAssertions<FluentAssertions.Primitives.StringAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringAssertions<TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<string, TAssertions>
         where TAssertions : FluentAssertions.Primitives.StringAssertions<TAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEmpty(string because = "", params object[] becauseArgs) { }
@@ -2157,12 +2140,12 @@ namespace FluentAssertions.Primitives
     }
     public class TimeOnlyAssertions : FluentAssertions.Primitives.TimeOnlyAssertions<FluentAssertions.Primitives.TimeOnlyAssertions>
     {
-        public TimeOnlyAssertions(System.TimeOnly? value) { }
+        public TimeOnlyAssertions(System.TimeOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class TimeOnlyAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.TimeOnlyAssertions<TAssertions>
     {
-        public TimeOnlyAssertions(System.TimeOnly? value) { }
+        public TimeOnlyAssertions(System.TimeOnly? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.TimeOnly? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeOnly expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeOnly? expected, string because = "", params object[] becauseArgs) { }
@@ -2205,8 +2188,8 @@ namespace FluentAssertions.Specialized
 {
     public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions<System.Action, FluentAssertions.Specialized.ActionAssertions>
     {
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2216,7 +2199,7 @@ namespace FluentAssertions.Specialized
         where TTask : System.Threading.Tasks.Task
         where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<TTask, TAssertions>
     {
-        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotThrowAsync<TException>(string because = "", params object[] becauseArgs)
@@ -2242,7 +2225,7 @@ namespace FluentAssertions.Specialized
         where TDelegate : System.Delegate
         where TAssertions : FluentAssertions.Specialized.DelegateAssertions<TDelegate, TAssertions>
     {
-        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
+        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected abstract void InvokeSubject();
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
@@ -2254,7 +2237,7 @@ namespace FluentAssertions.Specialized
     public class ExceptionAssertions<TException> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Collections.Generic.IEnumerable<TException>, FluentAssertions.Specialized.ExceptionAssertions<TException>>
         where TException : System.Exception
     {
-        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions) { }
+        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TException And { get; }
         protected override string Identifier { get; }
         public TException Which { get; }
@@ -2276,7 +2259,7 @@ namespace FluentAssertions.Specialized
     }
     public class ExecutionTimeAssertions
     {
-        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { }
+        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
@@ -2286,8 +2269,8 @@ namespace FluentAssertions.Specialized
     }
     public class FunctionAssertions<T> : FluentAssertions.Specialized.DelegateAssertions<System.Func<T>, FluentAssertions.Specialized.FunctionAssertions<T>>
     {
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2295,8 +2278,8 @@ namespace FluentAssertions.Specialized
     }
     public class GenericAsyncFunctionAssertions<TResult> : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task<TResult>, FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>>
     {
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2312,16 +2295,16 @@ namespace FluentAssertions.Specialized
     }
     public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task, FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>
     {
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
     }
     public class TaskCompletionSourceAssertions : FluentAssertions.Specialized.TaskCompletionSourceAssertionsBase
     {
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { }
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
     }
@@ -2332,8 +2315,8 @@ namespace FluentAssertions.Specialized
     }
     public class TaskCompletionSourceAssertions<T> : FluentAssertions.Specialized.TaskCompletionSourceAssertionsBase
     {
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs) { }
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Common.IClock clock) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
     }
@@ -2342,25 +2325,25 @@ namespace FluentAssertions.Streams
 {
     public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions<FluentAssertions.Streams.BufferedStreamAssertions>
     {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        public BufferedStreamAssertions(System.IO.BufferedStream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class BufferedStreamAssertions<TAssertions> : FluentAssertions.Streams.StreamAssertions<System.IO.BufferedStream, TAssertions>
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        public BufferedStreamAssertions(System.IO.BufferedStream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { }
     }
     public class StreamAssertions : FluentAssertions.Streams.StreamAssertions<System.IO.Stream, FluentAssertions.Streams.StreamAssertions>
     {
-        public StreamAssertions(System.IO.Stream stream) { }
+        public StreamAssertions(System.IO.Stream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StreamAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.IO.Stream
         where TAssertions : FluentAssertions.Streams.StreamAssertions<TSubject, TAssertions>
     {
-        public StreamAssertions(TSubject stream) { }
+        public StreamAssertions(TSubject stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeReadOnly(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
@@ -2386,7 +2369,7 @@ namespace FluentAssertions.Types
     }
     public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Reflection.Assembly, FluentAssertions.Types.AssemblyAssertions>
     {
-        public AssemblyAssertions(System.Reflection.Assembly assembly) { }
+        public AssemblyAssertions(System.Reflection.Assembly assembly, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeSignedWithPublicKey(string publicKey, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeUnsigned(string because = "", params object[] becauseArgs) { }
@@ -2396,15 +2379,17 @@ namespace FluentAssertions.Types
     }
     public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.ConstructorInfo, FluentAssertions.Types.ConstructorInfoAssertions>
     {
-        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { }
+        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
     }
     public abstract class MemberInfoAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Reflection.MemberInfo
         where TAssertions : FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>
     {
-        protected MemberInfoAssertions(TSubject subject) { }
+        protected MemberInfoAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected virtual string SubjectDescription { get; }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(System.Linq.Expressions.Expression<System.Func<TAttribute, bool>> isMatchingAttributePredicate, string because = "", params object[] becauseArgs)
@@ -2418,14 +2403,15 @@ namespace FluentAssertions.Types
         where TSubject : System.Reflection.MethodBase
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
-        protected MethodBaseAssertions(TSubject subject) { }
+        protected MethodBaseAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
     public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.MethodInfo, FluentAssertions.Types.MethodInfoAssertions>
     {
-        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { }
+        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeAsync(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> NotBeAsync(string because = "", params object[] becauseArgs) { }
@@ -2468,7 +2454,7 @@ namespace FluentAssertions.Types
     }
     public class MethodInfoSelectorAssertions
     {
-        public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { }
+        public MethodInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.MethodInfo[] methods) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> SubjectMethods { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoSelectorAssertions> Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
@@ -2489,8 +2475,9 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions<System.Reflection.PropertyInfo, FluentAssertions.Types.PropertyInfoAssertions>
     {
-        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { }
+        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
@@ -2531,7 +2518,7 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoSelectorAssertions
     {
-        public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { }
+        public PropertyInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.PropertyInfo[] properties) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.PropertyInfo> SubjectProperties { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
@@ -2546,7 +2533,7 @@ namespace FluentAssertions.Types
     }
     public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Type, FluentAssertions.Types.TypeAssertions>
     {
-        public TypeAssertions(System.Type type) { }
+        public TypeAssertions(System.Type type, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be(System.Type expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be<TExpected>(string because = "", params object[] becauseArgs) { }
@@ -2664,7 +2651,7 @@ namespace FluentAssertions.Types
     }
     public class TypeSelectorAssertions
     {
-        public TypeSelectorAssertions(params System.Type[] types) { }
+        public TypeSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Type[] types) { }
         public System.Collections.Generic.IEnumerable<System.Type> Subject { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
@@ -2695,7 +2682,7 @@ namespace FluentAssertions.Xml
 {
     public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XAttribute, FluentAssertions.Xml.XAttributeAssertions>
     {
-        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { }
+        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> HaveValue(string expected, string because = "", params object[] becauseArgs) { }
@@ -2703,7 +2690,7 @@ namespace FluentAssertions.Xml
     }
     public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XDocument, FluentAssertions.Xml.XDocumentAssertions>
     {
-        public XDocumentAssertions(System.Xml.Linq.XDocument document) { }
+        public XDocumentAssertions(System.Xml.Linq.XDocument document, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
@@ -2718,7 +2705,7 @@ namespace FluentAssertions.Xml
     }
     public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XElement, FluentAssertions.Xml.XElementAssertions>
     {
-        public XElementAssertions(System.Xml.Linq.XElement xElement) { }
+        public XElementAssertions(System.Xml.Linq.XElement xElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
@@ -2734,7 +2721,7 @@ namespace FluentAssertions.Xml
     }
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
-        public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        public XmlElementAssertions(System.Xml.XmlElement xmlElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
@@ -2744,13 +2731,13 @@ namespace FluentAssertions.Xml
     }
     public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlNode, FluentAssertions.Xml.XmlNodeAssertions>
     {
-        public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { }
+        public XmlNodeAssertions(System.Xml.XmlNode xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class XmlNodeAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Xml.XmlNode
         where TAssertions : FluentAssertions.Xml.XmlNodeAssertions<TSubject, TAssertions>
     {
-        public XmlNodeAssertions(TSubject xmlNode) { }
+        public XmlNodeAssertions(TSubject xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
index 1de3630d79..644f35ca50 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
@@ -15,12 +15,14 @@ namespace FluentAssertions
         public AndConstraint(TParent parent) { }
         public TParent And { get; }
     }
-    public class AndWhichConstraint<TParentConstraint, TMatchedElement> : FluentAssertions.AndConstraint<TParentConstraint>
+    public class AndWhichConstraint<TParent, TSubject> : FluentAssertions.AndConstraint<TParent>
     {
-        public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable<TMatchedElement> matchedConstraint) { }
-        public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { }
-        public TMatchedElement Subject { get; }
-        public TMatchedElement Which { get; }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects) { }
+        public AndWhichConstraint(TParent parent, TSubject subject) { }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix) { }
+        public AndWhichConstraint(TParent parent, TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix = "") { }
+        public TSubject Subject { get; }
+        public TSubject Which { get; }
     }
     public static class AssertionExtensions
     {
@@ -65,7 +67,6 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.Func<System.Threading.Tasks.Task> action) { }
         public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { }
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
-        public static FluentAssertions.Streams.BufferedStreamAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.IO.Stream actualValue) { }
         public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Types.AssemblyAssertions Should([System.Diagnostics.CodeAnalysis.NotNull] this System.Reflection.Assembly assembly) { }
@@ -368,18 +369,18 @@ namespace FluentAssertions.Collections
 {
     public class GenericCollectionAssertions<T> : FluentAssertions.Collections.GenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.GenericCollectionAssertions<T>>
     {
-        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue) { }
+        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TCollection, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TExpectation>> AllBeAssignableTo<TExpectation>(string because = "", params object[] becauseArgs) { }
@@ -453,7 +454,7 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> NotBeSubsetOf(System.Collections.Generic.IEnumerable<T> unexpectedSuperset, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Collections.Generic.IEnumerable<T> unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Linq.Expressions.Expression<System.Func<T, bool>> predicate, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndWhichConstraint<TAssertions, T> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainInConsecutiveOrder(params T[] unexpected) { }
@@ -484,13 +485,13 @@ namespace FluentAssertions.Collections
     public class GenericDictionaryAssertions<TCollection, TKey, TValue> : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue>>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, System.Collections.Generic.KeyValuePair<TKey, TValue>, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
         where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
@@ -502,8 +503,8 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(params TKey[] expected) { }
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(System.Collections.Generic.IEnumerable<TKey> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TValue> ContainValue(TValue expected, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(params TValue[] expected) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(params TValue[] expected) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Equal<T>(T expected, string because = "", params object[] becauseArgs)
             where T : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(params System.Collections.Generic.KeyValuePair<TKey, TValue>[] items) { }
@@ -521,18 +522,18 @@ namespace FluentAssertions.Collections
     }
     public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions<System.Collections.Generic.IEnumerable<string>>
     {
-        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue) { }
+        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection> : FluentAssertions.Collections.StringCollectionAssertions<TCollection, FluentAssertions.Collections.StringCollectionAssertions<TCollection>>
         where TCollection : System.Collections.Generic.IEnumerable<string>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, string, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<string>
         where TAssertions : FluentAssertions.Collections.StringCollectionAssertions<TCollection, TAssertions>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<string>, FluentAssertions.Equivalency.EquivalencyOptions<string>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(params string[] expectation) { }
@@ -545,18 +546,18 @@ namespace FluentAssertions.Collections
     }
     public class SubsequentOrderingAssertions<T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.SubsequentOrderingAssertions<T>>
     {
-        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, System.Collections.Generic.IComparer<TSelector> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInDescendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
@@ -697,7 +698,7 @@ namespace FluentAssertions.Equivalency
     {
         protected EquivalencyStep() { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
-        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested);
+        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator);
     }
     public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext
     {
@@ -789,7 +790,7 @@ namespace FluentAssertions.Equivalency
     }
     public interface IMemberMatchingRule
     {
-        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options);
+        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options, FluentAssertions.Execution.AssertionChain assertionChain);
     }
     public interface IMemberSelectionRule
     {
@@ -951,7 +952,7 @@ namespace FluentAssertions.Equivalency.Steps
 {
     public class AssertionRuleEquivalencyStep<TSubject> : FluentAssertions.Equivalency.IEquivalencyStep
     {
-        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertion) { }
+        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertionAction) { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
         public override string ToString() { }
     }
@@ -964,7 +965,7 @@ namespace FluentAssertions.Equivalency.Steps
     public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Collections.IDictionary>
     {
         public DictionaryEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep
     {
@@ -1025,17 +1026,17 @@ namespace FluentAssertions.Equivalency.Steps
     public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XAttribute>
     {
         public XAttributeEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XDocument>
     {
         public XDocumentEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XElement>
     {
         public XElementEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
 }
 namespace FluentAssertions.Equivalency.Tracing
@@ -1063,76 +1064,65 @@ namespace FluentAssertions.Equivalency.Tracing
 }
 namespace FluentAssertions.Execution
 {
+    public sealed class AssertionChain
+    {
+        public string CallerIdentifier { get; }
+        public bool HasOverriddenCallerIdentifier { get; }
+        public bool PreviousAssertionSucceeded { get; }
+        public bool Succeeded { get; }
+        public FluentAssertions.Execution.AssertionChain UsingLineBreaks { get; }
+        public void AddPreFormattedFailure(string failure) { }
+        public void AddReportable(string key, System.Func<string> getValue) { }
+        public void AddReportable(string key, string value) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(FluentAssertions.Execution.Reason reason) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(string because, params object[] becauseArgs) { }
+        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> getFailureReason) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
+        public FluentAssertions.Execution.AssertionChain ForCondition(bool condition) { }
+        public FluentAssertions.Execution.AssertionChain ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
+        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
+        public void OverrideCallerIdentifier(System.Func<string> getCallerIdentifier) { }
+        public void ReuseOnce() { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPostfix(string postfix) { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPrefix(string prefix) { }
+        public FluentAssertions.Execution.AssertionChain WithDefaultIdentifier(string identifier) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, object arg2, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.AssertionChain WithReportable(string name, System.Func<string> content) { }
+        public static FluentAssertions.Execution.AssertionChain GetOrCreate() { }
+    }
     [System.Serializable]
     public class AssertionFailedException : System.Exception
     {
         public AssertionFailedException(string message) { }
         protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
     }
-    public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
+    public sealed class AssertionScope : System.IDisposable
     {
         public AssertionScope() { }
         public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { }
-        public AssertionScope(System.Lazy<string> context) { }
-        public AssertionScope(string context) { }
-        public string CallerIdentity { get; }
-        public System.Lazy<string> Context { get; set; }
+        public AssertionScope(System.Func<string> name) { }
+        public AssertionScope(string name) { }
         public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; }
-        public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; }
+        public System.Func<string> Name { get; }
         public static FluentAssertions.Execution.AssertionScope Current { get; }
-        public void AddNonReportable(string key, object value) { }
         public void AddPreFormattedFailure(string formattedFailureMessage) { }
-        public void AddReportable(string key, System.Func<string> valueFunc) { }
-        public void AddReportable(string key, string value) { }
         public void AppendTracing(string tracingBlock) { }
-        public void AssumeSingleCaller() { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
         public string[] Discard() { }
         public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public T Get<T>(string key) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
         public bool HasFailures() { }
-        public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { }
     }
     public class Continuation
     {
-        public FluentAssertions.Execution.IAssertionScope Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { }
+        public FluentAssertions.Execution.AssertionChain Then { get; }
     }
     public class ContinuationOfGiven<TSubject>
     {
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.GivenSelector<TSubject> Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven<TSubject> continuationOfGiven) { }
-    }
-    public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
-    {
-        public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
-        public string[] Discard() { }
-        public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
-        public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { }
-    }
-    public static class Execute
-    {
-        public static FluentAssertions.Execution.AssertionScope Assertion { get; }
     }
     public class FailReason
     {
@@ -1142,29 +1132,13 @@ namespace FluentAssertions.Execution
     }
     public class GivenSelector<T>
     {
-        public FluentAssertions.Execution.ContinuationOfGiven<T> ClearExpectation() { }
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params System.Func<T, object>[] args) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params object[] args) { }
         public FluentAssertions.Execution.GivenSelector<T> ForCondition(System.Func<T, bool> predicate) { }
         public FluentAssertions.Execution.GivenSelector<TOut> Given<TOut>(System.Func<T, TOut> selector) { }
     }
-    public interface IAssertionScope : System.IDisposable
-    {
-        FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs);
-        FluentAssertions.Execution.Continuation ClearExpectation();
-        string[] Discard();
-        FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc);
-        FluentAssertions.Execution.Continuation FailWith(string message);
-        FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders);
-        FluentAssertions.Execution.Continuation FailWith(string message, params object[] args);
-        FluentAssertions.Execution.IAssertionScope ForCondition(bool condition);
-        FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences);
-        FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector);
-        FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier);
-        FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args);
-    }
     public interface IAssertionStrategy
     {
         System.Collections.Generic.IEnumerable<string> FailureMessages { get; }
@@ -1407,6 +1381,12 @@ namespace FluentAssertions.Formatting
         public MaxLinesExceededException(string message) { }
         public MaxLinesExceededException(string message, System.Exception innerException) { }
     }
+    public class MethodInfoFormatter : FluentAssertions.Formatting.IValueFormatter
+    {
+        public MethodInfoFormatter() { }
+        public bool CanHandle(object value) { }
+        public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { }
+    }
     public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter
     {
         public MultidimensionalArrayFormatter() { }
@@ -1513,12 +1493,12 @@ namespace FluentAssertions.Numeric
 {
     public class ComparableTypeAssertions<T> : FluentAssertions.Numeric.ComparableTypeAssertions<T, FluentAssertions.Numeric.ComparableTypeAssertions<T>>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class ComparableTypeAssertions<T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.IComparable<T>, TAssertions>
         where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions<T, TAssertions>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
@@ -1538,13 +1518,13 @@ namespace FluentAssertions.Numeric
     public class NullableNumericAssertions<T> : FluentAssertions.Numeric.NullableNumericAssertions<T, FluentAssertions.Numeric.NullableNumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableNumericAssertions<T, TAssertions> : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions<T, TAssertions>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Match(System.Linq.Expressions.Expression<System.Func<T?, bool>> predicate, string because = "", params object[] becauseArgs) { }
@@ -1554,13 +1534,14 @@ namespace FluentAssertions.Numeric
     public class NumericAssertions<T> : FluentAssertions.Numeric.NumericAssertions<T, FluentAssertions.Numeric.NumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         public T? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(T? expected, string because = "", params object[] becauseArgs) { }
@@ -1586,12 +1567,12 @@ namespace FluentAssertions.Primitives
 {
     public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions<FluentAssertions.Primitives.BooleanAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public bool? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeFalse(string because = "", params object[] becauseArgs) { }
@@ -1602,12 +1583,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions<FluentAssertions.Primitives.DateTimeAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTime? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { }
@@ -1652,12 +1633,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<FluentAssertions.Primitives.DateTimeOffsetAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTimeOffset? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { }
@@ -1707,7 +1688,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeOffsetRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1715,7 +1696,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1723,13 +1704,13 @@ namespace FluentAssertions.Primitives
     public class EnumAssertions<TEnum> : FluentAssertions.Primitives.EnumAssertions<TEnum, FluentAssertions.Primitives.EnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TEnum? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum? expected, string because = "", params object[] becauseArgs) { }
@@ -1756,12 +1737,12 @@ namespace FluentAssertions.Primitives
     }
     public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions<FluentAssertions.Primitives.GuidAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.GuidAssertions<TAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.Guid? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
@@ -1773,12 +1754,12 @@ namespace FluentAssertions.Primitives
     }
     public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
     {
-        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
         where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
     {
-        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
@@ -1790,12 +1771,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableBooleanAssertions<TAssertions> : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<TAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1807,12 +1788,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<FluentAssertions.Primitives.NullableDateTimeAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<TAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1820,12 +1801,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<FluentAssertions.Primitives.NullableDateTimeOffsetAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeOffsetAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<TAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1834,13 +1815,13 @@ namespace FluentAssertions.Primitives
     public class NullableEnumAssertions<TEnum> : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, FluentAssertions.Primitives.NullableEnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableEnumAssertions<TEnum, TAssertions> : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, TAssertions>
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1848,12 +1829,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions<FluentAssertions.Primitives.NullableGuidAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableGuidAssertions<TAssertions> : FluentAssertions.Primitives.GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions<TAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1862,12 +1843,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableSimpleTimeSpanAssertions<TAssertions> : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<TAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1876,7 +1857,7 @@ namespace FluentAssertions.Primitives
     }
     public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions<object, FluentAssertions.Primitives.ObjectAssertions>
     {
-        public ObjectAssertions(object value) { }
+        public ObjectAssertions(object value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> Be<TExpectation>(TExpectation expected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeOneOf<TExpectation>(System.Collections.Generic.IEnumerable<TExpectation> validValues, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> NotBe<TExpectation>(TExpectation unexpected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
@@ -1884,7 +1865,7 @@ namespace FluentAssertions.Primitives
     public class ObjectAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ObjectAssertions<TSubject, TAssertions>
     {
-        public ObjectAssertions(TSubject value) { }
+        public ObjectAssertions(TSubject value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, System.Collections.Generic.IEqualityComparer<TSubject> comparer, string because = "", params object[] becauseArgs) { }
@@ -1902,7 +1883,8 @@ namespace FluentAssertions.Primitives
     public abstract class ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
     {
-        protected ReferenceTypeAssertions(TSubject subject) { }
+        protected ReferenceTypeAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         protected abstract string Identifier { get; }
         public TSubject Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { }
@@ -1926,12 +1908,12 @@ namespace FluentAssertions.Primitives
     }
     public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<FluentAssertions.Primitives.SimpleTimeSpanAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.TimeSpan? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
@@ -1947,12 +1929,12 @@ namespace FluentAssertions.Primitives
     }
     public class StringAssertions : FluentAssertions.Primitives.StringAssertions<FluentAssertions.Primitives.StringAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringAssertions<TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<string, TAssertions>
         where TAssertions : FluentAssertions.Primitives.StringAssertions<TAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEmpty(string because = "", params object[] becauseArgs) { }
@@ -2028,8 +2010,8 @@ namespace FluentAssertions.Specialized
 {
     public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions<System.Action, FluentAssertions.Specialized.ActionAssertions>
     {
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2039,7 +2021,7 @@ namespace FluentAssertions.Specialized
         where TTask : System.Threading.Tasks.Task
         where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<TTask, TAssertions>
     {
-        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotThrowAsync<TException>(string because = "", params object[] becauseArgs)
@@ -2065,7 +2047,7 @@ namespace FluentAssertions.Specialized
         where TDelegate : System.Delegate
         where TAssertions : FluentAssertions.Specialized.DelegateAssertions<TDelegate, TAssertions>
     {
-        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
+        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected abstract void InvokeSubject();
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
@@ -2077,7 +2059,7 @@ namespace FluentAssertions.Specialized
     public class ExceptionAssertions<TException> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Collections.Generic.IEnumerable<TException>, FluentAssertions.Specialized.ExceptionAssertions<TException>>
         where TException : System.Exception
     {
-        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions) { }
+        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TException And { get; }
         protected override string Identifier { get; }
         public TException Which { get; }
@@ -2099,7 +2081,7 @@ namespace FluentAssertions.Specialized
     }
     public class ExecutionTimeAssertions
     {
-        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { }
+        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
@@ -2109,8 +2091,8 @@ namespace FluentAssertions.Specialized
     }
     public class FunctionAssertions<T> : FluentAssertions.Specialized.DelegateAssertions<System.Func<T>, FluentAssertions.Specialized.FunctionAssertions<T>>
     {
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2118,8 +2100,8 @@ namespace FluentAssertions.Specialized
     }
     public class GenericAsyncFunctionAssertions<TResult> : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task<TResult>, FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>>
     {
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2135,8 +2117,8 @@ namespace FluentAssertions.Specialized
     }
     public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task, FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>
     {
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2148,33 +2130,23 @@ namespace FluentAssertions.Specialized
     }
     public class TaskCompletionSourceAssertions<T> : FluentAssertions.Specialized.TaskCompletionSourceAssertionsBase
     {
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs) { }
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Common.IClock clock) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
     }
 }
 namespace FluentAssertions.Streams
 {
-    public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions<FluentAssertions.Streams.BufferedStreamAssertions>
-    {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
-    }
-    public class BufferedStreamAssertions<TAssertions> : FluentAssertions.Streams.StreamAssertions<System.IO.BufferedStream, TAssertions>
-        where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
-    {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
-        protected override string Identifier { get; }
-    }
     public class StreamAssertions : FluentAssertions.Streams.StreamAssertions<System.IO.Stream, FluentAssertions.Streams.StreamAssertions>
     {
-        public StreamAssertions(System.IO.Stream stream) { }
+        public StreamAssertions(System.IO.Stream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StreamAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.IO.Stream
         where TAssertions : FluentAssertions.Streams.StreamAssertions<TSubject, TAssertions>
     {
-        public StreamAssertions(TSubject stream) { }
+        public StreamAssertions(TSubject stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeReadOnly(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
@@ -2200,7 +2172,7 @@ namespace FluentAssertions.Types
     }
     public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Reflection.Assembly, FluentAssertions.Types.AssemblyAssertions>
     {
-        public AssemblyAssertions(System.Reflection.Assembly assembly) { }
+        public AssemblyAssertions(System.Reflection.Assembly assembly, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeSignedWithPublicKey(string publicKey, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeUnsigned(string because = "", params object[] becauseArgs) { }
@@ -2210,15 +2182,17 @@ namespace FluentAssertions.Types
     }
     public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.ConstructorInfo, FluentAssertions.Types.ConstructorInfoAssertions>
     {
-        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { }
+        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
     }
     public abstract class MemberInfoAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Reflection.MemberInfo
         where TAssertions : FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>
     {
-        protected MemberInfoAssertions(TSubject subject) { }
+        protected MemberInfoAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected virtual string SubjectDescription { get; }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(System.Linq.Expressions.Expression<System.Func<TAttribute, bool>> isMatchingAttributePredicate, string because = "", params object[] becauseArgs)
@@ -2232,14 +2206,15 @@ namespace FluentAssertions.Types
         where TSubject : System.Reflection.MethodBase
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
-        protected MethodBaseAssertions(TSubject subject) { }
+        protected MethodBaseAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
     public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.MethodInfo, FluentAssertions.Types.MethodInfoAssertions>
     {
-        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { }
+        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeAsync(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> NotBeAsync(string because = "", params object[] becauseArgs) { }
@@ -2282,7 +2257,7 @@ namespace FluentAssertions.Types
     }
     public class MethodInfoSelectorAssertions
     {
-        public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { }
+        public MethodInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.MethodInfo[] methods) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> SubjectMethods { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoSelectorAssertions> Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
@@ -2303,8 +2278,9 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions<System.Reflection.PropertyInfo, FluentAssertions.Types.PropertyInfoAssertions>
     {
-        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { }
+        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
@@ -2345,7 +2321,7 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoSelectorAssertions
     {
-        public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { }
+        public PropertyInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.PropertyInfo[] properties) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.PropertyInfo> SubjectProperties { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
@@ -2360,7 +2336,7 @@ namespace FluentAssertions.Types
     }
     public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Type, FluentAssertions.Types.TypeAssertions>
     {
-        public TypeAssertions(System.Type type) { }
+        public TypeAssertions(System.Type type, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be(System.Type expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be<TExpected>(string because = "", params object[] becauseArgs) { }
@@ -2478,7 +2454,7 @@ namespace FluentAssertions.Types
     }
     public class TypeSelectorAssertions
     {
-        public TypeSelectorAssertions(params System.Type[] types) { }
+        public TypeSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Type[] types) { }
         public System.Collections.Generic.IEnumerable<System.Type> Subject { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
@@ -2509,7 +2485,7 @@ namespace FluentAssertions.Xml
 {
     public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XAttribute, FluentAssertions.Xml.XAttributeAssertions>
     {
-        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { }
+        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> HaveValue(string expected, string because = "", params object[] becauseArgs) { }
@@ -2517,7 +2493,7 @@ namespace FluentAssertions.Xml
     }
     public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XDocument, FluentAssertions.Xml.XDocumentAssertions>
     {
-        public XDocumentAssertions(System.Xml.Linq.XDocument document) { }
+        public XDocumentAssertions(System.Xml.Linq.XDocument document, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
@@ -2532,7 +2508,7 @@ namespace FluentAssertions.Xml
     }
     public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XElement, FluentAssertions.Xml.XElementAssertions>
     {
-        public XElementAssertions(System.Xml.Linq.XElement xElement) { }
+        public XElementAssertions(System.Xml.Linq.XElement xElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
@@ -2548,7 +2524,7 @@ namespace FluentAssertions.Xml
     }
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
-        public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        public XmlElementAssertions(System.Xml.XmlElement xmlElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
@@ -2558,13 +2534,13 @@ namespace FluentAssertions.Xml
     }
     public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlNode, FluentAssertions.Xml.XmlNodeAssertions>
     {
-        public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { }
+        public XmlNodeAssertions(System.Xml.XmlNode xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class XmlNodeAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Xml.XmlNode
         where TAssertions : FluentAssertions.Xml.XmlNodeAssertions<TSubject, TAssertions>
     {
-        public XmlNodeAssertions(TSubject xmlNode) { }
+        public XmlNodeAssertions(TSubject xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
index 24ab2600ca..ded4744261 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
@@ -15,12 +15,14 @@ namespace FluentAssertions
         public AndConstraint(TParent parent) { }
         public TParent And { get; }
     }
-    public class AndWhichConstraint<TParentConstraint, TMatchedElement> : FluentAssertions.AndConstraint<TParentConstraint>
+    public class AndWhichConstraint<TParent, TSubject> : FluentAssertions.AndConstraint<TParent>
     {
-        public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable<TMatchedElement> matchedConstraint) { }
-        public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { }
-        public TMatchedElement Subject { get; }
-        public TMatchedElement Which { get; }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects) { }
+        public AndWhichConstraint(TParent parent, TSubject subject) { }
+        public AndWhichConstraint(TParent parent, System.Collections.Generic.IEnumerable<TSubject> subjects, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix) { }
+        public AndWhichConstraint(TParent parent, TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain, string pathPostfix = "") { }
+        public TSubject Subject { get; }
+        public TSubject Which { get; }
     }
     public static class AssertionExtensions
     {
@@ -376,18 +378,18 @@ namespace FluentAssertions.Collections
 {
     public class GenericCollectionAssertions<T> : FluentAssertions.Collections.GenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.GenericCollectionAssertions<T>>
     {
-        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue) { }
+        public GenericCollectionAssertions(System.Collections.Generic.IEnumerable<T> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TCollection, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public GenericCollectionAssertions(TCollection actualValue) { }
+        public GenericCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TExpectation>> AllBeAssignableTo<TExpectation>(string because = "", params object[] becauseArgs) { }
@@ -461,7 +463,7 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> NotBeSubsetOf(System.Collections.Generic.IEnumerable<T> unexpectedSuperset, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Collections.Generic.IEnumerable<T> unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(System.Linq.Expressions.Expression<System.Func<T, bool>> predicate, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndWhichConstraint<TAssertions, T> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotContain(T unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectation unexpected, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotContainInConsecutiveOrder(params T[] unexpected) { }
@@ -492,13 +494,13 @@ namespace FluentAssertions.Collections
     public class GenericDictionaryAssertions<TCollection, TKey, TValue> : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue>>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, System.Collections.Generic.KeyValuePair<TKey, TValue>, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>
         where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions<TCollection, TKey, TValue, TAssertions>
     {
-        public GenericDictionaryAssertions(TCollection keyValuePairs) { }
+        public GenericDictionaryAssertions(TCollection keyValuePairs, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>, FluentAssertions.Equivalency.EquivalencyOptions<TExpectation>> config, string because = "", params object[] becauseArgs) { }
@@ -510,8 +512,8 @@ namespace FluentAssertions.Collections
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(params TKey[] expected) { }
         public FluentAssertions.AndConstraint<TAssertions> ContainKeys(System.Collections.Generic.IEnumerable<TKey> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TValue> ContainValue(TValue expected, string because = "", params object[] becauseArgs) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(params TValue[] expected) { }
-        public FluentAssertions.AndConstraint<TAssertions> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(params TValue[] expected) { }
+        public FluentAssertions.AndWhichConstraint<TAssertions, System.Collections.Generic.IEnumerable<TValue>> ContainValues(System.Collections.Generic.IEnumerable<TValue> expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Equal<T>(T expected, string because = "", params object[] becauseArgs)
             where T : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> { }
         public FluentAssertions.AndConstraint<TAssertions> NotContain(params System.Collections.Generic.KeyValuePair<TKey, TValue>[] items) { }
@@ -529,18 +531,18 @@ namespace FluentAssertions.Collections
     }
     public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions<System.Collections.Generic.IEnumerable<string>>
     {
-        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue) { }
+        public StringCollectionAssertions(System.Collections.Generic.IEnumerable<string> actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection> : FluentAssertions.Collections.StringCollectionAssertions<TCollection, FluentAssertions.Collections.StringCollectionAssertions<TCollection>>
         where TCollection : System.Collections.Generic.IEnumerable<string>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringCollectionAssertions<TCollection, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, string, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<string>
         where TAssertions : FluentAssertions.Collections.StringCollectionAssertions<TCollection, TAssertions>
     {
-        public StringCollectionAssertions(TCollection actualValue) { }
+        public StringCollectionAssertions(TCollection actualValue, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> AllBe(string expectation, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<string>, FluentAssertions.Equivalency.EquivalencyOptions<string>> config, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(params string[] expectation) { }
@@ -553,18 +555,18 @@ namespace FluentAssertions.Collections
     }
     public class SubsequentOrderingAssertions<T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<System.Collections.Generic.IEnumerable<T>, T, FluentAssertions.Collections.SubsequentOrderingAssertions<T>>
     {
-        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable<T> actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T> : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T>>
         where TCollection : System.Collections.Generic.IEnumerable<T>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions> : FluentAssertions.Collections.GenericCollectionAssertions<TCollection, T, TAssertions>
         where TCollection : System.Collections.Generic.IEnumerable<T>
         where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions<TCollection, T, TAssertions>
     {
-        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable) { }
+        public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable<T> previousOrderedEnumerable, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInAscendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, System.Collections.Generic.IComparer<TSelector> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Collections.SubsequentOrderingAssertions<T>> ThenBeInDescendingOrder<TSelector>(System.Linq.Expressions.Expression<System.Func<T, TSelector>> propertyExpression, string because = "", params object[] becauseArgs) { }
@@ -705,7 +707,7 @@ namespace FluentAssertions.Equivalency
     {
         protected EquivalencyStep() { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
-        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested);
+        protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator);
     }
     public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext
     {
@@ -797,7 +799,7 @@ namespace FluentAssertions.Equivalency
     }
     public interface IMemberMatchingRule
     {
-        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options);
+        FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyOptions options, FluentAssertions.Execution.AssertionChain assertionChain);
     }
     public interface IMemberSelectionRule
     {
@@ -959,7 +961,7 @@ namespace FluentAssertions.Equivalency.Steps
 {
     public class AssertionRuleEquivalencyStep<TSubject> : FluentAssertions.Equivalency.IEquivalencyStep
     {
-        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertion) { }
+        public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression<System.Func<FluentAssertions.Equivalency.IObjectInfo, bool>> predicate, System.Action<FluentAssertions.Equivalency.IAssertionContext<TSubject>> assertionAction) { }
         public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency valueChildNodes) { }
         public override string ToString() { }
     }
@@ -972,7 +974,7 @@ namespace FluentAssertions.Equivalency.Steps
     public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Collections.IDictionary>
     {
         public DictionaryEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep
     {
@@ -1033,17 +1035,17 @@ namespace FluentAssertions.Equivalency.Steps
     public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XAttribute>
     {
         public XAttributeEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XDocument>
     {
         public XDocumentEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
     public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep<System.Xml.Linq.XElement>
     {
         public XElementEquivalencyStep() { }
-        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nested) { }
+        protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IValidateChildNodeEquivalency nestedValidator) { }
     }
 }
 namespace FluentAssertions.Equivalency.Tracing
@@ -1073,7 +1075,7 @@ namespace FluentAssertions.Events
 {
     public class EventAssertions<T> : FluentAssertions.Primitives.ReferenceTypeAssertions<T, FluentAssertions.Events.EventAssertions<T>>
     {
-        protected EventAssertions(FluentAssertions.Events.IMonitor<T> monitor) { }
+        protected EventAssertions(FluentAssertions.Events.IMonitor<T> monitor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.Events.IMonitor<T> Monitor { get; }
         public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { }
@@ -1119,76 +1121,65 @@ namespace FluentAssertions.Events
 }
 namespace FluentAssertions.Execution
 {
+    public sealed class AssertionChain
+    {
+        public string CallerIdentifier { get; }
+        public bool HasOverriddenCallerIdentifier { get; }
+        public bool PreviousAssertionSucceeded { get; }
+        public bool Succeeded { get; }
+        public FluentAssertions.Execution.AssertionChain UsingLineBreaks { get; }
+        public void AddPreFormattedFailure(string failure) { }
+        public void AddReportable(string key, System.Func<string> getValue) { }
+        public void AddReportable(string key, string value) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(FluentAssertions.Execution.Reason reason) { }
+        public FluentAssertions.Execution.AssertionChain BecauseOf(string because, params object[] becauseArgs) { }
+        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> getFailureReason) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
+        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
+        public FluentAssertions.Execution.AssertionChain ForCondition(bool condition) { }
+        public FluentAssertions.Execution.AssertionChain ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
+        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
+        public void OverrideCallerIdentifier(System.Func<string> getCallerIdentifier) { }
+        public void ReuseOnce() { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPostfix(string postfix) { }
+        public FluentAssertions.Execution.AssertionChain WithCallerPrefix(string prefix) { }
+        public FluentAssertions.Execution.AssertionChain WithDefaultIdentifier(string identifier) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.Continuation WithExpectation(string message, object arg1, object arg2, System.Action<FluentAssertions.Execution.AssertionChain> chain) { }
+        public FluentAssertions.Execution.AssertionChain WithReportable(string name, System.Func<string> content) { }
+        public static FluentAssertions.Execution.AssertionChain GetOrCreate() { }
+    }
     [System.Serializable]
     public class AssertionFailedException : System.Exception
     {
         public AssertionFailedException(string message) { }
         protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
     }
-    public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
+    public sealed class AssertionScope : System.IDisposable
     {
         public AssertionScope() { }
         public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { }
-        public AssertionScope(System.Lazy<string> context) { }
-        public AssertionScope(string context) { }
-        public string CallerIdentity { get; }
-        public System.Lazy<string> Context { get; set; }
+        public AssertionScope(System.Func<string> name) { }
+        public AssertionScope(string name) { }
         public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; }
-        public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; }
+        public System.Func<string> Name { get; }
         public static FluentAssertions.Execution.AssertionScope Current { get; }
-        public void AddNonReportable(string key, object value) { }
         public void AddPreFormattedFailure(string formattedFailureMessage) { }
-        public void AddReportable(string key, System.Func<string> valueFunc) { }
-        public void AddReportable(string key, string value) { }
         public void AppendTracing(string tracingBlock) { }
-        public void AssumeSingleCaller() { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { }
-        public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
         public string[] Discard() { }
         public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public T Get<T>(string key) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
         public bool HasFailures() { }
-        public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { }
     }
     public class Continuation
     {
-        public FluentAssertions.Execution.IAssertionScope Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { }
+        public FluentAssertions.Execution.AssertionChain Then { get; }
     }
     public class ContinuationOfGiven<TSubject>
     {
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.GivenSelector<TSubject> Then { get; }
-        public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven<TSubject> continuationOfGiven) { }
-    }
-    public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable
-    {
-        public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { }
-        public FluentAssertions.Execution.Continuation ClearExpectation() { }
-        public string[] Discard() { }
-        public void Dispose() { }
-        public FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders) { }
-        public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { }
-        public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { }
-        public FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { }
-        public FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector) { }
-        public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { }
-        public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { }
-    }
-    public static class Execute
-    {
-        public static FluentAssertions.Execution.AssertionScope Assertion { get; }
     }
     public class FailReason
     {
@@ -1198,29 +1189,13 @@ namespace FluentAssertions.Execution
     }
     public class GivenSelector<T>
     {
-        public FluentAssertions.Execution.ContinuationOfGiven<T> ClearExpectation() { }
+        public bool Succeeded { get; }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params System.Func<T, object>[] args) { }
         public FluentAssertions.Execution.ContinuationOfGiven<T> FailWith(string message, params object[] args) { }
         public FluentAssertions.Execution.GivenSelector<T> ForCondition(System.Func<T, bool> predicate) { }
         public FluentAssertions.Execution.GivenSelector<TOut> Given<TOut>(System.Func<T, TOut> selector) { }
     }
-    public interface IAssertionScope : System.IDisposable
-    {
-        FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; }
-        FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs);
-        FluentAssertions.Execution.Continuation ClearExpectation();
-        string[] Discard();
-        FluentAssertions.Execution.Continuation FailWith(System.Func<FluentAssertions.Execution.FailReason> failReasonFunc);
-        FluentAssertions.Execution.Continuation FailWith(string message);
-        FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<object>[] argProviders);
-        FluentAssertions.Execution.Continuation FailWith(string message, params object[] args);
-        FluentAssertions.Execution.IAssertionScope ForCondition(bool condition);
-        FluentAssertions.Execution.IAssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences);
-        FluentAssertions.Execution.GivenSelector<T> Given<T>(System.Func<T> selector);
-        FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier);
-        FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args);
-    }
     public interface IAssertionStrategy
     {
         System.Collections.Generic.IEnumerable<string> FailureMessages { get; }
@@ -1463,6 +1438,12 @@ namespace FluentAssertions.Formatting
         public MaxLinesExceededException(string message) { }
         public MaxLinesExceededException(string message, System.Exception innerException) { }
     }
+    public class MethodInfoFormatter : FluentAssertions.Formatting.IValueFormatter
+    {
+        public MethodInfoFormatter() { }
+        public bool CanHandle(object value) { }
+        public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { }
+    }
     public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter
     {
         public MultidimensionalArrayFormatter() { }
@@ -1569,12 +1550,12 @@ namespace FluentAssertions.Numeric
 {
     public class ComparableTypeAssertions<T> : FluentAssertions.Numeric.ComparableTypeAssertions<T, FluentAssertions.Numeric.ComparableTypeAssertions<T>>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class ComparableTypeAssertions<T, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.IComparable<T>, TAssertions>
         where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions<T, TAssertions>
     {
-        public ComparableTypeAssertions(System.IComparable<T> value) { }
+        public ComparableTypeAssertions(System.IComparable<T> value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo<TExpectation>(TExpectation expectation, string because = "", params object[] becauseArgs) { }
@@ -1594,13 +1575,13 @@ namespace FluentAssertions.Numeric
     public class NullableNumericAssertions<T> : FluentAssertions.Numeric.NullableNumericAssertions<T, FluentAssertions.Numeric.NullableNumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableNumericAssertions<T, TAssertions> : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions<T, TAssertions>
     {
-        public NullableNumericAssertions(T? value) { }
+        public NullableNumericAssertions(T? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Match(System.Linq.Expressions.Expression<System.Func<T?, bool>> predicate, string because = "", params object[] becauseArgs) { }
@@ -1610,13 +1591,14 @@ namespace FluentAssertions.Numeric
     public class NumericAssertions<T> : FluentAssertions.Numeric.NumericAssertions<T, FluentAssertions.Numeric.NumericAssertions<T>>
         where T :  struct, System.IComparable<T>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NumericAssertions<T, TAssertions>
         where T :  struct, System.IComparable<T>
         where TAssertions : FluentAssertions.Numeric.NumericAssertions<T, TAssertions>
     {
-        public NumericAssertions(T value) { }
+        public NumericAssertions(T value, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         public T? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(T expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(T? expected, string because = "", params object[] becauseArgs) { }
@@ -1642,12 +1624,12 @@ namespace FluentAssertions.Primitives
 {
     public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions<FluentAssertions.Primitives.BooleanAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
     {
-        public BooleanAssertions(bool? value) { }
+        public BooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public bool? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeFalse(string because = "", params object[] becauseArgs) { }
@@ -1658,12 +1640,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions<FluentAssertions.Primitives.DateTimeAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        public DateTimeAssertions(System.DateTime? value) { }
+        public DateTimeAssertions(System.DateTime? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTime? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { }
@@ -1708,12 +1690,12 @@ namespace FluentAssertions.Primitives
     }
     public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<FluentAssertions.Primitives.DateTimeOffsetAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        public DateTimeOffsetAssertions(System.DateTimeOffset? value) { }
+        public DateTimeOffsetAssertions(System.DateTimeOffset? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.DateTimeOffset? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { }
@@ -1763,7 +1745,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeOffsetRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
     {
-        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1771,7 +1753,7 @@ namespace FluentAssertions.Primitives
     public class DateTimeRangeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
     {
-        protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
+        protected DateTimeRangeAssertions(TAssertions parentAssertions, FluentAssertions.Execution.AssertionChain assertionChain, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { }
         public FluentAssertions.AndConstraint<TAssertions> After(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Before(System.DateTime target, string because = "", params object[] becauseArgs) { }
         public override bool Equals(object obj) { }
@@ -1779,13 +1761,13 @@ namespace FluentAssertions.Primitives
     public class EnumAssertions<TEnum> : FluentAssertions.Primitives.EnumAssertions<TEnum, FluentAssertions.Primitives.EnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
     {
-        public EnumAssertions(TEnum subject) { }
+        public EnumAssertions(TEnum subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TEnum? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TEnum? expected, string because = "", params object[] becauseArgs) { }
@@ -1812,12 +1794,12 @@ namespace FluentAssertions.Primitives
     }
     public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions<FluentAssertions.Primitives.GuidAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.GuidAssertions<TAssertions>
     {
-        public GuidAssertions(System.Guid? value) { }
+        public GuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.Guid? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
@@ -1829,12 +1811,12 @@ namespace FluentAssertions.Primitives
     }
     public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
     {
-        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
         where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
     {
-        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
@@ -1846,12 +1828,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableBooleanAssertions<TAssertions> : FluentAssertions.Primitives.BooleanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<TAssertions>
     {
-        public NullableBooleanAssertions(bool? value) { }
+        public NullableBooleanAssertions(bool? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(bool? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1863,12 +1845,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<FluentAssertions.Primitives.NullableDateTimeAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions<TAssertions>
     {
-        public NullableDateTimeAssertions(System.DateTime? expected) { }
+        public NullableDateTimeAssertions(System.DateTime? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1876,12 +1858,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<FluentAssertions.Primitives.NullableDateTimeOffsetAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableDateTimeOffsetAssertions<TAssertions> : FluentAssertions.Primitives.DateTimeOffsetAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions<TAssertions>
     {
-        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { }
+        public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1890,13 +1872,13 @@ namespace FluentAssertions.Primitives
     public class NullableEnumAssertions<TEnum> : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, FluentAssertions.Primitives.NullableEnumAssertions<TEnum>>
         where TEnum :  struct, System.Enum
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableEnumAssertions<TEnum, TAssertions> : FluentAssertions.Primitives.EnumAssertions<TEnum, TAssertions>
         where TEnum :  struct, System.Enum
         where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions<TEnum, TAssertions>
     {
-        public NullableEnumAssertions(TEnum? subject) { }
+        public NullableEnumAssertions(TEnum? subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> HaveValue(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<TAssertions, TEnum> NotBeNull(string because = "", params object[] becauseArgs) { }
@@ -1904,12 +1886,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions<FluentAssertions.Primitives.NullableGuidAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableGuidAssertions<TAssertions> : FluentAssertions.Primitives.GuidAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions<TAssertions>
     {
-        public NullableGuidAssertions(System.Guid? value) { }
+        public NullableGuidAssertions(System.Guid? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.Guid? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1918,12 +1900,12 @@ namespace FluentAssertions.Primitives
     }
     public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class NullableSimpleTimeSpanAssertions<TAssertions> : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions<TAssertions>
     {
-        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public NullableSimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeNull(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveValue(string because = "", params object[] becauseArgs) { }
@@ -1932,7 +1914,7 @@ namespace FluentAssertions.Primitives
     }
     public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions<object, FluentAssertions.Primitives.ObjectAssertions>
     {
-        public ObjectAssertions(object value) { }
+        public ObjectAssertions(object value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> Be<TExpectation>(TExpectation expected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeOneOf<TExpectation>(System.Collections.Generic.IEnumerable<TExpectation> validValues, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> NotBe<TExpectation>(TExpectation unexpected, System.Collections.Generic.IEqualityComparer<TExpectation> comparer, string because = "", params object[] becauseArgs) { }
@@ -1940,7 +1922,7 @@ namespace FluentAssertions.Primitives
     public class ObjectAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ObjectAssertions<TSubject, TAssertions>
     {
-        public ObjectAssertions(TSubject value) { }
+        public ObjectAssertions(TSubject value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> Be(TSubject expected, System.Collections.Generic.IEqualityComparer<TSubject> comparer, string because = "", params object[] becauseArgs) { }
@@ -1958,7 +1940,8 @@ namespace FluentAssertions.Primitives
     public abstract class ReferenceTypeAssertions<TSubject, TAssertions>
         where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
     {
-        protected ReferenceTypeAssertions(TSubject subject) { }
+        protected ReferenceTypeAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FluentAssertions.Execution.AssertionChain CurrentAssertionChain { get; }
         protected abstract string Identifier { get; }
         public TSubject Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { }
@@ -1982,12 +1965,12 @@ namespace FluentAssertions.Primitives
     }
     public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<FluentAssertions.Primitives.SimpleTimeSpanAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class SimpleTimeSpanAssertions<TAssertions>
         where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions<TAssertions>
     {
-        public SimpleTimeSpanAssertions(System.TimeSpan? value) { }
+        public SimpleTimeSpanAssertions(System.TimeSpan? value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public System.TimeSpan? Subject { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
@@ -2003,12 +1986,12 @@ namespace FluentAssertions.Primitives
     }
     public class StringAssertions : FluentAssertions.Primitives.StringAssertions<FluentAssertions.Primitives.StringAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StringAssertions<TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<string, TAssertions>
         where TAssertions : FluentAssertions.Primitives.StringAssertions<TAssertions>
     {
-        public StringAssertions(string value) { }
+        public StringAssertions(string value, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> Be(string expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeEmpty(string because = "", params object[] becauseArgs) { }
@@ -2084,8 +2067,8 @@ namespace FluentAssertions.Specialized
 {
     public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions<System.Action, FluentAssertions.Specialized.ActionAssertions>
     {
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2095,7 +2078,7 @@ namespace FluentAssertions.Specialized
         where TTask : System.Threading.Tasks.Task
         where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<TTask, TAssertions>
     {
-        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        protected AsyncFunctionAssertions(System.Func<TTask> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<TAssertions>> NotThrowAsync<TException>(string because = "", params object[] becauseArgs)
@@ -2121,7 +2104,7 @@ namespace FluentAssertions.Specialized
         where TDelegate : System.Delegate
         where TAssertions : FluentAssertions.Specialized.DelegateAssertions<TDelegate, TAssertions>
     {
-        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
+        protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected abstract void InvokeSubject();
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
@@ -2133,7 +2116,7 @@ namespace FluentAssertions.Specialized
     public class ExceptionAssertions<TException> : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Collections.Generic.IEnumerable<TException>, FluentAssertions.Specialized.ExceptionAssertions<TException>>
         where TException : System.Exception
     {
-        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions) { }
+        public ExceptionAssertions(System.Collections.Generic.IEnumerable<TException> exceptions, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public TException And { get; }
         protected override string Identifier { get; }
         public TException Which { get; }
@@ -2155,7 +2138,7 @@ namespace FluentAssertions.Specialized
     }
     public class ExecutionTimeAssertions
     {
-        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { }
+        public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ExecutionTimeAssertions> BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { }
@@ -2165,8 +2148,8 @@ namespace FluentAssertions.Specialized
     }
     public class FunctionAssertions<T> : FluentAssertions.Specialized.DelegateAssertions<System.Func<T>, FluentAssertions.Specialized.FunctionAssertions<T>>
     {
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public FunctionAssertions(System.Func<T> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs) { }
@@ -2174,8 +2157,8 @@ namespace FluentAssertions.Specialized
     }
     public class GenericAsyncFunctionAssertions<TResult> : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task<TResult>, FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>>
     {
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public GenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task<TResult>> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2191,8 +2174,8 @@ namespace FluentAssertions.Specialized
     }
     public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions<System.Threading.Tasks.Task, FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>
     {
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { }
-        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public NonGenericAsyncFunctionAssertions(System.Func<System.Threading.Tasks.Task> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions>> NotThrowAsync(string because = "", params object[] becauseArgs) { }
@@ -2204,8 +2187,8 @@ namespace FluentAssertions.Specialized
     }
     public class TaskCompletionSourceAssertions<T> : FluentAssertions.Specialized.TaskCompletionSourceAssertionsBase
     {
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs) { }
-        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Common.IClock clock) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain) { }
+        public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource<T> tcs, FluentAssertions.Execution.AssertionChain assertionChain, FluentAssertions.Common.IClock clock) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndWhichConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
         public System.Threading.Tasks.Task<FluentAssertions.AndConstraint<FluentAssertions.Specialized.TaskCompletionSourceAssertions<T>>> NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { }
     }
@@ -2214,25 +2197,25 @@ namespace FluentAssertions.Streams
 {
     public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions<FluentAssertions.Streams.BufferedStreamAssertions>
     {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        public BufferedStreamAssertions(System.IO.BufferedStream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class BufferedStreamAssertions<TAssertions> : FluentAssertions.Streams.StreamAssertions<System.IO.BufferedStream, TAssertions>
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
-        public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        public BufferedStreamAssertions(System.IO.BufferedStream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { }
     }
     public class StreamAssertions : FluentAssertions.Streams.StreamAssertions<System.IO.Stream, FluentAssertions.Streams.StreamAssertions>
     {
-        public StreamAssertions(System.IO.Stream stream) { }
+        public StreamAssertions(System.IO.Stream stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class StreamAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.IO.Stream
         where TAssertions : FluentAssertions.Streams.StreamAssertions<TSubject, TAssertions>
     {
-        public StreamAssertions(TSubject stream) { }
+        public StreamAssertions(TSubject stream, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeReadOnly(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
@@ -2258,7 +2241,7 @@ namespace FluentAssertions.Types
     }
     public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Reflection.Assembly, FluentAssertions.Types.AssemblyAssertions>
     {
-        public AssemblyAssertions(System.Reflection.Assembly assembly) { }
+        public AssemblyAssertions(System.Reflection.Assembly assembly, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeSignedWithPublicKey(string publicKey, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.AssemblyAssertions> BeUnsigned(string because = "", params object[] becauseArgs) { }
@@ -2268,15 +2251,17 @@ namespace FluentAssertions.Types
     }
     public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.ConstructorInfo, FluentAssertions.Types.ConstructorInfoAssertions>
     {
-        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { }
+        public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
     }
     public abstract class MemberInfoAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Reflection.MemberInfo
         where TAssertions : FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>
     {
-        protected MemberInfoAssertions(TSubject subject) { }
+        protected MemberInfoAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected virtual string SubjectDescription { get; }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Types.MemberInfoAssertions<TSubject, TAssertions>, TAttribute> BeDecoratedWith<TAttribute>(System.Linq.Expressions.Expression<System.Func<TAttribute, bool>> isMatchingAttributePredicate, string because = "", params object[] becauseArgs)
@@ -2290,14 +2275,15 @@ namespace FluentAssertions.Types
         where TSubject : System.Reflection.MethodBase
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
-        protected MethodBaseAssertions(TSubject subject) { }
+        protected MethodBaseAssertions(TSubject subject, FluentAssertions.Execution.AssertionChain assertionChain) { }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
     public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions<System.Reflection.MethodInfo, FluentAssertions.Types.MethodInfoAssertions>
     {
-        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { }
+        public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeAsync(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoAssertions> NotBeAsync(string because = "", params object[] becauseArgs) { }
@@ -2340,7 +2326,7 @@ namespace FluentAssertions.Types
     }
     public class MethodInfoSelectorAssertions
     {
-        public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { }
+        public MethodInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.MethodInfo[] methods) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> SubjectMethods { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.MethodInfoSelectorAssertions> Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
@@ -2361,8 +2347,9 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions<System.Reflection.PropertyInfo, FluentAssertions.Types.PropertyInfoAssertions>
     {
-        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { }
+        public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
+        protected override string SubjectDescription { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoAssertions> BeVirtual(string because = "", params object[] becauseArgs) { }
@@ -2403,7 +2390,7 @@ namespace FluentAssertions.Types
     }
     public class PropertyInfoSelectorAssertions
     {
-        public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { }
+        public PropertyInfoSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Reflection.PropertyInfo[] properties) { }
         protected string Context { get; }
         public System.Collections.Generic.IEnumerable<System.Reflection.PropertyInfo> SubjectProperties { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.PropertyInfoSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
@@ -2418,7 +2405,7 @@ namespace FluentAssertions.Types
     }
     public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Type, FluentAssertions.Types.TypeAssertions>
     {
-        public TypeAssertions(System.Type type) { }
+        public TypeAssertions(System.Type type, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be(System.Type expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeAssertions> Be<TExpected>(string because = "", params object[] becauseArgs) { }
@@ -2536,7 +2523,7 @@ namespace FluentAssertions.Types
     }
     public class TypeSelectorAssertions
     {
-        public TypeSelectorAssertions(params System.Type[] types) { }
+        public TypeSelectorAssertions(FluentAssertions.Execution.AssertionChain assertionChain, params System.Type[] types) { }
         public System.Collections.Generic.IEnumerable<System.Type> Subject { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Types.TypeSelectorAssertions> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
             where TAttribute : System.Attribute { }
@@ -2567,7 +2554,7 @@ namespace FluentAssertions.Xml
 {
     public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XAttribute, FluentAssertions.Xml.XAttributeAssertions>
     {
-        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { }
+        public XAttributeAssertions(System.Xml.Linq.XAttribute attribute, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XAttributeAssertions> HaveValue(string expected, string because = "", params object[] becauseArgs) { }
@@ -2575,7 +2562,7 @@ namespace FluentAssertions.Xml
     }
     public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XDocument, FluentAssertions.Xml.XDocumentAssertions>
     {
-        public XDocumentAssertions(System.Xml.Linq.XDocument document) { }
+        public XDocumentAssertions(System.Xml.Linq.XDocument document, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XDocumentAssertions> BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { }
@@ -2590,7 +2577,7 @@ namespace FluentAssertions.Xml
     }
     public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions<System.Xml.Linq.XElement, FluentAssertions.Xml.XElementAssertions>
     {
-        public XElementAssertions(System.Xml.Linq.XElement xElement) { }
+        public XElementAssertions(System.Xml.Linq.XElement xElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XElementAssertions> BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { }
@@ -2606,7 +2593,7 @@ namespace FluentAssertions.Xml
     }
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
-        public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        public XmlElementAssertions(System.Xml.XmlElement xmlElement, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
@@ -2616,13 +2603,13 @@ namespace FluentAssertions.Xml
     }
     public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlNode, FluentAssertions.Xml.XmlNodeAssertions>
     {
-        public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { }
+        public XmlNodeAssertions(System.Xml.XmlNode xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
     }
     public class XmlNodeAssertions<TSubject, TAssertions> : FluentAssertions.Primitives.ReferenceTypeAssertions<TSubject, TAssertions>
         where TSubject : System.Xml.XmlNode
         where TAssertions : FluentAssertions.Xml.XmlNodeAssertions<TSubject, TAssertions>
     {
-        public XmlNodeAssertions(TSubject xmlNode) { }
+        public XmlNodeAssertions(TSubject xmlNode, FluentAssertions.Execution.AssertionChain assertionChain) { }
         protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Benchmarks/Program.cs b/Tests/Benchmarks/Program.cs
index 2dc62955e7..ff2fb9ab18 100644
--- a/Tests/Benchmarks/Program.cs
+++ b/Tests/Benchmarks/Program.cs
@@ -1,5 +1,4 @@
 using System.Globalization;
-using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Exporters.Csv;
 using BenchmarkDotNet.Reports;
diff --git a/Tests/FluentAssertions.Equivalency.Specs/BasicSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/BasicSpecs.cs
index 1936a02b89..b1c54dd353 100644
--- a/Tests/FluentAssertions.Equivalency.Specs/BasicSpecs.cs
+++ b/Tests/FluentAssertions.Equivalency.Specs/BasicSpecs.cs
@@ -599,8 +599,7 @@ public void When_asserting_equivalence_including_only_properties_it_should_not_m
     }
 
     [Fact]
-    public void
-        When_asserting_equivalence_of_objects_including_enumerables_it_should_print_the_failure_message_only_once()
+    public void When_asserting_equivalence_of_objects_including_enumerables_it_should_print_the_failure_message_only_once()
     {
         // Arrange
         var record = new { Member1 = "", Member2 = new[] { "", "" } };
diff --git a/Tests/FluentAssertions.Equivalency.Specs/CollectionSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/CollectionSpecs.cs
index 64e036548d..27c74ec048 100644
--- a/Tests/FluentAssertions.Equivalency.Specs/CollectionSpecs.cs
+++ b/Tests/FluentAssertions.Equivalency.Specs/CollectionSpecs.cs
@@ -1467,8 +1467,7 @@ public void Can_force_strict_ordering_based_on_the_parent_type_of_an_unordered_c
 
         // Assert
         action.Should().Throw<XunitException>()
-            .WithMessage(
-                "*Expected*[0].UnorderedCollection*5 item(s)*empty collection*");
+            .WithMessage("*Expected*[0].UnorderedCollection*5 item(s)*empty collection*");
     }
 
     [Fact]
diff --git a/Tests/FluentAssertions.Equivalency.Specs/DictionarySpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/DictionarySpecs.cs
index ea5f509b56..131efc6be3 100644
--- a/Tests/FluentAssertions.Equivalency.Specs/DictionarySpecs.cs
+++ b/Tests/FluentAssertions.Equivalency.Specs/DictionarySpecs.cs
@@ -570,6 +570,29 @@ public void
         act.Should().Throw<XunitException>("the types have different properties");
     }
 
+    [Fact]
+    public void Can_compare_non_generic_directories_without_recursing()
+    {
+        // Arrange
+        var expected = new NonGenericDictionary
+        {
+            ["Key2"] = "Value2",
+            ["Key1"] = "Value1"
+        };
+
+        var subject = new NonGenericDictionary
+        {
+            ["Key1"] = "Value1",
+            ["Key3"] = "Value2"
+        };
+
+        // Act
+        Action act = () => subject.Should().BeEquivalentTo(expected, options => options.ExcludingNestedObjects());
+
+        // Assert
+        act.Should().Throw<XunitException>().WithMessage("Expected subject[\"Key2\"] to be \"Value2\", but found <null>*");
+    }
+
     [Fact]
     public void When_asserting_equivalence_of_dictionaries_it_should_respect_the_declared_type()
     {
diff --git a/Tests/FluentAssertions.Equivalency.Specs/ExtensibilitySpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/ExtensibilitySpecs.cs
index a4c7478d4a..af8beba7ce 100644
--- a/Tests/FluentAssertions.Equivalency.Specs/ExtensibilitySpecs.cs
+++ b/Tests/FluentAssertions.Equivalency.Specs/ExtensibilitySpecs.cs
@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
+using FluentAssertions.Execution;
 using FluentAssertions.Extensions;
 using JetBrains.Annotations;
 using Xunit;
@@ -141,7 +142,8 @@ public void When_a_matching_rule_is_added_it_should_appear_in_the_exception_mess
 
     internal class ForeignKeyMatchingRule : IMemberMatchingRule
     {
-        public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options)
+        public IMember Match(IMember expectedMember, object subject, INode parent, IEquivalencyOptions options,
+            AssertionChain assertionChain)
         {
             string name = expectedMember.Name;
 
@@ -296,7 +298,7 @@ public void When_equally_named_properties_are_both_incompatible_with_generic_typ
 
         // Assert
         act.Should().Throw<XunitException>()
-            .WithMessage("*Id*from subject*System.String*System.Double*Id*from expectation*System.String*System.Double*");
+            .WithMessage("*Id*from subject*System.String*System.Double*");
     }
 
     [Fact]
@@ -335,13 +337,13 @@ public void When_property_of_subject_is_null_the_failure_message_should_not_comp
             Id = null as double?,
         };
 
-        var other = new
+        var expectation = new
         {
             Id = "bar",
         };
 
         // Act
-        Action act = () => subject.Should().BeEquivalentTo(other,
+        Action act = () => subject.Should().BeEquivalentTo(expectation,
             o => o
                 .Using<string>(c => c.Subject.Should().Be(c.Expectation))
                 .When(si => si.Path == "Id"));
diff --git a/Tests/FluentAssertions.Specs/AssertionExtensions.cs b/Tests/FluentAssertions.Specs/AssertionExtensions.cs
index 1e8936c211..add27b751a 100644
--- a/Tests/FluentAssertions.Specs/AssertionExtensions.cs
+++ b/Tests/FluentAssertions.Specs/AssertionExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 using FluentAssertions.Specialized;
 
 namespace FluentAssertions.Specs;
@@ -11,33 +12,33 @@ internal static class AssertionExtensions
 
     public static NonGenericAsyncFunctionAssertions Should(this Func<Task> action, IClock clock)
     {
-        return new NonGenericAsyncFunctionAssertions(action, Extractor, clock);
+        return new NonGenericAsyncFunctionAssertions(action, Extractor, AssertionChain.GetOrCreate(), clock);
     }
 
     public static GenericAsyncFunctionAssertions<T> Should<T>(this Func<Task<T>> action, IClock clock)
     {
-        return new GenericAsyncFunctionAssertions<T>(action, Extractor, clock);
+        return new GenericAsyncFunctionAssertions<T>(action, Extractor, AssertionChain.GetOrCreate(), clock);
     }
 
     public static ActionAssertions Should(this Action action, IClock clock)
     {
-        return new ActionAssertions(action, Extractor, clock);
+        return new ActionAssertions(action, Extractor, AssertionChain.GetOrCreate(),  clock);
     }
 
     public static FunctionAssertions<T> Should<T>(this Func<T> func, IClock clock)
     {
-        return new FunctionAssertions<T>(func, Extractor, clock);
+        return new FunctionAssertions<T>(func, Extractor, AssertionChain.GetOrCreate(), clock);
     }
 
     public static TaskCompletionSourceAssertions<T> Should<T>(this TaskCompletionSource<T> tcs, IClock clock)
     {
-        return new TaskCompletionSourceAssertions<T>(tcs, clock);
+        return new TaskCompletionSourceAssertions<T>(tcs, AssertionChain.GetOrCreate(), clock);
     }
 
 #if NET6_0_OR_GREATER
     public static TaskCompletionSourceAssertions Should(this TaskCompletionSource tcs, IClock clock)
     {
-        return new TaskCompletionSourceAssertions(tcs, clock);
+        return new TaskCompletionSourceAssertions(tcs, AssertionChain.GetOrCreate(), clock);
     }
 
 #endif
diff --git a/Tests/FluentAssertions.Specs/AssertionExtensionsSpecs.cs b/Tests/FluentAssertions.Specs/AssertionExtensionsSpecs.cs
index 9ee81a9033..4963fd2a99 100644
--- a/Tests/FluentAssertions.Specs/AssertionExtensionsSpecs.cs
+++ b/Tests/FluentAssertions.Specs/AssertionExtensionsSpecs.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 using FluentAssertions.Numeric;
 using FluentAssertions.Primitives;
 using FluentAssertions.Specialized;
@@ -40,24 +41,24 @@ private static bool OverridesEquals(Type t)
 
     public static TheoryData<object> ClassesWithGuardEquals => new()
     {
-        new ObjectAssertions<object, ObjectAssertions>(default),
-        new BooleanAssertions<BooleanAssertions>(default),
-        new DateTimeAssertions<DateTimeAssertions>(default),
-        new DateTimeRangeAssertions<DateTimeAssertions>(default, default, default, default),
-        new DateTimeOffsetAssertions<DateTimeOffsetAssertions>(default),
-        new DateTimeOffsetRangeAssertions<DateTimeOffsetAssertions>(default, default, default, default),
-        new ExecutionTimeAssertions(new ExecutionTime(() => { }, () => new StopwatchTimer())),
-        new GuidAssertions<GuidAssertions>(default),
-        new MethodInfoSelectorAssertions(),
-        new NumericAssertions<int, NumericAssertions<int>>(default),
-        new PropertyInfoSelectorAssertions(),
-        new SimpleTimeSpanAssertions<SimpleTimeSpanAssertions>(default),
-        new TaskCompletionSourceAssertions<int>(default),
-        new TypeSelectorAssertions(),
-        new EnumAssertions<StringComparison, EnumAssertions<StringComparison>>(default),
+        new ObjectAssertions<object, ObjectAssertions>(default, AssertionChain.GetOrCreate()),
+        new BooleanAssertions<BooleanAssertions>(default, AssertionChain.GetOrCreate()),
+        new DateTimeAssertions<DateTimeAssertions>(default, AssertionChain.GetOrCreate()),
+        new DateTimeRangeAssertions<DateTimeAssertions>(default, AssertionChain.GetOrCreate(),  default, default, default),
+        new DateTimeOffsetAssertions<DateTimeOffsetAssertions>(default, AssertionChain.GetOrCreate()),
+        new DateTimeOffsetRangeAssertions<DateTimeOffsetAssertions>(default, AssertionChain.GetOrCreate(), default, default, default),
+        new ExecutionTimeAssertions(new ExecutionTime(() => { }, () => new StopwatchTimer()), AssertionChain.GetOrCreate()),
+        new GuidAssertions<GuidAssertions>(default, AssertionChain.GetOrCreate()),
+        new MethodInfoSelectorAssertions(AssertionChain.GetOrCreate()),
+        new NumericAssertions<int, NumericAssertions<int>>(default, AssertionChain.GetOrCreate()),
+        new PropertyInfoSelectorAssertions(AssertionChain.GetOrCreate()),
+        new SimpleTimeSpanAssertions<SimpleTimeSpanAssertions>(default, AssertionChain.GetOrCreate()),
+        new TaskCompletionSourceAssertions<int>(default, AssertionChain.GetOrCreate()),
+        new TypeSelectorAssertions(AssertionChain.GetOrCreate()),
+        new EnumAssertions<StringComparison, EnumAssertions<StringComparison>>(default, AssertionChain.GetOrCreate()),
 #if NET6_0_OR_GREATER
-        new DateOnlyAssertions<DateOnlyAssertions>(default),
-        new TimeOnlyAssertions<TimeOnlyAssertions>(default),
+        new DateOnlyAssertions<DateOnlyAssertions>(default, AssertionChain.GetOrCreate()),
+        new TimeOnlyAssertions<TimeOnlyAssertions>(default, AssertionChain.GetOrCreate()),
 #endif
     };
 
@@ -163,7 +164,7 @@ public void Should_methods_have_a_matching_overload_to_guard_against_chaining_an
     public void Should_methods_returning_reference_type_assertions_are_annotated_with_not_null_attribute(MethodInfo method)
     {
         var notNullAttribute = method.GetParameters().Single().GetCustomAttribute<NotNullAttribute>();
-        notNullAttribute.Should().NotBeNull();
+        notNullAttribute.Should().NotBeNull($"because {method} should be annotated with [NotNull]");
     }
 
     [Theory]
@@ -171,7 +172,7 @@ public void Should_methods_returning_reference_type_assertions_are_annotated_wit
     public void Should_methods_not_returning_reference_type_assertions_are_not_annotated_with_not_null_attribute(MethodInfo method)
     {
         var notNullAttribute = method.GetParameters().Single().GetCustomAttribute<NotNullAttribute>();
-        notNullAttribute.Should().BeNull();
+        notNullAttribute.Should().BeNull($"because {method} should NOT be annotated with [NotNull]");
     }
 
     public static IEnumerable<object[]> GetShouldMethods(bool referenceTypes)
diff --git a/Tests/FluentAssertions.Specs/AssertionFailureSpecs.cs b/Tests/FluentAssertions.Specs/AssertionFailureSpecs.cs
index ea81a04d7a..857253db82 100644
--- a/Tests/FluentAssertions.Specs/AssertionFailureSpecs.cs
+++ b/Tests/FluentAssertions.Specs/AssertionFailureSpecs.cs
@@ -1,6 +1,5 @@
 using System;
 using FluentAssertions.Execution;
-using FluentAssertions.Primitives;
 using Xunit;
 using Xunit.Sdk;
 
@@ -70,23 +69,15 @@ public void When_reason_does_not_start_with_because_but_is_prefixed_with_blanks_
             .WithMessage("Expected it to fail\r\nbecause AssertionsTestSubClass should always fail.");
     }
 
-    internal class AssertionsTestSubClass : ReferenceTypeAssertions<object, AssertionsTestSubClass>
+    internal class AssertionsTestSubClass
     {
+        private readonly AssertionChain assertionChain = AssertionChain.GetOrCreate();
+
         public void AssertFail(string because, params object[] becauseArgs)
         {
-            Execute.Assertion
+            assertionChain
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected it to fail{reason}");
         }
-
-        protected override string Identifier
-        {
-            get { return "test"; }
-        }
-
-        public AssertionsTestSubClass()
-            : base(null)
-        {
-        }
     }
 }
diff --git a/Tests/FluentAssertions.Specs/AssertionOptionsSpecs.cs b/Tests/FluentAssertions.Specs/AssertionOptionsSpecs.cs
index 0ffac09bcd..a931266d0b 100644
--- a/Tests/FluentAssertions.Specs/AssertionOptionsSpecs.cs
+++ b/Tests/FluentAssertions.Specs/AssertionOptionsSpecs.cs
@@ -421,7 +421,7 @@ internal class MyEquivalencyStep : IEquivalencyStep
         public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationContext context,
             IValidateChildNodeEquivalency valueChildNodes)
         {
-            Execute.Assertion.FailWith(GetType().FullName);
+            AssertionChain.GetOrCreate().For(context).FailWith(GetType().FullName);
 
             return EquivalencyResult.EquivalencyProven;
         }
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.BeEquivalentTo.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.BeEquivalentTo.cs
index 6f4688bdce..60a28858db 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.BeEquivalentTo.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.BeEquivalentTo.cs
@@ -363,11 +363,11 @@ public void When_asserting_collections_not_to_be_equivalent_with_options_but_sub
         public void Default_immutable_array_should_not_be_equivalent_to_initialized_immutable_array()
         {
             // Arrange
-            ImmutableArray<string> collection = default;
-            ImmutableArray<string> collection1 = ImmutableArray.Create("a", "b", "c");
+            ImmutableArray<string> subject = default;
+            ImmutableArray<string> expectation = ImmutableArray.Create("a", "b", "c");
 
             // Act / Assert
-            collection.Should().NotBeEquivalentTo(collection1);
+            subject.Should().NotBeEquivalentTo(expectation);
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.Contain.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.Contain.cs
index 4c95e2abc2..4fb71e62ee 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.Contain.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.Contain.cs
@@ -104,7 +104,8 @@ public void
             Action act = () =>
             {
                 using var _ = new AssertionScope();
-                collection.Should().Contain([4]).And.Contain([5, 6]);
+                collection.Should().Contain([4]);
+                collection.Should().Contain([5, 6]);
             };
 
             // Assert
@@ -186,6 +187,20 @@ public void When_collection_does_contain_an_expected_item_matching_a_predicate_i
                 "Expected*greater*4*2*");
         }
 
+        [Fact]
+        public void Can_chain_another_assertion_on_the_single_result()
+        {
+            // Arrange
+            IEnumerable<int> collection = [1, 2, 3];
+
+            // Act
+            Action act = () => collection.Should().Contain(item => item == 2).Which.Should().BeGreaterThan(4);
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage(
+                "Expected collection[1]*greater*4*2*");
+        }
+
         [Fact]
         public void When_collection_does_contain_an_expected_item_matching_a_predicate_it_should_not_throw()
         {
@@ -395,7 +410,7 @@ public void When_collection_contains_unexpected_items_it_should_throw()
         }
 
         [Fact]
-        public void When_asserting_multiple_collection_in_assertion_scope_all_should_be_reported()
+        public void Assertion_scopes_do_not_affect_chained_calls()
         {
             // Arrange
             int[] collection = [1, 2, 3];
@@ -409,7 +424,7 @@ public void When_asserting_multiple_collection_in_assertion_scope_all_should_be_
 
             // Assert
             act.Should().Throw<XunitException>().WithMessage(
-                "*to not contain {1, 2}*to not contain 3*");
+                "*but found {1, 2}.");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainEquivalentOf.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainEquivalentOf.cs
index 1a07b2b20a..b8f3028b4b 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainEquivalentOf.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainEquivalentOf.cs
@@ -45,6 +45,21 @@ public void When_character_collection_does_contain_equivalent_it_should_succeed(
             collection.Should().ContainEquivalentOf(item);
         }
 
+        [Fact]
+        public void Can_chain_a_successive_assertion_on_the_matching_item()
+        {
+            // Arrange
+            char[] collection = "abc123ab".ToCharArray();
+            char item = 'c';
+
+            // Act
+            var act = () => collection.Should().ContainEquivalentOf(item).Which.Should().Be('C');
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected collection[2] to be equal to C, but found c.");
+        }
+
         [Fact]
         public void When_string_collection_does_contain_same_string_with_other_case_it_should_throw()
         {
@@ -398,17 +413,17 @@ public void When_asserting_collection_to_not_contain_equivalent_it_should_allow_
             // Act
             Action act = () =>
             {
-                using (new AssertionScope())
-                {
-                    collection.Should().NotContainEquivalentOf(another, "because we want to test {0}", "first message")
-                        .And
-                        .HaveCount(4, "because we want to test {0}", "second message");
-                }
+                using var _ = new AssertionScope();
+
+                collection.Should()
+                    .NotContainEquivalentOf(another, "because we want to test {0}", "first message")
+                    .And
+                    .HaveCount(4, "because we want to test {0}", "second message");
             };
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage("Expected collection*not to contain*first message*but*.\n" +
-                "Expected*4 item(s)*because*second message*but*.");
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected collection*not to contain*first message*but found one at index 2.*");
         }
     }
 }
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainInOrder.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainInOrder.cs
index da7dafbc61..0efa455e49 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainInOrder.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainInOrder.cs
@@ -90,7 +90,7 @@ public void When_a_collection_does_not_contain_an_ordered_item_it_should_throw_w
         }
 
         [Fact]
-        public void When_a_collection_does_not_contain_items_with_assertion_scope_all_items_are_reported()
+        public void Even_with_an_assertion_scope_only_the_first_failure_in_a_chained_assertion_is_reported()
         {
             // Act
             Action act = () =>
@@ -100,8 +100,7 @@ public void When_a_collection_does_not_contain_items_with_assertion_scope_all_it
             };
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage(
-                "*but 4 (index 0)*but 5 (index 0)*");
+            act.Should().Throw<XunitException>().WithMessage("*but 4 (index 0) did not appear (in the right order).");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainSingle.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainSingle.cs
index 260662bc6e..15bf529510 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainSingle.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainSingle.cs
@@ -33,11 +33,8 @@ public void When_a_collection_contains_a_single_item_matching_a_predicate_it_sho
         IEnumerable<int> collection = [1, 2, 3];
         Expression<Func<int, bool>> expression = item => item == 2;
 
-        // Act
-        Action act = () => collection.Should().ContainSingle(expression);
-
-        // Assert
-        act.Should().NotThrow();
+        // Act / Assert
+        collection.Should().ContainSingle(expression);
     }
 
     [Fact]
@@ -122,7 +119,27 @@ public void When_single_item_matching_a_predicate_is_found_it_should_allow_conti
         Action act = () => collection.Should().ContainSingle(item => item == 2).Which.Should().BeGreaterThan(4);
 
         // Assert
-        act.Should().Throw<XunitException>().WithMessage("Expected*greater*4*2*");
+        act.Should()
+            .Throw<XunitException>()
+            .WithMessage("Expected collection[0]*greater*4*2*");
+    }
+
+    [Fact]
+    public void Chained_assertions_are_never_called_when_the_initial_assertion_failed()
+    {
+        // Arrange
+        IEnumerable<int> collection = [1, 2, 3];
+
+        // Act
+        Action act = () =>
+        {
+            using var _ = new AssertionScope();
+            collection.Should().ContainSingle(item => item == 4).Which.Should().BeGreaterThan(4);
+        };
+
+        // Assert
+        act.Should().Throw<XunitException>()
+            .WithMessage("Expected collection to contain a single item matching (item == 4), but no such item was found.");
     }
 
     [Fact]
@@ -239,9 +256,8 @@ public void When_single_item_is_found_it_should_allow_continuation()
         Action act = () => collection.Should().ContainSingle().Which.Should().BeGreaterThan(4);
 
         // Assert
-        const string expectedMessage = "Expected collection to be greater than 4, but found 3.";
-
-        act.Should().Throw<XunitException>().WithMessage(expectedMessage);
+        act.Should().Throw<XunitException>()
+            .WithMessage("Expected collection[0] to be greater than 4, but found 3.");
     }
 
     [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveCount.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveCount.cs
index bc0022bbdc..91f58b5fc1 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveCount.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveCount.cs
@@ -62,7 +62,7 @@ public void When_collection_has_a_count_larger_than_the_minimum_it_should_not_th
         }
 
         [Fact]
-        public void When_asserting_a_collection_with_incorrect_predicates_in_assertion_scope_all_are_reported()
+        public void Even_with_an_assertion_scope_only_the_first_failure_in_a_chained_call_is_reported()
         {
             // Arrange
             int[] collection = [1, 2, 3];
@@ -75,8 +75,7 @@ public void When_asserting_a_collection_with_incorrect_predicates_in_assertion_s
             };
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage(
-                "*to have a count (c > 3)*to have a count (c < 3)*");
+            act.Should().Throw<XunitException>().WithMessage("*count (c > 3), but count is 3: {1, 2, 3}.");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveElementAt.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveElementAt.cs
index efad04183c..fa9c3c0a6e 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveElementAt.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.HaveElementAt.cs
@@ -22,6 +22,20 @@ public void When_collection_has_expected_element_at_specific_index_it_should_not
             collection.Should().HaveElementAt(1, 2);
         }
 
+        [Fact]
+        public void Can_chain_another_assertion_on_the_selected_element()
+        {
+            // Arrange
+            int[] collection = [1, 2, 3];
+
+            // Act
+            var act = () => collection.Should().HaveElementAt(index: 1, element: 2).Which.Should().Be(3);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected collection[1] to be 3, but found 2.");
+        }
+
         [Fact]
         public void When_collection_does_not_have_the_expected_element_at_specific_index_it_should_throw()
         {
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.OnlyHaveUniqueItems.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.OnlyHaveUniqueItems.cs
index 6c86ba71c4..b07d84886b 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.OnlyHaveUniqueItems.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.OnlyHaveUniqueItems.cs
@@ -177,7 +177,7 @@ public void When_a_collection_contains_multiple_duplicate_items_with_a_predicate
         }
 
         [Fact]
-        public void When_a_collection_contains_multiple_duplicates_on_different_properties_all_should_be_reported()
+        public void Only_the_first_failing_assertion_in_a_chain_is_reported()
         {
             // Arrange
             IEnumerable<SomeClass> collection =
@@ -198,7 +198,7 @@ public void When_a_collection_contains_multiple_duplicates_on_different_properti
 
             // Assert
             act.Should().Throw<XunitException>().WithMessage(
-                "*have unique items on e.Text*have unique items on e.Number*");
+                "*have unique items on e.Text*");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.cs
index b908e6669c..ee26a1a148 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.cs
@@ -12,8 +12,21 @@ namespace FluentAssertions.Specs.Collections;
 /// </summary>
 public partial class CollectionAssertionSpecs
 {
-    public class Chainings
+    public class Chaining
     {
+        [Fact]
+        public void Chaining_something_should_do_something()
+        {
+            // Act
+            var languages = new[] { "C#" };
+
+            var act = () => languages.Should().ContainSingle()
+                .Which.Should().EndWith("script");
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage("Expected languages[0]*");
+        }
+
         [Fact]
         public void Should_support_chaining_constraints_with_and()
         {
@@ -71,7 +84,7 @@ public void When_the_collection_is_not_ordered_according_to_the_subsequent_ascen
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected collection * to be ordered \"by Item2\"*");
+                .WithMessage("Expected collection*to be ordered \"by Item2\"*");
         }
 
         [Fact]
@@ -163,7 +176,7 @@ public void When_the_collection_is_not_ordered_according_to_the_subsequent_desce
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected collection * to be ordered \"by Item2\"*");
+                .WithMessage("Expected collection*to be ordered \"by Item2\"*");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Collections/GenericCollectionAssertionOfStringSpecs.ContainMatch.cs b/Tests/FluentAssertions.Specs/Collections/GenericCollectionAssertionOfStringSpecs.ContainMatch.cs
index d274fe904f..6901a1e685 100644
--- a/Tests/FluentAssertions.Specs/Collections/GenericCollectionAssertionOfStringSpecs.ContainMatch.cs
+++ b/Tests/FluentAssertions.Specs/Collections/GenericCollectionAssertionOfStringSpecs.ContainMatch.cs
@@ -37,7 +37,21 @@ public void When_collection_contains_multiple_matches_it_should_not_throw()
         }
 
         [Fact]
-        public void When_collection_contains_multiple_matches_which_should_throw()
+        public void Can_chain_another_assertion_if_a_single_string_matches_the_pattern()
+        {
+            // Arrange
+            IEnumerable<string> collection = ["build succeeded", "test succeeded", "pack failed"];
+
+            // Act
+            Action action = () => collection.Should().ContainMatch("*failed*").Which.Should().StartWith("test");
+
+            // Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage("Expected collection[2] to start with*test*pack failed*");
+        }
+
+        [Fact]
+        public void Cannot_chain_another_assertion_if_multiple_strings_match_the_pattern()
         {
             // Arrange
             IEnumerable<string> collection = ["build succeded", "test failed", "pack failed"];
diff --git a/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValue.cs b/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValue.cs
index 639b329436..3cfd9ab9d9 100644
--- a/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValue.cs
+++ b/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValue.cs
@@ -27,6 +27,23 @@ public void When_dictionary_contains_expected_value_it_should_succeed()
             act.Should().NotThrow();
         }
 
+        [Fact]
+        public void Can_continue_asserting_on_a_single_matching_item()
+        {
+            // Arrange
+            var dictionary = new Dictionary<int, string>
+            {
+                [1] = "One",
+                [2] = "Two"
+            };
+
+            // Act
+            Action act = () => dictionary.Should().ContainValue("One").Which.Should().Be("Two");
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage("*Expected dictionary[1] to be*Two*, but*One*differs*");
+        }
+
         [Fact]
         public void Null_dictionaries_do_not_contain_any_values()
         {
@@ -82,30 +99,6 @@ public void When_the_specified_value_exists_it_should_allow_continuation_using_t
             act.Should().Throw<XunitException>().WithMessage("Expected*greater*0*0*");
         }
 
-        [Fact]
-        public void When_multiple_matches_for_the_specified_value_exist_continuation_using_the_matched_value_should_fail()
-        {
-            // Arrange
-            var myClass = new MyClass { SomeProperty = 0 };
-
-            var dictionary = new Dictionary<int, MyClass>
-            {
-                [1] = myClass,
-                [2] = new() { SomeProperty = 0 }
-            };
-
-            // Act
-            Action act =
-                () =>
-                    dictionary.Should()
-                        .ContainValue(new MyClass { SomeProperty = 0 })
-                        .Which.Should()
-                        .BeSameAs(myClass);
-
-            // Assert
-            act.Should().Throw<XunitException>();
-        }
-
         [Fact]
         public void When_a_dictionary_does_not_contain_single_value_it_should_throw_with_clear_explanation()
         {
diff --git a/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValues.cs b/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValues.cs
index ec0247fb4d..07f898177b 100644
--- a/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValues.cs
+++ b/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.ContainValues.cs
@@ -42,7 +42,7 @@ public void When_a_dictionary_does_not_contain_a_number_of_values_it_should_thro
 
             // Assert
             act.Should().Throw<XunitException>().WithMessage(
-                "Expected dictionary {[1] = \"One\", [2] = \"Two\"} to contain value {\"Two\", \"Three\"} because we do, but could not find {\"Three\"}.");
+                "Expected dictionary {[1] = \"One\", [2] = \"Two\"} to contain values {\"Two\", \"Three\"} because we do, but could not find \"Three\".");
         }
 
         [Fact]
@@ -65,6 +65,23 @@ public void
         }
     }
 
+    [Fact]
+    public void Can_run_another_assertion_on_the_result()
+    {
+        // Arrange
+        var dictionary = new Dictionary<int, string>
+        {
+            [1] = "One",
+            [2] = "Two"
+        };
+
+        // Act
+        Action act = () => dictionary.Should().ContainValues("Two", "One").Which.Should().Contain("Three");
+
+        // Assert
+        act.Should().Throw<XunitException>().WithMessage("Expected dictionary[1 and 2]*to contain*Three*");
+    }
+
     public class NotContainValues
     {
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Exceptions/FunctionExceptionAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Exceptions/FunctionExceptionAssertionSpecs.cs
index 9933c52a5c..69d8e077c3 100644
--- a/Tests/FluentAssertions.Specs/Exceptions/FunctionExceptionAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Exceptions/FunctionExceptionAssertionSpecs.cs
@@ -435,29 +435,6 @@ public void
             .WithMessage("*no*exception*that's what he told me*but*ArgumentNullException*");
     }
 
-    [Fact]
-    public void When_an_assertion_fails_on_NotThrow_succeeding_message_should_be_included()
-    {
-        // Arrange
-        Func<int> throwingFunction = () => throw new Exception();
-
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            throwingFunction.Should().NotThrow()
-                .And.BeNull();
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage(
-                "*Did not expect any exception*" +
-                "*to be <null>*"
-            );
-    }
-
     #endregion
 
     #region NotThrowAfter
@@ -594,10 +571,10 @@ public void When_no_exception_should_be_thrown_after_wait_time_the_func_result_s
 
         // Act
         Action act = () => throwShorterThanWaitTime.Should(clock).NotThrowAfter(waitTime, pollInterval)
-            .Which.Should().Be(42);
+            .Which.Should().Be(43);
 
         // Assert
-        act.Should().NotThrow();
+        act.Should().Throw<XunitException>().WithMessage("Expected throwShorterThanWaitTime.Result to be 43*");
     }
 
     [Fact]
@@ -619,10 +596,7 @@ public void When_an_assertion_fails_on_NotThrowAfter_succeeding_message_should_b
 
         // Assert
         act.Should().Throw<XunitException>()
-            .WithMessage(
-                "*Did not expect any exceptions after*" +
-                "*to be <null>*"
-            );
+            .WithMessage("*Did not expect any exceptions after*");
     }
 
     #endregion
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionChainSpecs.Chaining.cs b/Tests/FluentAssertions.Specs/Execution/AssertionChainSpecs.Chaining.cs
new file mode 100644
index 0000000000..11e959587d
--- /dev/null
+++ b/Tests/FluentAssertions.Specs/Execution/AssertionChainSpecs.Chaining.cs
@@ -0,0 +1,599 @@
+using System;
+using FluentAssertions.Execution;
+using Xunit;
+using Xunit.Sdk;
+
+namespace FluentAssertions.Specs.Execution;
+
+/// <content>
+/// The chaining API specs.
+/// </content>
+public partial class AssertionChainSpecs
+{
+    public class Chaining
+    {
+        [Fact]
+        public void A_successful_assertion_does_not_affect_the_chained_failing_assertion()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(condition: true)
+                .FailWith("First assertion")
+                .Then
+                .FailWith("Second assertion");
+
+            // Arrange
+            act.Should().Throw<XunitException>().WithMessage("*Second assertion*");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one_with_arguments()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(true)
+                .FailWith("First assertion")
+                .Then
+                .FailWith("Second {0}", "assertion");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Second \"assertion\"");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one_with_argument_providers()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(true)
+                .FailWith("First assertion")
+                .Then
+                .FailWith("Second {0}", () => "assertion");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Second \"assertion\"");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one_with_a_fail_reason_function()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(true)
+                .FailWith("First assertion")
+                .Then
+                .FailWith(() => new FailReason("Second {0}", "assertion"));
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Second \"assertion\"");
+        }
+
+        [Fact]
+        public void When_continuing_an_assertion_chain_the_reason_should_be_part_of_consecutive_failures()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(true)
+                .FailWith("First assertion")
+                .Then
+                .BecauseOf("because reasons")
+                .FailWith("Expected{reason}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected because reasons");
+        }
+
+        [Fact]
+        public void When_continuing_an_assertion_chain_the_reason_with_arguments_should_be_part_of_consecutive_failures()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(true)
+                .FailWith("First assertion")
+                .Then
+                .BecauseOf("because {0}", "reasons")
+                .FailWith("Expected{reason}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected because reasons");
+        }
+
+        [Fact]
+        public void Passing_a_null_value_as_reason_does_not_fail()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .BecauseOf(null, "only because for method disambiguity")
+                .ForCondition(false)
+                .FailWith("First assertion");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("First assertion");
+        }
+
+        [Fact]
+        public void When_a_given_is_used_before_an_assertion_then_the_result_should_be_available_for_evaluation()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .Given(() => new[] { "a", "b" })
+                .ForCondition(collection => collection.Length > 0)
+                .FailWith("First assertion");
+
+            // Assert
+            act.Should().NotThrow();
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_evaluate_the_succeeding_given_statement()
+        {
+            // Arrange
+            using var _ = new AssertionScope(new IgnoringFailuresAssertionStrategy());
+
+            // Act / Assert
+            AssertionChain.GetOrCreate()
+                .ForCondition(false)
+                .FailWith("First assertion")
+                .Then
+                .Given<object>(() => throw new InvalidOperationException());
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_evaluate_the_succeeding_condition()
+        {
+            // Arrange
+            bool secondConditionEvaluated = false;
+
+            try
+            {
+                using var _ = new AssertionScope();
+
+                // Act
+                AssertionChain.GetOrCreate()
+                    .Given(() => (string)null)
+                    .ForCondition(s => s is not null)
+                    .FailWith("but is was null")
+                    .Then
+                    .ForCondition(_ => secondConditionEvaluated = true)
+                    .FailWith("it should be 42");
+            }
+            catch
+            {
+                // Ignore
+            }
+
+            // Assert
+            secondConditionEvaluated.Should().BeFalse("because the 2nd condition should not be invoked");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure()
+        {
+            // Arrange
+            var scope = new AssertionScope();
+
+            // Act
+            AssertionChain.GetOrCreate()
+                .ForCondition(false)
+                .FailWith("First assertion")
+                .Then
+                .ForCondition(false)
+                .FailWith("Second assertion");
+
+            string[] failures = scope.Discard();
+            scope.Dispose();
+
+            Assert.Single(failures);
+            Assert.Contains("First assertion", failures);
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure_with_arguments()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .ForCondition(false)
+                    .FailWith("First assertion")
+                    .Then
+                    .FailWith("Second {0}", "assertion");
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("First assertion");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure_with_argument_providers()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .ForCondition(false)
+                    .FailWith("First assertion")
+                    .Then
+                    .FailWith("Second {0}", () => "assertion");
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("First assertion");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure_with_a_fail_reason_function()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .ForCondition(false)
+                    .FailWith("First assertion")
+                    .Then
+                    .FailWith(() => new FailReason("Second {0}", "assertion"));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("First assertion");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_expectation()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var scope = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .WithExpectation("Expectations are the root ", c => c
+                        .ForCondition(false)
+                        .FailWith("of disappointment")
+                        .Then
+                        .WithExpectation("Assumptions are the root ", c2 => c2
+                            .FailWith("of all evil")));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expectations are the root of disappointment");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_expectation_with_arguments()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var scope = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .WithExpectation("Expectations are the {0} ", "root", c => c
+                        .ForCondition(false)
+                        .FailWith("of disappointment")
+                        .Then
+                        .WithExpectation("Assumptions are the {0} ", "root", c2 => c2
+                            .FailWith("of all evil")));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expectations are the \"root\" of disappointment");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_default_identifier()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .WithDefaultIdentifier("identifier")
+                    .ForCondition(false)
+                    .FailWith("Expected {context}")
+                    .Then
+                    .WithDefaultIdentifier("other")
+                    .FailWith("Expected {context}");
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected identifier");
+        }
+
+        [Fact]
+        public void When_continuing_a_failed_assertion_chain_consecutive_reasons_are_ignored()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .BecauseOf("because {0}", "whatever")
+                    .ForCondition(false)
+                    .FailWith("Expected{reason}")
+                    .Then
+                    .BecauseOf("because reasons")
+                    .FailWith("Expected{reason}");
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected because whatever");
+        }
+
+        [Fact]
+        public void When_continuing_a_failed_assertion_chain_consecutive_reasons_with_arguments_are_ignored()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+
+                AssertionChain.GetOrCreate()
+                    .BecauseOf("because {0}", "whatever")
+                    .ForCondition(false)
+                    .FailWith("Expected{reason}")
+                    .Then
+                    .BecauseOf("because {0}", "reasons")
+                    .FailWith("Expected{reason}");
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected because whatever");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_evaluate_the_succeeding_given_statement()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(true)
+                .FailWith("First assertion")
+                .Then
+                .Given<object>(() => throw new InvalidOperationException());
+
+            // Assert
+            act.Should().Throw<InvalidOperationException>();
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_not_affect_the_succeeding_expectation()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .WithExpectation("Expectations are the root ", chain => chain
+                        .ForCondition(true)
+                        .FailWith("of disappointment")
+                        .Then
+                        .WithExpectation("Assumptions are the root ", innerChain => innerChain
+                            .FailWith("of all evil")));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Assumptions are the root of all evil");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_not_affect_the_succeeding_expectation_with_arguments()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .WithExpectation("Expectations are the {0} ", "root", c => c
+                        .ForCondition(true)
+                        .FailWith("of disappointment")
+                        .Then
+                        .WithExpectation("Assumptions are the {0} ", "root", c2 => c2
+                            .FailWith("of all evil")));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Assumptions are the \"root\" of all evil");
+        }
+
+        [Fact]
+        public void When_the_previous_assertion_succeeded_it_should_not_affect_the_succeeding_default_identifier()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .WithDefaultIdentifier("identifier")
+                    .ForCondition(true)
+                    .FailWith("Expected {context}")
+                    .Then
+                    .WithDefaultIdentifier("other")
+                    .FailWith("Expected {context}");
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected other");
+        }
+
+        [Fact]
+        public void Continuing_an_assertion_with_occurrence()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .ForCondition(true)
+                    .FailWith("First assertion")
+                    .Then
+                    .WithExpectation("{expectedOccurrence} ", c => c
+                        .ForConstraint(Exactly.Once(), 2)
+                        .FailWith("Second {0}", "assertion"));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Exactly 1 time Second \"assertion\"*");
+        }
+
+        [Fact]
+        public void Continuing_an_assertion_with_occurrence_will_not_be_executed_when_first_assertion_fails()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .ForCondition(false)
+                    .FailWith("First assertion")
+                    .Then
+                    .WithExpectation("{expectedOccurrence} ", c => c
+                        .ForConstraint(Exactly.Once(), 2)
+                        .FailWith("Second {0}", "assertion"));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("First assertion");
+        }
+
+        [Fact]
+        public void Continuing_an_assertion_with_occurrence_overrides_the_previous_defined_expectations()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .WithExpectation("First expectation", c => c
+                        .ForCondition(true)
+                        .FailWith("First assertion")
+                        .Then
+                        .WithExpectation("{expectedOccurrence} ", c2 => c2
+                            .ForConstraint(Exactly.Once(), 2)
+                            .FailWith("Second {0}", "assertion")));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Exactly 1 time Second \"assertion\"*");
+        }
+
+        [Fact]
+        public void Continuing_an_assertion_after_occurrence_check_works()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .WithExpectation("{expectedOccurrence} ", c => c
+                        .ForConstraint(Exactly.Once(), 1)
+                        .FailWith("First assertion")
+                        .Then
+                        .WithExpectation("Second expectation ", c2 => c2
+                            .ForCondition(false)
+                            .FailWith("Second {0}", "assertion")));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Second expectation Second \"assertion\"*");
+        }
+
+        [Fact]
+        public void Continuing_an_assertion_with_occurrence_check_before_defining_expectation_works()
+        {
+            // Act
+            Action act = () =>
+            {
+                AssertionChain.GetOrCreate()
+                    .ForCondition(true)
+                    .FailWith("First assertion")
+                    .Then
+                    .ForConstraint(Exactly.Once(), 2)
+                    .WithExpectation("Second expectation ", c => c
+                        .FailWith("Second {0}", "assertion"));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Second expectation Second \"assertion\"*");
+        }
+
+        [Fact]
+        public void Does_not_continue_a_chained_assertion_after_the_first_one_failed_the_occurrence_check()
+        {
+            // Arrange
+            var scope = new AssertionScope();
+
+            // Act
+            AssertionChain.GetOrCreate()
+                .ForConstraint(Exactly.Once(), 2)
+                .FailWith("First {0}", "assertion")
+                .Then
+                .ForConstraint(Exactly.Once(), 2)
+                .FailWith("Second {0}", "assertion");
+
+            string[] failures = scope.Discard();
+
+            // Assert
+            Assert.Single(failures);
+            Assert.Contains("First \"assertion\"", failures);
+        }
+
+        [Fact]
+        public void Discard_a_scope_after_continuing_chained_assertion()
+        {
+            // Arrange
+            using var scope = new AssertionScope();
+
+            // Act
+            AssertionChain.GetOrCreate()
+                .ForConstraint(Exactly.Once(), 2)
+                .FailWith("First {0}", "assertion");
+
+            var failures = scope.Discard();
+
+            // Assert
+            Assert.Single(failures);
+            Assert.Contains("First \"assertion\"", failures);
+        }
+
+        // [Fact]
+        // public void Get_info_about_line_breaks_from_parent_scope_after_continuing_chained_assertion()
+        // {
+        //     // Arrange
+        //     using var scope = new AssertionScope();
+        //     scope.FormattingOptions.UseLineBreaks = true;
+        //
+        //     // Act
+        //     var innerScope = AssertionChain.GetOrCreate()
+        //         .ForConstraint(Exactly.Once(), 1)
+        //         .FailWith("First {0}", "assertion")
+        //         .Then
+        //         .UsingLineBreaks;
+        //
+        //     // Assert
+        //     innerScope.UsingLineBreaks.Should().Be(scope.UsingLineBreaks);
+        // }
+    }
+}
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionChainSpecs.MessageFormating.cs b/Tests/FluentAssertions.Specs/Execution/AssertionChainSpecs.MessageFormating.cs
new file mode 100644
index 0000000000..63fc8e684e
--- /dev/null
+++ b/Tests/FluentAssertions.Specs/Execution/AssertionChainSpecs.MessageFormating.cs
@@ -0,0 +1,390 @@
+using System;
+using System.Collections.Generic;
+using FluentAssertions.Execution;
+using Xunit;
+using Xunit.Sdk;
+
+namespace FluentAssertions.Specs.Execution;
+
+/// <content>
+/// The message formatting specs.
+/// </content>
+public partial class AssertionChainSpecs
+{
+    public class MessageFormatting
+    {
+        [Fact]
+        public void Multiple_assertions_in_an_assertion_scope_are_all_reported()
+        {
+            // Arrange
+            var scope = new AssertionScope();
+
+            AssertionChain.GetOrCreate().FailWith("Failure");
+            AssertionChain.GetOrCreate().FailWith("Failure");
+
+            using (new AssertionScope())
+            {
+                AssertionChain.GetOrCreate().FailWith("Failure");
+                AssertionChain.GetOrCreate().FailWith("Failure");
+            }
+
+            // Act
+            Action act = scope.Dispose;
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .Which.Message.Should().Contain("Failure", Exactly.Times(4));
+        }
+
+        [InlineData("foo")]
+        [InlineData("{}")]
+        [Theory]
+        public void The_failure_message_uses_the_name_of_the_scope_as_context(string context)
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope(context);
+                new[] { 1, 2, 3 }.Should().Equal(3, 2, 1);
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage($"Expected {context} to be equal to*");
+        }
+
+        [Fact]
+        public void The_failure_message_uses_the_lazy_name_of_the_scope_as_context()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope(() => "lazy foo");
+                new[] { 1, 2, 3 }.Should().Equal(3, 2, 1);
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected lazy foo to be equal to*");
+        }
+
+        [Fact]
+        public void The_failure_message_includes_all_failures()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+                var values = new Dictionary<int, int>();
+                values.Should().ContainKey(0);
+                values.Should().ContainKey(1);
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected * to contain key 0.\nExpected * to contain key 1.\n");
+        }
+
+        [Fact]
+        public void The_failure_message_includes_all_failures_as_well()
+        {
+            // Act
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+                var values = new List<int>();
+                values.Should().ContainSingle();
+                values.Should().ContainSingle();
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected * to contain a single item, but the collection is empty.\n" +
+                    "Expected * to contain a single item, but the collection is empty.\n");
+        }
+
+        [Fact]
+        public void The_reason_can_contain_parentheses()
+        {
+            // Act
+            Action act = () => 1.Should().Be(2, "can't use these in becauseArgs: {0} {1}", "{", "}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("*because can't use these in becauseArgs: { }*");
+        }
+
+        [Fact]
+        public void Because_reason_should_ignore_undefined_arguments()
+        {
+            // Act
+            object[] becauseArgs = null;
+            Action act = () => 1.Should().Be(2, "it should still work", becauseArgs);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("*because it should still work*");
+        }
+
+        [Fact]
+        public void Because_reason_should_threat_parentheses_as_literals_if_no_arguments_are_defined()
+        {
+            // Act
+#pragma warning disable CA2241
+            // ReSharper disable once FormatStringProblem
+            Action act = () => 1.Should().Be(2, "use of {} is okay if there are no because arguments");
+#pragma warning restore CA2241
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("*because use of {} is okay if there are no because arguments*");
+        }
+
+        [Fact]
+        public void Because_reason_should_inform_about_invalid_parentheses_with_a_default_message()
+        {
+            // Act
+#pragma warning disable CA2241
+            // ReSharper disable once FormatStringProblem
+            Action act = () => 1.Should().Be(2, "use of {} is considered invalid in because parameter with becauseArgs",
+                "additional becauseArgs argument");
+#pragma warning restore CA2241
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage(
+                    "*because message 'use of {} is considered invalid in because parameter with becauseArgs' could not be formatted with string.Format*");
+        }
+
+        [Fact]
+        public void Message_should_keep_parentheses_in_literal_values()
+        {
+            // Act
+            Action act = () => "{foo}".Should().Be("{bar}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected string to be \"{bar}\", but \"{foo}\" differs near*");
+        }
+
+        [Fact]
+        public void Message_should_contain_literal_value_if_marked_with_double_parentheses()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate().FailWith("{{empty}}");
+
+            // Assert
+            act.Should().ThrowExactly<XunitException>()
+                .WithMessage("{empty}*");
+        }
+
+        [InlineData("\r")]
+        [InlineData("\\r")]
+        [InlineData("\\\r")]
+        [InlineData("\\\\r")]
+        [InlineData("\\\\\r")]
+        [InlineData("\n")]
+        [InlineData("\\n")]
+        [InlineData("\\\n")]
+        [InlineData("\\\\n")]
+        [InlineData("\\\\\n")]
+        [Theory]
+        public void Message_should_not_have_modified_carriage_return_or_line_feed_control_characters(string str)
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate().FailWith(str);
+
+            // Assert
+            act.Should().ThrowExactly<XunitException>()
+                .WithMessage(str);
+        }
+
+        [InlineData("\r")]
+        [InlineData("\\r")]
+        [InlineData("\\\r")]
+        [InlineData(@"\\r")]
+        [InlineData("\\\\\r")]
+        [InlineData("\n")]
+        [InlineData("\\n")]
+        [InlineData("\\\n")]
+        [InlineData(@"\\n")]
+        [InlineData("\\\\\n")]
+        [Theory]
+        public void Message_should_not_have_modified_carriage_return_or_line_feed_control_characters_in_supplied_arguments(
+            string str)
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate().FailWith(@"\{0}\A", str);
+
+            // Assert
+            act.Should().ThrowExactly<XunitException>()
+                .WithMessage("\\\"" + str + "\"\\A*");
+        }
+
+        [Fact]
+        public void Message_should_not_have_trailing_backslashes_removed_from_subject()
+        {
+            // Arrange / Act
+            Action act = () => "A\\".Should().Be("A");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("""* near "\" *""");
+        }
+
+        [Fact]
+        public void Message_should_not_have_trailing_backslashes_removed_from_expectation()
+        {
+            // Arrange / Act
+            Action act = () => "A".Should().Be("A\\");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("""* to be "A\" *""");
+        }
+
+        [Fact]
+        public void Message_should_have_reportable_values_appended_at_the_end()
+        {
+            // Arrange
+            var scope = new AssertionScope();
+            scope.AddReportable("SomeKey", "SomeValue");
+            scope.AddReportable("AnotherKey", "AnotherValue");
+
+            AssertionChain.GetOrCreate().FailWith("{SomeKey}{AnotherKey}");
+
+            // Act
+            Action act = scope.Dispose;
+
+            // Assert
+            act.Should().ThrowExactly<XunitException>()
+                .WithMessage("*With SomeKey:\nSomeValue\nWith AnotherKey:\nAnotherValue");
+        }
+
+        [Fact]
+        public void Deferred_reportable_values_should_not_be_calculated_in_absence_of_failures()
+        {
+            // Arrange
+            var scope = new AssertionScope();
+            var deferredValueInvoked = false;
+
+            scope.AddReportable("MyKey", () =>
+            {
+                deferredValueInvoked = true;
+
+                return "MyValue";
+            });
+
+            // Act
+            scope.Dispose();
+
+            // Assert
+            deferredValueInvoked.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Message_should_start_with_the_defined_expectation()
+        {
+            // Act
+            Action act = () =>
+            {
+                var assertion = AssertionChain.GetOrCreate();
+
+                assertion
+                    .WithExpectation("Expectations are the root ", chain => chain
+                        .ForCondition(false)
+                        .FailWith("of disappointment"));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expectations are the root of disappointment");
+        }
+
+        [Fact]
+        public void Message_should_start_with_the_defined_expectation_and_arguments()
+        {
+            // Act
+            Action act = () =>
+            {
+                var assertion = AssertionChain.GetOrCreate();
+
+                assertion
+                    .WithExpectation("Expectations are the {0} ", "root", chain => chain.ForCondition(false)
+                        .FailWith("of disappointment"));
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expectations are the \"root\" of disappointment");
+        }
+
+        [Fact]
+        public void Message_should_contain_object_as_context_if_identifier_can_not_be_resolved()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(false)
+                .FailWith("Expected {context}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected object");
+        }
+
+        [Fact]
+        public void Message_should_contain_the_fallback_value_as_context_if_identifier_can_not_be_resolved()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .ForCondition(false)
+                .FailWith("Expected {context:fallback}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected fallback");
+        }
+
+        [Fact]
+        public void Message_should_contain_the_default_identifier_as_context_if_identifier_can_not_be_resolved()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .WithDefaultIdentifier("identifier")
+                .ForCondition(false)
+                .FailWith("Expected {context}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected identifier");
+        }
+
+        [Fact]
+        public void Message_should_contain_the_reason_as_defined()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .BecauseOf("because reasons")
+                .FailWith("Expected{reason}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected because reasons");
+        }
+
+        [Fact]
+        public void Message_should_contain_the_reason_as_defined_with_arguments()
+        {
+            // Act
+            Action act = () => AssertionChain.GetOrCreate()
+                .BecauseOf("because {0}", "reasons")
+                .FailWith("Expected{reason}");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected because reasons");
+        }
+    }
+}
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionScope.ChainingApiSpecs.cs b/Tests/FluentAssertions.Specs/Execution/AssertionScope.ChainingApiSpecs.cs
deleted file mode 100644
index 11f21eae89..0000000000
--- a/Tests/FluentAssertions.Specs/Execution/AssertionScope.ChainingApiSpecs.cs
+++ /dev/null
@@ -1,588 +0,0 @@
-using System;
-using FluentAssertions.Execution;
-using Xunit;
-using Xunit.Sdk;
-
-namespace FluentAssertions.Specs.Execution;
-
-/// <content>
-/// The chaining API specs.
-/// </content>
-public partial class AssertionScopeSpecs
-{
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one()
-    {
-        bool succeeded = false;
-
-        // Act
-        try
-        {
-            Execute.Assertion
-                .ForCondition(condition: true)
-                .FailWith("First assertion")
-                .Then
-                .FailWith("Second assertion");
-        }
-        catch (Exception e)
-        {
-            // Assert
-            succeeded = e is XunitException xUnitException && xUnitException.Message.Contains("Second");
-        }
-
-        if (!succeeded)
-        {
-            throw new XunitException("Expected the second assertion to fail");
-        }
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one_with_arguments()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .FailWith("Second {0}", "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Second \"assertion\"");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one_with_argument_providers()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .FailWith("Second {0}", () => "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Second \"assertion\"");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_next_one_with_a_fail_reason_function()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .FailWith(() => new FailReason("Second {0}", "assertion"));
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Second \"assertion\"");
-    }
-
-    [Fact]
-    public void When_continuing_an_assertion_chain_the_reason_should_be_part_of_consecutive_failures()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .BecauseOf("because reasons")
-            .FailWith("Expected{reason}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected because reasons");
-    }
-
-    [Fact]
-    public void When_continuing_an_assertion_chain_the_reason_with_arguments_should_be_part_of_consecutive_failures()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .BecauseOf("because {0}", "reasons")
-            .FailWith("Expected{reason}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected because reasons");
-    }
-
-    [Fact]
-    public void Passing_a_null_value_as_reason_does_not_fail()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .BecauseOf(null, "only because for method disambiguity")
-            .ForCondition(false)
-            .FailWith("First assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("First assertion");
-    }
-
-    [Fact]
-    public void When_a_given_is_used_before_an_assertion_then_the_result_should_be_available_for_evaluation()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .Given(() => new[] { "a", "b" })
-            .ForCondition(collection => collection.Length > 0)
-            .FailWith("First assertion");
-
-        // Assert
-        act.Should().NotThrow();
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_evaluate_the_succeeding_given_statement()
-    {
-        // Arrange
-        using var _ = new AssertionScope(new IgnoringFailuresAssertionStrategy());
-
-        // Act / Assert
-        Execute.Assertion
-            .ForCondition(false)
-            .FailWith("First assertion")
-            .Then
-            .Given<object>(() => throw new InvalidOperationException());
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_evaluate_the_succeeding_condition()
-    {
-        // Arrange
-        bool secondConditionEvaluated = false;
-
-        try
-        {
-            using var _ = new AssertionScope();
-
-            // Act
-            Execute.Assertion
-                .Given(() => (string)null)
-                .ForCondition(s => s is not null)
-                .FailWith("but is was null")
-                .Then
-                .ForCondition(_ => secondConditionEvaluated = true)
-                .FailWith("it should be 42");
-        }
-        catch
-        {
-            // Ignore
-        }
-
-        // Assert
-        secondConditionEvaluated.Should().BeFalse("because the 2nd condition should not be invoked");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        // Act
-        Execute.Assertion
-            .ForCondition(false)
-            .FailWith("First assertion")
-            .Then
-            .ForCondition(false)
-            .FailWith("Second assertion");
-
-        string[] failures = scope.Discard();
-        scope.Dispose();
-
-        Assert.Single(failures);
-        Assert.Contains("First assertion", failures);
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure_with_arguments()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .ForCondition(false)
-                .FailWith("First assertion")
-                .Then
-                .FailWith("Second {0}", "assertion");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("First assertion");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure_with_argument_providers()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .ForCondition(false)
-                .FailWith("First assertion")
-                .Then
-                .FailWith("Second {0}", () => "assertion");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("First assertion");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_failure_with_a_fail_reason_function()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .ForCondition(false)
-                .FailWith("First assertion")
-                .Then
-                .FailWith(() => new FailReason("Second {0}", "assertion"));
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("First assertion");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_expectation()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .WithExpectation("Expectations are the root ")
-                .ForCondition(false)
-                .FailWith("of disappointment")
-                .Then
-                .WithExpectation("Assumptions are the root ")
-                .FailWith("of all evil");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expectations are the root of disappointment");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_expectation_with_arguments()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .WithExpectation("Expectations are the {0} ", "root")
-                .ForCondition(false)
-                .FailWith("of disappointment")
-                .Then
-                .WithExpectation("Assumptions are the {0} ", "root")
-                .FailWith("of all evil");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expectations are the \"root\" of disappointment");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_failed_it_should_not_execute_the_succeeding_default_identifier()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .WithDefaultIdentifier("identifier")
-                .ForCondition(false)
-                .FailWith("Expected {context}")
-                .Then
-                .WithDefaultIdentifier("other")
-                .FailWith("Expected {context}");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected identifier");
-    }
-
-    [Fact]
-    public void When_continuing_a_failed_assertion_chain_consecutive_resons_are_ignored()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .BecauseOf("because {0}", "whatever")
-                .ForCondition(false)
-                .FailWith("Expected{reason}")
-                .Then
-                .BecauseOf("because reasons")
-                .FailWith("Expected{reason}");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected because whatever");
-    }
-
-    [Fact]
-    public void When_continuing_a_failed_assertion_chain_consecutive_resons_with_arguments_are_ignored()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-
-            Execute.Assertion
-                .BecauseOf("because {0}", "whatever")
-                .ForCondition(false)
-                .FailWith("Expected{reason}")
-                .Then
-                .BecauseOf("because {0}", "reasons")
-                .FailWith("Expected{reason}");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected because whatever");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_evaluate_the_succeeding_given_statement()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .Given<object>(() => throw new InvalidOperationException());
-
-        // Assert
-        Assert.Throws<InvalidOperationException>(act);
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_succeeding_expectation()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("Expectations are the root ")
-            .ForCondition(true)
-            .FailWith("of disappointment")
-            .Then
-            .WithExpectation("Assumptions are the root ")
-            .FailWith("of all evil");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Assumptions are the root of all evil");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_succeeding_expectation_with_arguments()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("Expectations are the {0} ", "root")
-            .ForCondition(true)
-            .FailWith("of disappointment")
-            .Then
-            .WithExpectation("Assumptions are the {0} ", "root")
-            .FailWith("of all evil");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Assumptions are the \"root\" of all evil");
-    }
-
-    [Fact]
-    public void When_the_previous_assertion_succeeded_it_should_not_affect_the_succeeding_default_identifier()
-    {
-        // Act
-        Action act = () =>
-        {
-            Execute.Assertion
-                .WithDefaultIdentifier("identifier")
-                .ForCondition(true)
-                .FailWith("Expected {context}")
-                .Then
-                .WithDefaultIdentifier("other")
-                .FailWith("Expected {context}");
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected other");
-    }
-
-    [Fact]
-    public void Continuing_an_assertion_with_occurrence()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .WithExpectation("{expectedOccurrence} ")
-            .ForConstraint(Exactly.Once(), 2)
-            .FailWith("Second {0}", "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Exactly 1 time Second \"assertion\"*");
-    }
-
-    [Fact]
-    public void Continuing_an_assertion_with_occurrence_will_not_be_executed_when_first_assertion_fails()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(false)
-            .FailWith("First assertion")
-            .Then
-            .WithExpectation("{expectedOccurrence} ")
-            .ForConstraint(Exactly.Once(), 2)
-            .FailWith("Second {0}", "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("First assertion");
-    }
-
-    [Fact]
-    public void Continuing_an_assertion_with_occurrence_overrides_the_previous_defined_expectations()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("First expectation")
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .WithExpectation("{expectedOccurrence} ")
-            .ForConstraint(Exactly.Once(), 2)
-            .FailWith("Second {0}", "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Exactly 1 time Second \"assertion\"*");
-    }
-
-    [Fact]
-    public void Continuing_an_assertion_after_occurrence_check_works()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("{expectedOccurrence} ")
-            .ForConstraint(Exactly.Once(), 1)
-            .FailWith("First assertion")
-            .Then
-            .WithExpectation("Second expectation ")
-            .ForCondition(false)
-            .FailWith("Second {0}", "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Second expectation Second \"assertion\"*");
-    }
-
-    [Fact]
-    public void Continuing_an_assertion_with_occurrence_check_before_defining_expectation_works()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(true)
-            .FailWith("First assertion")
-            .Then
-            .ForConstraint(Exactly.Once(), 2)
-            .WithExpectation("Second expectation ")
-            .FailWith("Second {0}", "assertion");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Second expectation Second \"assertion\"*");
-    }
-
-    [Fact]
-    public void Does_not_continue_a_chained_assertion_after_the_first_one_failed_the_occurrence_check()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        // Act
-        Execute.Assertion
-            .ForConstraint(Exactly.Once(), 2)
-            .FailWith("First {0}", "assertion")
-            .Then
-            .ForConstraint(Exactly.Once(), 2)
-            .FailWith("Second {0}", "assertion");
-
-        string[] failures = scope.Discard();
-        scope.Dispose();
-
-        // Assert
-        Assert.Single(failures);
-        Assert.Contains("First \"assertion\"", failures);
-    }
-
-    [Fact]
-    public void Discard_a_scope_after_continuing_chained_assertion()
-    {
-        // Arrange
-        using var scope = new AssertionScope();
-
-        // Act
-        var failures = Execute.Assertion
-            .ForConstraint(Exactly.Once(), 2)
-            .FailWith("First {0}", "assertion")
-            .Then
-            .Discard();
-
-        // Assert
-        Assert.Single(failures);
-        Assert.Contains("First \"assertion\"", failures);
-    }
-
-    [Fact]
-    public void Get_info_about_line_breaks_from_parent_scope_after_continuing_chained_assertion()
-    {
-        // Arrange
-        using var scope = new AssertionScope();
-        scope.FormattingOptions.UseLineBreaks = true;
-
-        // Act
-        var innerScope = Execute.Assertion
-            .ForConstraint(Exactly.Once(), 1)
-            .FailWith("First {0}", "assertion")
-            .Then
-            .UsingLineBreaks;
-
-        // Assert
-        innerScope.UsingLineBreaks.Should().Be(scope.UsingLineBreaks);
-    }
-}
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionScope.ContextDataSpecs.cs b/Tests/FluentAssertions.Specs/Execution/AssertionScope.ContextDataSpecs.cs
deleted file mode 100644
index 1a36fb62bc..0000000000
--- a/Tests/FluentAssertions.Specs/Execution/AssertionScope.ContextDataSpecs.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-using FluentAssertions.Execution;
-using Xunit;
-
-namespace FluentAssertions.Specs.Execution;
-
-/// <content>
-/// The chaining API specs.
-/// </content>
-public partial class AssertionScopeSpecs
-{
-    [Fact]
-    public void Get_value_when_key_is_present()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddNonReportable("SomeKey", "SomeValue");
-        scope.AddNonReportable("SomeOtherKey", "SomeOtherValue");
-
-        // Act
-        var value = scope.Get<string>("SomeKey");
-
-        // Assert
-        value.Should().Be("SomeValue");
-    }
-
-    [Fact]
-    public void Get_default_value_when_key_is_not_present()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        // Act
-        var value = scope.Get<int>("SomeKey");
-
-        // Assert
-        value.Should().Be(0);
-    }
-
-    [Fact]
-    public void Get_default_value_when_nullable_value_is_null()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        int? someValue = null;
-        scope.AddNonReportable("SomeKey", someValue);
-
-        // Act
-        var value = scope.Get<int>("SomeKey");
-
-        // Assert
-        value.Should().Be(0);
-    }
-
-    [Fact]
-    public void Value_should_be_of_requested_type()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddNonReportable("SomeKey", "SomeValue");
-
-        // Act
-        var value = scope.Get<string>("SomeKey");
-
-        // Assert
-        value.Should().BeOfType<string>();
-    }
-}
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionScope.MessageFormatingSpecs.cs b/Tests/FluentAssertions.Specs/Execution/AssertionScope.MessageFormatingSpecs.cs
deleted file mode 100644
index 4dcd1d7af9..0000000000
--- a/Tests/FluentAssertions.Specs/Execution/AssertionScope.MessageFormatingSpecs.cs
+++ /dev/null
@@ -1,522 +0,0 @@
-using System;
-using System.Collections.Generic;
-using FluentAssertions.Execution;
-using Xunit;
-using Xunit.Sdk;
-
-namespace FluentAssertions.Specs.Execution;
-
-/// <content>
-/// The message formatting specs.
-/// </content>
-public partial class AssertionScopeSpecs
-{
-    [Fact]
-    public void When_the_same_failure_is_handled_twice_or_more_it_should_still_report_it_once()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        AssertionScope.Current.FailWith("Failure");
-        AssertionScope.Current.FailWith("Failure");
-
-        using (var nestedScope = new AssertionScope())
-        {
-            nestedScope.FailWith("Failure");
-            nestedScope.FailWith("Failure");
-        }
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .Which.Message.Should().Contain("Failure", Exactly.Times(4));
-    }
-
-    [InlineData("foo")]
-    [InlineData("{}")]
-    [Theory]
-    public void Message_should_use_the_name_of_the_scope_as_context(string context)
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope(context);
-            new[] { 1, 2, 3 }.Should().Equal(3, 2, 1);
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage($"Expected {context} to be equal to*");
-    }
-
-    [Fact]
-    public void Message_should_use_the_lazy_name_of_the_scope_as_context()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope(new Lazy<string>(() => "lazy foo"));
-            new[] { 1, 2, 3 }.Should().Equal(3, 2, 1);
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected lazy foo to be equal to*");
-    }
-
-    [Fact]
-    public void Nested_scopes_use_the_name_of_their_outer_scope_as_context()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var outerScope = new AssertionScope("outer");
-            using var innerScope = new AssertionScope("inner");
-            new[] { 1, 2, 3 }.Should().Equal(3, 2, 1);
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected outer/inner to be equal to*");
-    }
-
-    [Fact]
-    public void The_inner_scope_is_used_when_the_outer_scope_does_not_have_a_context()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var outerScope = new AssertionScope();
-            using var innerScope = new AssertionScope("inner");
-            new[] { 1, 2, 3 }.Should().Equal(3, 2, 1);
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected inner to be equal to*");
-    }
-
-    [Fact]
-    public void Message_should_contain_each_unique_failed_assertion_seperately()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-            var values = new Dictionary<int, int>();
-            values.Should().ContainKey(0);
-            values.Should().ContainKey(1);
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage(
-                "Expected * to contain key 0.\n" +
-                "Expected * to contain key 1.\n");
-    }
-
-    [Fact]
-    public void Message_should_contain_the_same_failed_assertion_seperately_if_called_multiple_times()
-    {
-        // Act
-        Action act = () =>
-        {
-            using var _ = new AssertionScope();
-            var values = new List<int>();
-            values.Should().ContainSingle();
-            values.Should().ContainSingle();
-        };
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage(
-                "Expected * to contain a single item, but the collection is empty.\n" +
-                "Expected * to contain a single item, but the collection is empty.\n");
-    }
-
-    [Fact]
-    public void Because_reason_should_keep_parentheses_in_arguments_as_literals()
-    {
-        // Act
-        Action act = () => 1.Should().Be(2, "can't use these in becauseArgs: {0} {1}", "{", "}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("*because can't use these in becauseArgs: { }*");
-    }
-
-    [Fact]
-    public void Because_reason_should_ignore_undefined_arguments()
-    {
-        // Act
-        object[] becauseArgs = null;
-
-        // ReSharper disable once FormatStringProblem
-        Action act = () => 1.Should().Be(2, "it should still work", becauseArgs);
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("*because it should still work*");
-    }
-
-    [Fact]
-    public void Because_reason_should_threat_parentheses_as_literals_if_no_arguments_are_defined()
-    {
-        // Act
-#pragma warning disable CA2241
-        // ReSharper disable once FormatStringProblem
-        Action act = () => 1.Should().Be(2, "use of {} is okay if there are no because arguments");
-#pragma warning restore CA2241
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("*because use of {} is okay if there are no because arguments*");
-    }
-
-    [Fact]
-    public void Because_reason_should_inform_about_invalid_parentheses_with_a_default_message()
-    {
-        // Act
-#pragma warning disable CA2241
-        // ReSharper disable once FormatStringProblem
-        Action act = () => 1.Should().Be(2, "use of {} is considered invalid in because parameter with becauseArgs",
-            "additional becauseArgs argument");
-#pragma warning restore CA2241
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage(
-                "*because message 'use of {} is considered invalid in because parameter with becauseArgs' could not be formatted with string.Format*");
-    }
-
-    [Fact]
-    public void Message_should_keep_parentheses_in_literal_values()
-    {
-        // Act
-        Action act = () => "{foo}".Should().Be("{bar}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected string to be \"{bar}\", but \"{foo}\" differs near*");
-    }
-
-    [Fact]
-    public void Message_should_contain_literal_value_if_marked_with_double_parentheses()
-    {
-        // Arrange
-        var scope = new AssertionScope("context");
-
-        AssertionScope.Current.FailWith("{{empty}}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("{empty}*");
-    }
-
-    [InlineData("\r")]
-    [InlineData("\\r")]
-    [InlineData("\\\r")]
-    [InlineData("\\\\r")]
-    [InlineData("\\\\\r")]
-    [InlineData("\n")]
-    [InlineData("\\n")]
-    [InlineData("\\\n")]
-    [InlineData("\\\\n")]
-    [InlineData("\\\\\n")]
-    [Theory]
-    public void Message_should_not_have_modified_carriage_return_or_line_feed_control_characters(string str)
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        AssertionScope.Current.FailWith(str);
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage(str);
-    }
-
-    [InlineData("\r")]
-    [InlineData("\\r")]
-    [InlineData("\\\r")]
-    [InlineData(@"\\r")]
-    [InlineData("\\\\\r")]
-    [InlineData("\n")]
-    [InlineData("\\n")]
-    [InlineData("\\\n")]
-    [InlineData(@"\\n")]
-    [InlineData("\\\\\n")]
-    [Theory]
-    public void Message_should_not_have_modified_carriage_return_or_line_feed_control_characters_in_supplied_arguments(string str)
-    {
-        // Arrange
-        var scope = new AssertionScope();
-
-        AssertionScope.Current.FailWith(@"\{0}\A", str);
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("\\\"" + str + "\"\\A*");
-    }
-
-    [Fact]
-    public void Message_should_not_have_trailing_backslashes_removed_from_subject()
-    {
-        // Arrange / Act
-        Action act = () => "A\\".Should().Be("A");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("""* near "\" *""");
-    }
-
-    [Fact]
-    public void Message_should_not_have_trailing_backslashes_removed_from_expectation()
-    {
-        // Arrange / Act
-        Action act = () => "A".Should().Be("A\\");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("""* to be "A\" *""");
-    }
-
-    [Fact]
-    public void Message_should_have_named_placeholder_be_replaced_by_reportable_value()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddReportable("MyKey", "MyValue");
-
-        AssertionScope.Current.FailWith("{MyKey}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("MyValue*");
-    }
-
-    [Fact]
-    public void Message_should_have_named_placeholders_be_replaced_by_reportable_values()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddReportable("SomeKey", "SomeValue");
-        scope.AddReportable("AnotherKey", "AnotherValue");
-
-        AssertionScope.Current.FailWith("{SomeKey}{AnotherKey}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("SomeValueAnotherValue*");
-    }
-
-    [Fact]
-    public void Message_should_have_reportable_values_appended_at_the_end()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddReportable("SomeKey", "SomeValue");
-        scope.AddReportable("AnotherKey", "AnotherValue");
-
-        AssertionScope.Current.FailWith("{SomeKey}{AnotherKey}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("*With SomeKey:\nSomeValue\nWith AnotherKey:\nAnotherValue");
-    }
-
-    [Fact]
-    public void Message_should_not_have_nonreportable_values_appended_at_the_end()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddNonReportable("SomeKey", "SomeValue");
-
-        AssertionScope.Current.FailWith("{SomeKey}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .Which.Message.Should().NotContain("With SomeKey:\nSomeValue");
-    }
-
-    [Fact]
-    public void Message_should_have_named_placeholder_be_replaced_by_nonreportable_value()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        scope.AddNonReportable("SomeKey", "SomeValue");
-
-        AssertionScope.Current.FailWith("{SomeKey}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("SomeValue");
-    }
-
-    [Fact]
-    public void Deferred_reportable_values_should_not_be_calculated_in_absence_of_failures()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        var deferredValueInvoked = false;
-
-        scope.AddReportable("MyKey", () =>
-        {
-            deferredValueInvoked = true;
-
-            return "MyValue";
-        });
-
-        // Act
-        scope.Dispose();
-
-        // Assert
-        deferredValueInvoked.Should().BeFalse();
-    }
-
-    [Fact]
-    public void Message_should_have_named_placeholder_be_replaced_by_defered_reportable_value()
-    {
-        // Arrange
-        var scope = new AssertionScope();
-        var deferredValueInvoked = false;
-
-        scope.AddReportable("MyKey", () =>
-        {
-            deferredValueInvoked = true;
-
-            return "MyValue";
-        });
-
-        AssertionScope.Current.FailWith("{MyKey}");
-
-        // Act
-        Action act = scope.Dispose;
-
-        // Assert
-        act.Should().ThrowExactly<XunitException>()
-            .WithMessage("MyValue*\n\nWith MyKey:\nMyValue\n");
-
-        deferredValueInvoked.Should().BeTrue();
-    }
-
-    [Fact]
-    public void Message_should_start_with_the_defined_expectation()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("Expectations are the root ")
-            .ForCondition(false)
-            .FailWith("of disappointment");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expectations are the root of disappointment");
-    }
-
-    [Fact]
-    public void Message_should_start_with_the_defined_expectation_and_arguments()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("Expectations are the {0} ", "root")
-            .ForCondition(false)
-            .FailWith("of disappointment");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expectations are the \"root\" of disappointment");
-    }
-
-    [Fact]
-    public void Message_should_contain_object_as_context_if_identifier_can_not_be_resolved()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(false)
-            .FailWith("Expected {context}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected object");
-    }
-
-    [Fact]
-    public void Message_should_contain_the_fallback_value_as_context_if_identifier_can_not_be_resolved()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .ForCondition(false)
-            .FailWith("Expected {context:fallback}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected fallback");
-    }
-
-    [Fact]
-    public void Message_should_contain_the_default_identifier_as_context_if_identifier_can_not_be_resolved()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .WithDefaultIdentifier("identifier")
-            .ForCondition(false)
-            .FailWith("Expected {context}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected identifier");
-    }
-
-    [Fact]
-    public void Message_should_contain_the_reason_as_defined()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .BecauseOf("because reasons")
-            .FailWith("Expected{reason}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected because reasons");
-    }
-
-    [Fact]
-    public void Message_should_contain_the_reason_as_defined_with_arguments()
-    {
-        // Act
-        Action act = () => Execute.Assertion
-            .BecauseOf("because {0}", "reasons")
-            .FailWith("Expected{reason}");
-
-        // Assert
-        act.Should().Throw<XunitException>()
-            .WithMessage("Expected because reasons");
-    }
-}
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionScope.ScopedFormatters.cs b/Tests/FluentAssertions.Specs/Execution/AssertionScopeSpecs.ScopedFormatters.cs
similarity index 100%
rename from Tests/FluentAssertions.Specs/Execution/AssertionScope.ScopedFormatters.cs
rename to Tests/FluentAssertions.Specs/Execution/AssertionScopeSpecs.ScopedFormatters.cs
diff --git a/Tests/FluentAssertions.Specs/Execution/AssertionScopeSpecs.cs b/Tests/FluentAssertions.Specs/Execution/AssertionScopeSpecs.cs
index 931c352e65..440efa3152 100644
--- a/Tests/FluentAssertions.Specs/Execution/AssertionScopeSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Execution/AssertionScopeSpecs.cs
@@ -24,7 +24,7 @@ public void When_disposed_it_should_throw_any_failures()
             // Arrange
             var scope = new AssertionScope();
 
-            AssertionScope.Current.FailWith("Failure1");
+            AssertionChain.GetOrCreate().FailWith("Failure1");
 
             // Act
             Action act = scope.Dispose;
@@ -46,7 +46,7 @@ public void When_disposed_it_should_throw_any_failures_and_properly_format_using
             // Arrange
             var scope = new AssertionScope();
 
-            AssertionScope.Current.FailWith("Failure{0}", 1);
+            AssertionChain.GetOrCreate().FailWith("Failure{0}", 1);
 
             // Act
             Action act = scope.Dispose;
@@ -69,7 +69,7 @@ public void When_lazy_version_is_not_disposed_it_should_not_execute_fail_reason_
             var scope = new AssertionScope();
             bool failReasonCalled = false;
 
-            AssertionScope.Current
+            AssertionChain.GetOrCreate()
                 .ForCondition(true)
                 .FailWith(() =>
                 {
@@ -91,7 +91,9 @@ public void When_lazy_version_is_disposed_it_should_throw_any_failures_and_prope
             // Arrange
             var scope = new AssertionScope();
 
-            AssertionScope.Current.FailWith(() => new FailReason("Failure{0}", 1));
+            AssertionChain
+                .GetOrCreate()
+                .FailWith(() => new FailReason("Failure{0}", 1));
 
             // Act
             Action act = scope.Dispose;
@@ -113,14 +115,14 @@ public void When_multiple_scopes_are_nested_it_should_throw_all_failures_from_th
             // Arrange
             var scope = new AssertionScope();
 
-            AssertionScope.Current.FailWith("Failure1");
+            AssertionChain.GetOrCreate().FailWith("Failure1");
 
-            using (var nestedScope = new AssertionScope())
+            using (new AssertionScope())
             {
-                nestedScope.FailWith("Failure2");
+                AssertionChain.GetOrCreate().FailWith("Failure2");
 
                 using var deeplyNestedScope = new AssertionScope();
-                deeplyNestedScope.FailWith("Failure3");
+                AssertionChain.GetOrCreate().FailWith("Failure3");
             }
 
             // Act
@@ -143,14 +145,14 @@ public void When_a_nested_scope_is_discarded_its_failures_should_also_be_discard
             // Arrange
             var scope = new AssertionScope();
 
-            AssertionScope.Current.FailWith("Failure1");
+            AssertionChain.GetOrCreate().FailWith("Failure1");
 
-            using (var nestedScope = new AssertionScope())
+            using (new AssertionScope())
             {
-                nestedScope.FailWith("Failure2");
+                AssertionChain.GetOrCreate().FailWith("Failure2");
 
                 using var deeplyNestedScope = new AssertionScope();
-                deeplyNestedScope.FailWith("Failure3");
+                AssertionChain.GetOrCreate().FailWith("Failure3");
                 deeplyNestedScope.Discard();
             }
 
@@ -170,7 +172,7 @@ public void When_a_nested_scope_is_discarded_its_failures_should_also_be_discard
         }
 
         [Fact]
-        public async Task When_using_AssertionScope_across_thread_boundaries_it_should_work()
+        public async Task When_using_a_scope_across_thread_boundaries_it_should_work()
         {
             using var semaphore = new SemaphoreSlim(0, 1);
             await Task.WhenAll(SemaphoreYieldAndWait(semaphore), SemaphoreYieldAndRelease(semaphore));
@@ -196,10 +198,10 @@ private static async Task SemaphoreYieldAndRelease(SemaphoreSlim semaphore)
         public void When_custom_strategy_used_respect_its_behavior()
         {
             // Arrange
-            var scope = new AssertionScope(new FailWithStupidMessageAssertionStrategy());
+            using var _ = new AssertionScope(new FailWithStupidMessageAssertionStrategy());
 
             // Act
-            Action act = () => scope.FailWith("Failure 1");
+            Action act = () => AssertionChain.GetOrCreate().FailWith("Failure 1");
 
             // Assert
             act.Should().ThrowExactly<XunitException>()
@@ -240,7 +242,7 @@ public void When_using_a_custom_strategy_it_should_include_failure_messages_of_a
         public void When_nested_scope_is_disposed_it_passes_reports_to_parent_scope()
         {
             // Arrange/Act
-            using var outerScope = new AssertionScope();
+            var outerScope = new AssertionScope();
             outerScope.AddReportable("outerReportable", "foo");
 
             using (var innerScope = new AssertionScope())
@@ -248,8 +250,13 @@ public void When_nested_scope_is_disposed_it_passes_reports_to_parent_scope()
                 innerScope.AddReportable("innerReportable", "bar");
             }
 
+            AssertionChain.GetOrCreate().FailWith("whatever reason");
+
+            Action act = () => outerScope.Dispose();
+
             // Assert
-            outerScope.Get<string>("innerReportable").Should().Be("bar");
+            act.Should().Throw<XunitException>()
+                .Which.Message.Should().Match("Whatever reason*outerReportable*foo*innerReportable*bar*");
         }
 
         [Fact]
@@ -286,6 +293,25 @@ public void Formatting_options_passed_to_inner_assertion_scopes()
                 .Which.Should().Contain("Maximum recursion depth of 1 was reached");
         }
 
+        [Fact]
+        public void Multiple_named_scopes_will_prefix_the_caller_identifier()
+        {
+            // Arrange
+            var nonEmptyList = new List<int>([1, 2]);
+
+            // Act
+            Action act = () =>
+            {
+                using var scope1 = new AssertionScope("Test1");
+                using var scope2 = new AssertionScope("Test2");
+                nonEmptyList.Should().BeEmpty();
+            };
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected Test1/Test2/nonEmptyList to be empty*");
+        }
+
         public class CustomAssertionStrategy : IAssertionStrategy
         {
             private readonly List<string> failureMessages = [];
@@ -326,12 +352,12 @@ public void HandleFailure(string message)
 
         internal class FailWithStupidMessageAssertionStrategy : IAssertionStrategy
         {
-            public IEnumerable<string> FailureMessages => new string[0];
+            public IEnumerable<string> FailureMessages => Array.Empty<string>();
 
             public void HandleFailure(string message) =>
                 Services.ThrowException("Good luck with understanding what's going on!");
 
-            public IEnumerable<string> DiscardFailures() => new string[0];
+            public IEnumerable<string> DiscardFailures() => Array.Empty<string>();
 
             public void ThrowIfAny(IDictionary<string, object> context)
             {
diff --git a/Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs b/Tests/FluentAssertions.Specs/Execution/CallerIdentificationSpecs.cs
similarity index 93%
rename from Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs
rename to Tests/FluentAssertions.Specs/Execution/CallerIdentificationSpecs.cs
index c508ade7c9..235b19d327 100644
--- a/Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Execution/CallerIdentificationSpecs.cs
@@ -14,36 +14,37 @@
 // ReSharper disable RedundantStringInterpolation
 namespace FluentAssertions.Specs.Execution
 {
-    public class CallerIdentifierSpecs
+    public class CallerIdentificationSpecs
     {
         [Fact]
-        public void When_namespace_is_exactly_System_caller_should_be_unknown()
+        public void Types_in_the_system_namespace_are_excluded_from_identification()
         {
             // Act
-            Action act = () => SystemNamespaceClass.DetermineCallerIdentityInNamespace();
+            Action act = () => SystemNamespaceClass.AssertAgainstFailure();
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage("Expected function to be*");
+            act.Should().Throw<XunitException>().WithMessage("Expected object*",
+                "because a subject in a system namespace should not be ignored by caller identification");
         }
 
         [Fact]
-        public void When_namespace_is_nested_under_System_caller_should_be_unknown()
+        public void Types_in_a_namespace_nested_under_system_are_excluded_from_identification()
         {
             // Act
-            Action act = () => System.Data.NestedSystemNamespaceClass.DetermineCallerIdentityInNamespace();
+            Action act = () => System.Data.NestedSystemNamespaceClass.AssertAgainstFailure();
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage("Expected function to be*");
+            act.Should().Throw<XunitException>().WithMessage("Expected object*");
         }
 
         [Fact]
-        public void When_namespace_is_prefixed_with_System_caller_should_be_known()
+        public void Types_in_a_namespace_prefixed_with_system_are_excluded_from_identification()
         {
             // Act
-            Action act = () => SystemPrefixed.SystemPrefixedNamespaceClass.DetermineCallerIdentityInNamespace();
+            Action act = () => SystemPrefixed.SystemPrefixedNamespaceClass.AssertAgainstFailure();
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage("Expected actualCaller to be*");
+            act.Should().Throw<XunitException>().WithMessage("Expected actualCaller*");
         }
 
         [Fact]
@@ -545,7 +546,7 @@ public void An_object_initializer_preceding_an_assertion_is_not_an_identifier()
             // Act
             Action act = () => new { Property = "blah" }.Should().BeNull();
 
-            // Assert
+            // Assertl
             act.Should().Throw<XunitException>()
                 .WithMessage("Expected object to be*");
         }
@@ -570,7 +571,7 @@ 5. Test
         }
 
         [CustomAssertion]
-        private string GetSubjectId() => AssertionScope.Current.CallerIdentity;
+        private string GetSubjectId() => AssertionChain.GetOrCreate().CallerIdentifier;
     }
 
 #pragma warning disable IDE0060, RCS1163 // Remove unused parameter
@@ -605,10 +606,10 @@ namespace System
 {
     public static class SystemNamespaceClass
     {
-        public static void DetermineCallerIdentityInNamespace()
+        public static void AssertAgainstFailure()
         {
-            Func<string> actualCaller = () => AssertionScope.Current.CallerIdentity;
-            actualCaller.Should().BeNull("we want this check to fail for the test");
+            object actualCaller = null;
+            actualCaller.Should().NotBeNull("because we want this to fail and not return the name of the subject");
         }
     }
 }
@@ -617,10 +618,10 @@ namespace SystemPrefixed
 {
     public static class SystemPrefixedNamespaceClass
     {
-        public static void DetermineCallerIdentityInNamespace()
+        public static void AssertAgainstFailure()
         {
-            Func<string> actualCaller = () => AssertionScope.Current.CallerIdentity;
-            actualCaller.Should().BeNull("we want this check to fail for the test");
+            object actualCaller = null;
+            actualCaller.Should().NotBeNull("because we want this to fail and return the name of the subject");
         }
     }
 }
@@ -629,10 +630,10 @@ namespace System.Data
 {
     public static class NestedSystemNamespaceClass
     {
-        public static void DetermineCallerIdentityInNamespace()
+        public static void AssertAgainstFailure()
         {
-            Func<string> actualCaller = () => AssertionScope.Current.CallerIdentity;
-            actualCaller.Should().BeNull("we want this check to fail for the test");
+            object actualCaller = null;
+            actualCaller.Should().NotBeNull("because we want this to fail and not return the name of the subject");
         }
     }
 }
diff --git a/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs
index d9808ab3f2..3209ccddbb 100644
--- a/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs
@@ -14,7 +14,7 @@ public void A_consecutive_subject_should_be_selected()
         string value = string.Empty;
 
         // Act
-        Execute.Assertion
+        AssertionChain.GetOrCreate()
             .ForCondition(true)
             .Given(() => "First selector")
             .Given(_ => value = "Second selector");
@@ -30,7 +30,7 @@ public void After_a_failed_condition_a_consecutive_subject_should_be_ignored()
         string value = string.Empty;
 
         // Act
-        Execute.Assertion
+        AssertionChain.GetOrCreate()
             .ForCondition(false)
             .Given(() => "First selector")
             .Given(_ => value = "Second selector");
@@ -43,7 +43,7 @@ public void After_a_failed_condition_a_consecutive_subject_should_be_ignored()
     public void A_consecutive_condition_should_be_evaluated()
     {
         // Act / Assert
-        Execute.Assertion
+        AssertionChain.GetOrCreate()
             .ForCondition(true)
             .Given(() => "Subject")
             .ForCondition(_ => true)
@@ -54,7 +54,7 @@ public void A_consecutive_condition_should_be_evaluated()
     public void After_a_failed_condition_a_consecutive_condition_should_be_ignored()
     {
         // Act
-        Action act = () => Execute.Assertion
+        Action act = () => AssertionChain.GetOrCreate()
             .ForCondition(false)
             .Given(() => "Subject")
             .ForCondition(_ => throw new ApplicationException())
@@ -68,7 +68,7 @@ public void After_a_failed_condition_a_consecutive_condition_should_be_ignored()
     public void When_continuing_an_assertion_chain_it_fails_with_a_message_after_selecting_the_subject()
     {
         // Act
-        Action act = () => Execute.Assertion
+        Action act = () => AssertionChain.GetOrCreate()
             .ForCondition(true)
             .Given(() => "First")
             .FailWith("First selector")
@@ -85,7 +85,7 @@ public void When_continuing_an_assertion_chain_it_fails_with_a_message_after_sel
     public void When_continuing_an_assertion_chain_it_fails_with_a_message_with_arguments_after_selecting_the_subject()
     {
         // Act
-        Action act = () => Execute.Assertion
+        Action act = () => AssertionChain.GetOrCreate()
             .ForCondition(true)
             .Given(() => "First")
             .FailWith("{0} selector", "First")
@@ -102,7 +102,7 @@ public void When_continuing_an_assertion_chain_it_fails_with_a_message_with_argu
     public void When_continuing_an_assertion_chain_it_fails_with_a_message_with_argument_selectors_after_selecting_the_subject()
     {
         // Act
-        Action act = () => Execute.Assertion
+        Action act = () => AssertionChain.GetOrCreate()
             .ForCondition(true)
             .Given(() => "First")
             .FailWith("{0} selector", _ => "First")
@@ -123,7 +123,7 @@ public void When_continuing_a_failed_assertion_chain_consecutive_failure_message
         {
             using var _ = new AssertionScope();
 
-            Execute.Assertion
+            AssertionChain.GetOrCreate()
                 .Given(() => "First")
                 .FailWith("First selector")
                 .Then
@@ -143,7 +143,7 @@ public void When_continuing_a_failed_assertion_chain_consecutive_failure_message
         {
             using var _ = new AssertionScope();
 
-            Execute.Assertion
+            AssertionChain.GetOrCreate()
                 .Given(() => "First")
                 .FailWith("{0} selector", "First")
                 .Then
@@ -163,7 +163,7 @@ public void When_continuing_a_failed_assertion_chain_consecutive_failure_message
         {
             using var _ = new AssertionScope();
 
-            Execute.Assertion
+            AssertionChain.GetOrCreate()
                 .Given(() => "First")
                 .FailWith("{0} selector", _ => "First")
                 .Then
@@ -179,10 +179,13 @@ public void When_continuing_a_failed_assertion_chain_consecutive_failure_message
     public void The_failure_message_should_be_preceded_by_the_expectation_after_selecting_a_subject()
     {
         // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("Expectation ")
-            .Given(() => "Subject")
-            .FailWith("Failure");
+        Action act = () =>
+        {
+            AssertionChain.GetOrCreate()
+                .WithExpectation("Expectation ", chain => chain
+                    .Given(() => "Subject")
+                    .FailWith("Failure"));
+        };
 
         // Assert
         act.Should().Throw<XunitException>()
@@ -194,12 +197,14 @@ public void
         The_failure_message_should_not_be_preceded_by_the_expectation_after_selecting_a_subject_and_clearing_the_expectation()
     {
         // Act
-        Action act = () => Execute.Assertion
-            .WithExpectation("Expectation ")
-            .Given(() => "Subject")
-            .ClearExpectation()
-            .Then
-            .FailWith("Failure");
+        Action act = () =>
+        {
+            AssertionChain.GetOrCreate()
+                .WithExpectation("Expectation ", chain => chain
+                    .Given(() => "Subject"))
+                .Then
+                .FailWith("Failure");
+        };
 
         // Assert
         act.Should().Throw<XunitException>()
@@ -210,38 +215,15 @@ public void
     public void Clearing_the_expectation_does_not_affect_a_successful_assertion()
     {
         // Act
-        bool result = Execute.Assertion
-            .WithExpectation("Expectation ")
-            .Given(() => "Don't care")
-            .ForCondition(_ => true)
-            .FailWith("Should not fail")
-            .Then
-            .ClearExpectation();
-
-        // Assert
-        result.Should().BeTrue();
-    }
-
-    [Fact]
-    public void Clearing_the_expectation_does_not_affect_a_failed_assertion()
-    {
-        // Act
-        using var scope = new AssertionScope();
+        var assertionChain = AssertionChain.GetOrCreate();
 
-        bool result = Execute.Assertion
-            .WithExpectation("Expectation ")
-            .Given(() => "Don't care")
-            .ForCondition(_ => false)
-            .FailWith("Should fail")
-            .Then
-            .ClearExpectation();
-
-        scope.Discard();
+        assertionChain
+            .WithExpectation("Expectation ", chain => chain
+                .Given(() => "Don't care")
+                .ForCondition(_ => true)
+                .FailWith("Should not fail"));
 
         // Assert
-        if (result)
-        {
-            throw new XunitException("the assertion failed and should return false");
-        }
+        assertionChain.Succeeded.Should().BeTrue();
     }
 }
diff --git a/Tests/FluentAssertions.Specs/Formatting/FormatterSpecs.cs b/Tests/FluentAssertions.Specs/Formatting/FormatterSpecs.cs
index 4d6853ee72..e38556fc56 100644
--- a/Tests/FluentAssertions.Specs/Formatting/FormatterSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Formatting/FormatterSpecs.cs
@@ -211,32 +211,32 @@ public void When_the_object_is_a_generic_type_without_custom_string_representati
         act.Should().Throw<XunitException>()
             .WithMessage(
             """
-            Expected stuff to be equal to 
+            Expected stuff to be equal to
             {
                 FluentAssertions.Specs.Formatting.FormatterSpecs+Stuff`1[[System.Int32*]]
                 {
-                    Children = {1, 2, 3, 4}, 
-                    Description = "Stuff_1", 
+                    Children = {1, 2, 3, 4},
+                    Description = "Stuff_1",
                     StuffId = 1
-                }, 
+                },
                 FluentAssertions.Specs.Formatting.FormatterSpecs+Stuff`1[[System.Int32*]]
                 {
-                    Children = {1, 2, 3, 4}, 
-                    Description = "WRONG_DESCRIPTION", 
+                    Children = {1, 2, 3, 4},
+                    Description = "WRONG_DESCRIPTION",
                     StuffId = 2
                 }
-            }, but 
+            }, but
             {
                 FluentAssertions.Specs.Formatting.FormatterSpecs+Stuff`1[[System.Int32*]]
                 {
-                    Children = {1, 2, 3, 4}, 
-                    Description = "Stuff_1", 
+                    Children = {1, 2, 3, 4},
+                    Description = "Stuff_1",
                     StuffId = 1
-                }, 
+                },
                 FluentAssertions.Specs.Formatting.FormatterSpecs+Stuff`1[[System.Int32*]]
                 {
-                    Children = {1, 2, 3, 4}, 
-                    Description = "Stuff_2", 
+                    Children = {1, 2, 3, 4},
+                    Description = "Stuff_2",
                     StuffId = 2
                 }
             } differs at index 1.
@@ -254,13 +254,13 @@ public void When_the_object_is_a_user_defined_type_it_should_show_the_name_on_th
 
         // Assert
         act.Should().Throw<XunitException>()
-            .Which.Message.Should().Be(
+            .Which.Message.Should().Match(
             """
             Expected stuff to be <null>, but found FluentAssertions.Specs.Formatting.FormatterSpecs+StuffRecord
             {
-                RecordChildren = {10, 20, 30, 40}, 
-                RecordDescription = "description", 
-                RecordId = 42, 
+                RecordChildren = {10, 20, 30, 40},*
+                RecordDescription = "description",*
+                RecordId = 42,*
                 SingleChild = FluentAssertions.Specs.Formatting.FormatterSpecs+ChildRecord
                 {
                     ChildRecordId = 24
@@ -293,18 +293,18 @@ public void When_the_object_is_an_anonymous_type_it_should_show_the_properties_r
         act.Should().Throw<XunitException>()
             .Which.Message.Should().Be(
             """
-            Expected stuff to be 
+            Expected stuff to be
             {
-                Children = {10, 20, 30, 40}, 
-                SingleChild = 
+                Children = {10, 20, 30, 40},
+                SingleChild =
                 {
                     ChildId = 4
                 }
-            }, but found 
+            }, but found
             {
-                Children = {1, 2, 3, 4}, 
-                Description = "absent", 
-                SingleChild = 
+                Children = {1, 2, 3, 4},
+                Description = "absent",
+                SingleChild =
                 {
                     ChildId = 8
                 }
@@ -345,13 +345,13 @@ public void When_the_object_is_a_list_of_anonymous_type_it_should_show_the_prope
 
         // Assert
         act.Should().Throw<XunitException>()
-            .Which.Message.Should().StartWith(
+            .Which.Message.Should().Match(
             """
-            Expected stuff to be a collection with 1 item(s), but 
+            Expected stuff to be a collection with 1 item(s), but*
             {
                 {
                     Description = "absent"
-                }, 
+                },*
                 {
                     Description = "absent"
                 }
@@ -360,17 +360,17 @@ contains 1 item(s) more than
 
             {
                 {
-                    ComplexChildren = 
+                    ComplexChildren =*
                     {
                         {
                             Property = "hello"
-                        }, 
+                        },*
                         {
                             Property = "goodbye"
                         }
                     }
                 }
-            }.
+            }.*
             """);
     }
 
@@ -403,19 +403,19 @@ public void When_the_object_is_a_tuple_it_should_show_the_properties_recursively
 
         // Assert
         act.Should().Throw<XunitException>()
-            .Which.Message.Should().Be(
+            .Which.Message.Should().Match(
             """
-            Expected stuff to be equal to 
+            Expected stuff to be equal to*
             {
-                Item1 = 2, 
-                Item2 = "WRONG_DESCRIPTION", 
+                Item1 = 2,*
+                Item2 = "WRONG_DESCRIPTION",*
                 Item3 = {4, 5, 6, 7}
-            }, but found 
+            }, but found*
             {
-                Item1 = 1, 
-                Item2 = "description", 
+                Item1 = 1,*
+                Item2 = "description",*
                 Item3 = {1, 2, 3, 4}
-            }.
+            }.*
             """);
     }
 
@@ -439,16 +439,16 @@ public void When_the_object_is_a_record_it_should_show_the_properties_recursivel
 
         // Assert
         act.Should().Throw<XunitException>()
-            .Which.Message.Should().Be(
+            .Which.Message.Should().Match(
             """
-            Expected stuff to be 
+            Expected stuff to be*
             {
                 RecordDescription = "WRONG_DESCRIPTION"
             }, but found FluentAssertions.Specs.Formatting.FormatterSpecs+StuffRecord
             {
-                RecordChildren = {4, 5, 6, 7}, 
-                RecordDescription = "descriptive", 
-                RecordId = 9, 
+                RecordChildren = {4, 5, 6, 7},*
+                RecordDescription = "descriptive",*
+                RecordId = 9,*
                 SingleChild = FluentAssertions.Specs.Formatting.FormatterSpecs+ChildRecord
                 {
                     ChildRecordId = 80
@@ -1193,7 +1193,7 @@ public void When_defining_a_custom_enumerable_value_formatter_it_should_respect_
         str.Should().Match(Environment.NewLine +
             "{*FluentAssertions*FormatterSpecs+CustomClass" + Environment.NewLine +
             "    {" + Environment.NewLine +
-            "        IntProperty = 1, " + Environment.NewLine +
+            "        IntProperty = 1," + Environment.NewLine +
             "        StringProperty = <null>" + Environment.NewLine +
             "    },*…1 more…*}*");
     }
diff --git a/Tests/FluentAssertions.Specs/OccurrenceConstraintSpecs.cs b/Tests/FluentAssertions.Specs/OccurrenceConstraintSpecs.cs
index 307099e068..7024a699dd 100644
--- a/Tests/FluentAssertions.Specs/OccurrenceConstraintSpecs.cs
+++ b/Tests/FluentAssertions.Specs/OccurrenceConstraintSpecs.cs
@@ -49,7 +49,7 @@ public class OccurrenceConstraintSpecs
     public void Occurrence_constraint_passes(OccurrenceConstraint constraint, int occurrences)
     {
         // Act / Assert
-        Execute.Assertion
+        AssertionChain.GetOrCreate()
             .ForConstraint(constraint, occurrences)
             .FailWith("");
     }
@@ -96,7 +96,7 @@ public void Occurrence_constraint_passes(OccurrenceConstraint constraint, int oc
     public void Occurrence_constraint_fails(OccurrenceConstraint constraint, int occurrences)
     {
         // Act
-        Action act = () => Execute.Assertion
+        Action act = () => AssertionChain.GetOrCreate()
             .ForConstraint(constraint, occurrences)
             .FailWith($"Expected occurrence to be {constraint.Mode} {constraint.ExpectedCount}, but it was {occurrences}");
 
diff --git a/Tests/FluentAssertions.Specs/Primitives/ObjectAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/ObjectAssertionSpecs.cs
index e83f7a0394..e57f61e5d8 100644
--- a/Tests/FluentAssertions.Specs/Primitives/ObjectAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Primitives/ObjectAssertionSpecs.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 using Xunit;
 
@@ -84,7 +85,7 @@ public bool Equals(SomeClass x, SomeClass y)
 internal class SomeClassAssertions : ObjectAssertions<SomeClass, SomeClassAssertions>
 {
     public SomeClassAssertions(SomeClass value)
-        : base(value)
+        : base(value, AssertionChain.GetOrCreate())
     {
     }
 }
diff --git a/Tests/FluentAssertions.Specs/Primitives/ReferenceTypeAssertionsSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/ReferenceTypeAssertionsSpecs.cs
index 191ea2e41e..54f2c74587 100644
--- a/Tests/FluentAssertions.Specs/Primitives/ReferenceTypeAssertionsSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Primitives/ReferenceTypeAssertionsSpecs.cs
@@ -43,10 +43,10 @@ public void When_two_different_objects_are_expected_to_be_the_same_it_should_fai
             .Should().Throw<XunitException>()
             .WithMessage(
             """
-            Expected subject to refer to 
+            Expected subject to refer to
             {
                 UserName = "JohnDoe"
-            } because they are the same, but found 
+            } because they are the same, but found
             {
                 Name = "John Doe"
             }.
@@ -61,7 +61,7 @@ public void When_a_derived_class_has_longer_formatting_than_the_base_class()
         act.Should().Throw<XunitException>()
             .WithMessage(
             """
-            Expected subject to be empty, but found at least one item 
+            Expected subject to be empty, but found at least one item
             {
                 FluentAssertions.Specs.Primitives.Complex
                 {
@@ -454,7 +454,7 @@ public void Should_throw_a_helpful_error_when_accidentally_using_equals()
         public class ReferenceTypeAssertionsDummy : ReferenceTypeAssertions<object, ReferenceTypeAssertionsDummy>
         {
             public ReferenceTypeAssertionsDummy(object subject)
-                : base(subject)
+                : base(subject, AssertionChain.GetOrCreate())
             {
             }
 
diff --git a/Tests/FluentAssertions.Specs/Primitives/SimpleTimeSpanAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/SimpleTimeSpanAssertionSpecs.cs
index 1e2a8a56d8..0cf1b14ae1 100644
--- a/Tests/FluentAssertions.Specs/Primitives/SimpleTimeSpanAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Primitives/SimpleTimeSpanAssertionSpecs.cs
@@ -1,4 +1,5 @@
 using System;
+using FluentAssertions.Execution;
 using FluentAssertions.Extensions;
 using FluentAssertions.Primitives;
 using Xunit;
@@ -165,7 +166,7 @@ public void When_asserting_value_to_be_equal_to_different_value_it_should_fail()
     public void A_null_is_not_equal_to_another_value()
     {
         // Arrange
-        var subject = new SimpleTimeSpanAssertions(null);
+        var subject = new SimpleTimeSpanAssertions(null, AssertionChain.GetOrCreate());
         TimeSpan expected = 2.Seconds();
 
         // Act
diff --git a/Tests/FluentAssertions.Specs/Primitives/StringComparisonSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/StringComparisonSpecs.cs
index 5ece34c048..abbc42f90b 100644
--- a/Tests/FluentAssertions.Specs/Primitives/StringComparisonSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Primitives/StringComparisonSpecs.cs
@@ -264,15 +264,11 @@ public void When_comparing_strings_for_not_containing_any_equals_it_should_ignor
     [CulturedFact("tr-TR")]
     public void When_formatting_reason_arguments_it_should_ignore_culture()
     {
-        // Arrange
-        var scope = new AssertionScope();
-
         // Act
-        scope.BecauseOf("{0}", 1.234)
-            .FailWith("{reason}");
+        Action act = () => 1.Should().Be(2, "{0}", 1.234);
 
         // Assert
-        scope.Invoking(e => e.Dispose()).Should().Throw<XunitException>()
+        act.Should().Throw<XunitException>()
             .WithMessage("*1.234*", "it should always use . as decimal separator");
     }
 
diff --git a/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
index 50ec7d4f01..debf5e2c06 100644
--- a/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
@@ -165,7 +165,7 @@ public void When_an_assembly_is_referencing_null_it_should_throw()
     public class DefineType
     {
         [Fact]
-        public void When_an_assembly_defines_a_type_and_Should_DefineType_is_asserted_it_should_succeed()
+        public void Can_find_a_specific_type()
         {
             // Arrange
             var thisAssembly = GetType().Assembly;
@@ -179,6 +179,22 @@ public void When_an_assembly_defines_a_type_and_Should_DefineType_is_asserted_it
             act.Should().NotThrow();
         }
 
+        [Fact]
+        public void Can_continue_assertions_on_the_found_type()
+        {
+            // Arrange
+            var thisAssembly = GetType().Assembly;
+
+            // Act
+            Action act = () => thisAssembly
+                .Should().DefineType(GetType().Namespace, typeof(WellKnownClassWithAttribute).Name)
+                .Which.Should().BeDecoratedWith<SerializableAttribute>();
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected*WellKnownClassWithAttribute*decorated*SerializableAttribute*not found.");
+        }
+
         [Fact]
         public void
             When_an_assembly_does_not_define_a_type_and_Should_DefineType_is_asserted_it_should_fail_with_a_useful_message()
diff --git a/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs
index d1a591ba61..d0f632baa4 100644
--- a/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using FluentAssertions.Execution;
 using FluentAssertions.Extensions;
 using FluentAssertions.Specialized;
 using Xunit;
@@ -580,7 +581,7 @@ public void When_asserting_on_null_execution_it_should_throw()
             ExecutionTime executionTime = null;
 
             // Act
-            Func<ExecutionTimeAssertions> act = () => new ExecutionTimeAssertions(executionTime);
+            Func<ExecutionTimeAssertions> act = () => new ExecutionTimeAssertions(executionTime, AssertionChain.GetOrCreate());
 
             // Assert
             act.Should().Throw<ArgumentNullException>()
diff --git a/Tests/FluentAssertions.Specs/Specialized/TaskCompletionSourceAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/TaskCompletionSourceAssertionSpecs.cs
index 087c9b2d51..2d5a53994f 100644
--- a/Tests/FluentAssertions.Specs/Specialized/TaskCompletionSourceAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/TaskCompletionSourceAssertionSpecs.cs
@@ -201,7 +201,7 @@ public async Task When_it_completes_in_time_and_async_result_is_not_expected_it_
 
             // Assert
             await action.Should().ThrowAsync<XunitException>()
-                .WithMessage("Expected testSubject to be 42, but found 99.");
+                .WithMessage("Expected testSubject.Result to be 42, but found 99.");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Specialized/TaskOfTAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/TaskOfTAssertionSpecs.cs
index df75d2f527..5ea7158732 100644
--- a/Tests/FluentAssertions.Specs/Specialized/TaskOfTAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/TaskOfTAssertionSpecs.cs
@@ -76,6 +76,29 @@ public async Task When_task_completes_fast_it_should_succeed()
             await action.Should().NotThrowAsync();
         }
 
+        [Fact]
+        public async Task Can_chain_another_assertion_on_the_result_of_the_async_operation()
+        {
+            // Arrange
+            var timer = new FakeClock();
+            var taskFactory = new TaskCompletionSource<int>();
+
+            // Act
+            Func<Task> action = async () =>
+            {
+                Func<Task<int>> func = () => taskFactory.Task;
+
+                (await func.Should(timer).CompleteWithinAsync(100.Milliseconds()))
+                    .Which.Should().Be(42);
+            };
+
+            taskFactory.SetResult(42);
+            timer.Complete();
+
+            // Assert
+            await action.Should().NotThrowAsync();
+        }
+
         [Fact]
         public async Task When_task_completes_and_result_is_not_expected_it_should_fail()
         {
@@ -120,7 +143,7 @@ public async Task When_task_completes_and_async_result_is_not_expected_it_should
             timer.Complete();
 
             // Assert
-            await action.Should().ThrowAsync<XunitException>().WithMessage("Expected funcSubject to be 42, but found 99.");
+            await action.Should().ThrowAsync<XunitException>().WithMessage("Expected funcSubject.Result to be 42, but found 99.");
         }
 
         [Fact]
@@ -185,7 +208,7 @@ public async Task When_task_does_not_complete_the_result_extension_does_not_hang
 
             // Assert
             var assertionTask = action.Should().ThrowAsync<XunitException>()
-                .WithMessage("Expected*to complete within 100ms.*Expected*to be 2, but found 0.");
+                .WithMessage("Expected*to complete within 100ms.");
 
             await Awaiting(() => assertionTask).Should().CompleteWithinAsync(200.Seconds());
         }
@@ -261,6 +284,29 @@ public async Task When_task_does_not_throw_it_should_succeed()
             await action.Should().NotThrowAsync();
         }
 
+        [Fact]
+        public async Task Can_chain_another_assertion_on_the_result_of_the_async_operation()
+        {
+            // Arrange
+            var timer = new FakeClock();
+            var taskFactory = new TaskCompletionSource<int>();
+
+            // Act
+            Func<Task> action = async () =>
+            {
+                Func<Task<int>> func = () => taskFactory.Task;
+
+                (await func.Should(timer).NotThrowAsync())
+                    .Which.Should().Be(10);
+            };
+
+            taskFactory.SetResult(20);
+            timer.Complete();
+
+            // Assert
+            await action.Should().ThrowAsync<XunitException>().WithMessage("*func.Result to be 10*");
+        }
+
         [Fact]
         public async Task When_task_throws_it_should_fail()
         {
diff --git a/Tests/FluentAssertions.Specs/Types/MethodBaseAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodBaseAssertionSpecs.cs
index 84a2bf8dc2..997f09fb29 100644
--- a/Tests/FluentAssertions.Specs/Types/MethodBaseAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Types/MethodBaseAssertionSpecs.cs
@@ -389,7 +389,7 @@ public void When_asserting_a_private_member_is_protected_it_throws_with_a_useful
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method PrivateMethod to be Protected because we want to test the error message, but it is " +
+                    "Expected method TestClass.PrivateMethod to be Protected because we want to test the error message, but it is " +
                     "Private.");
         }
 
@@ -426,7 +426,7 @@ public void When_asserting_a_protected_member_is_public_it_throws_with_a_useful_
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method set_ProtectedSetProperty to be Public because we want to test the error message, but it" +
+                    "Expected method TestClass.set_ProtectedSetProperty to be Public because we want to test the error message, but it" +
                     " is Protected.");
         }
 
@@ -463,7 +463,7 @@ public void When_asserting_a_public_member_is_internal_it_throws_with_a_useful_m
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method get_PublicGetProperty to be Internal because we want to test the error message, but it" +
+                    "Expected method TestClass.get_PublicGetProperty to be Internal because we want to test the error message, but it" +
                     " is Public.");
         }
 
@@ -495,7 +495,7 @@ public void When_asserting_an_internal_member_is_protectedInternal_it_throws_wit
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method InternalMethod to be ProtectedInternal because we want to test the error message, but" +
+                    "Expected method TestClass.InternalMethod to be ProtectedInternal because we want to test the error message, but" +
                     " it is Internal.");
         }
 
@@ -526,7 +526,7 @@ public void When_asserting_a_protected_internal_member_is_private_it_throws_with
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method ProtectedInternalMethod to be Private because we want to test the error message, but it is " +
+                    "Expected method TestClass.ProtectedInternalMethod to be Private because we want to test the error message, but it is " +
                     "ProtectedInternal.");
         }
 
@@ -604,7 +604,7 @@ public void When_asserting_a_private_member_is_not_private_it_throws_with_a_usef
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected method PrivateMethod not to be Private*because we want to test the error message*");
+                .WithMessage("Expected method TestClass.PrivateMethod not to be Private*because we want to test the error message*");
         }
 
         [Fact]
@@ -638,7 +638,7 @@ public void When_asserting_a_protected_member_is_not_protected_it_throws_with_a_
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method set_ProtectedSetProperty not to be Protected*because we want to test the error message*");
+                    "Expected method TestClass.set_ProtectedSetProperty not to be Protected*because we want to test the error message*");
         }
 
         [Fact]
@@ -686,7 +686,7 @@ public void When_asserting_a_public_member_is_not_public_it_throws_with_a_useful
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected method get_PublicGetProperty not to be Public*because we want to test the error message*");
+                .WithMessage("Expected method TestClass.get_PublicGetProperty not to be Public*because we want to test the error message*");
         }
 
         [Fact]
@@ -716,7 +716,7 @@ public void When_asserting_an_internal_member_is_not_internal_it_throws_with_a_u
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected method InternalMethod not to be Internal*because we want to test the error message*");
+                .WithMessage("Expected method TestClass.InternalMethod not to be Internal*because we want to test the error message*");
         }
 
         [Fact]
@@ -747,7 +747,7 @@ public void When_asserting_a_protected_internal_member_is_not_protected_internal
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected method ProtectedInternalMethod not to be ProtectedInternal*because we want to test the error message*");
+                    "Expected method TestClass.ProtectedInternalMethod not to be ProtectedInternal*because we want to test the error message*");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Types/PropertyInfoAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/PropertyInfoAssertionSpecs.cs
index e4479a345e..5d247992e8 100644
--- a/Tests/FluentAssertions.Specs/Types/PropertyInfoAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Types/PropertyInfoAssertionSpecs.cs
@@ -19,8 +19,7 @@ public void When_asserting_that_a_property_is_virtual_and_it_is_then_it_succeeds
             PropertyInfo propertyInfo = typeof(ClassWithAllPropertiesVirtual).GetRuntimeProperty("PublicVirtualProperty");
 
             // Act
-            Action act = () =>
-                propertyInfo.Should().BeVirtual();
+            Action act = () => propertyInfo.Should().BeVirtual();
 
             // Assert
             act.Should().NotThrow();
@@ -34,13 +33,12 @@ public void When_asserting_that_a_property_is_virtual_and_it_is_not_then_it_fail
                 typeof(ClassWithNonVirtualPublicProperties).GetRuntimeProperty("PublicNonVirtualProperty");
 
             // Act
-            Action act = () =>
-                propertyInfo.Should().BeVirtual("we want to test the error {0}", "message");
+            Action act = () => propertyInfo.Should().BeVirtual("we want to test the error {0}", "message");
 
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected property String FluentAssertions*ClassWithNonVirtualPublicProperties.PublicNonVirtualProperty" +
+                    "Expected property ClassWithNonVirtualPublicProperties.PublicNonVirtualProperty" +
                     " to be virtual because we want to test the error message," +
                     " but it is not.");
         }
@@ -173,8 +171,8 @@ public void When_asserting_a_property_is_decorated_with_attribute_and_it_is_not_
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected property String " +
-                    "FluentAssertions*ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty to be decorated with " +
+                .WithMessage("Expected property " +
+                    "ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty to be decorated with " +
                     "FluentAssertions*DummyPropertyAttribute because we want to test the error message, but that attribute was not found.");
         }
 
@@ -194,7 +192,7 @@ public void
             // Assert
             act.Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected property String FluentAssertions*ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty to be decorated with " +
+                    "Expected property ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty to be decorated with " +
                     "FluentAssertions*DummyPropertyAttribute because we want to test the error message," +
                     " but that attribute was not found.");
         }
@@ -295,7 +293,7 @@ public void When_asserting_a_readonly_property_is_writable_it_fails_with_useful_
             action
                 .Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected propertyInfo ReadOnlyProperty to have a setter because we want to test the error message.");
+                    "Expected property ClassWithProperties.ReadOnlyProperty to have a setter because we want to test the error message.");
         }
 
         [Fact]
@@ -381,7 +379,7 @@ public void When_asserting_a_writeonly_property_is_readable_it_fails_with_useful
             action
                 .Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected property WriteOnlyProperty to have a getter because we want to test the error message, but it does not.");
+                    "Expected property *WriteOnlyProperty to have a getter because we want to test the error message, but it does not.");
         }
 
         [Fact]
@@ -427,8 +425,8 @@ public void When_asserting_a_readwrite_property_is_not_writable_it_fails_with_us
             // Assert
             action
                 .Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected propertyInfo ReadWriteProperty not to have a setter because we want to test the error message.");
+                .WithMessage("Did not expect property ClassWithReadOnlyProperties.ReadWriteProperty" +
+                    " to have a setter because we want to test the error message.");
         }
 
         [Fact]
@@ -443,8 +441,8 @@ public void When_asserting_a_writeonly_property_is_not_writable_it_fails_with_us
             // Assert
             action
                 .Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected propertyInfo WriteOnlyProperty not to have a setter because we want to test the error message.");
+                .WithMessage("Did not expect property ClassWithProperties.WriteOnlyProperty" +
+                    " to have a setter because we want to test the error message.");
         }
 
         [Fact]
@@ -459,7 +457,7 @@ public void When_subject_is_null_not_be_writable_should_fail()
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected property not to have a setter *failure message*, but propertyInfo is <null>.");
+                .WithMessage("Expected propertyInfo not to have a setter *failure message*, but it is <null>.");
         }
     }
 
@@ -477,8 +475,8 @@ public void When_asserting_a_readonly_property_is_not_readable_it_fails_with_use
             // Assert
             action
                 .Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected propertyInfo ReadOnlyProperty not to have a getter because we want to test the error message.");
+                .WithMessage("Did not expect property ClassWithReadOnlyProperties.ReadOnlyProperty " +
+                    "to have a getter because we want to test the error message.");
         }
 
         [Fact]
@@ -493,8 +491,8 @@ public void When_asserting_a_readwrite_property_is_not_readable_it_fails_with_us
             // Assert
             action
                 .Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected propertyInfo ReadWriteProperty not to have a getter because we want to test the error message.");
+                .WithMessage("Did not expect property ClassWithReadOnlyProperties.ReadWriteProperty " +
+                    "to have a getter because we want to test the error message.");
         }
 
         [Fact]
@@ -553,8 +551,8 @@ public void When_asserting_a_private_read_public_write_property_is_public_readab
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected method get_WritePrivateReadProperty to be Public because we want to test the error message, but it is Private.");
+                .WithMessage("Expected getter of property ClassWithProperties.WritePrivateReadProperty " +
+                    "to be Public because we want to test the error message, but it is Private*");
         }
 
         [Fact]
@@ -572,7 +570,7 @@ public void Do_not_the_check_access_modifier_when_the_property_is_not_readable()
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected property WriteOnlyProperty to have a getter, but it does not.");
+                .WithMessage("Expected property ClassWithProperties.WriteOnlyProperty to have a getter, but it does not.");
         }
 
         [Fact]
@@ -587,7 +585,7 @@ public void When_subject_is_null_be_readable_with_accessmodifier_should_fail()
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected property to be Public *failure message*, but propertyInfo is <null>.");
+                .WithMessage("Expected propertyInfo to be Public *failure message*, but it is <null>.");
         }
 
         [Fact]
@@ -633,8 +631,8 @@ public void When_asserting_a_private_write_public_read_property_is_public_writab
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected method set_ReadPrivateWriteProperty to be Public because we want to test the error message, but it is Private.");
+                .WithMessage("Expected setter of property ClassWithProperties.ReadPrivateWriteProperty " +
+                    "to be Public because we want to test the error message, but it is Private.");
         }
 
         [Fact]
@@ -652,7 +650,7 @@ public void Do_not_the_check_access_modifier_when_the_property_is_not_writable()
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected propertyInfo ReadOnlyProperty to have a setter.");
+                .WithMessage("Expected property ClassWithProperties.ReadOnlyProperty to have a setter.");
         }
 
         [Fact]
@@ -667,7 +665,7 @@ public void When_subject_is_null_be_writable_with_accessmodifier_should_fail()
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected property to be Public *failure message*, but propertyInfo is <null>.");
+                .WithMessage("Expected propertyInfo to be Public *failure message*, but it is <null>.");
         }
 
         [Fact]
@@ -712,8 +710,8 @@ public void When_asserting_a_String_property_returns_an_Int32_it_throw_with_a_us
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected Type of property StringProperty to be System.Int32 because we want to test the error " +
-                    "message, but it is System.String.");
+                .WithMessage("Expected type of property ClassWithProperties.StringProperty" +
+                    " to be System.Int32 because we want to test the error message, but it is System.String.");
         }
 
         [Fact]
@@ -773,7 +771,7 @@ public void When_asserting_a_String_property_returnsOfT_an_Int32_it_throw_with_a
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected Type of property StringProperty to be System.Int32 because we want to test the error " +
+                .WithMessage("Expected type of property ClassWithProperties.StringProperty to be System.Int32 because we want to test the error " +
                     "message, but it is System.String.");
         }
     }
@@ -804,8 +802,8 @@ public void When_asserting_a_String_property_does_not_return_a_String_it_throw_w
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected Type of property StringProperty not to be*String*because we want to test the error " +
-                    "message, but it is.");
+                .WithMessage("Expected type of property ClassWithProperties.StringProperty" +
+                    " not to be System.String because we want to test the error message, but it is.");
         }
 
         [Fact]
@@ -842,7 +840,7 @@ public void When_asserting_property_type_is_not_null_it_should_throw()
     public class NotReturnOfT
     {
         [Fact]
-        public void When_asserting_a_String_property_does_not_returnOfT_an_Int32_it_succeeds()
+        public void Can_validate_the_type_of_a_property()
         {
             // Arrange
             PropertyInfo propertyInfo = typeof(ClassWithProperties).GetRuntimeProperty("StringProperty");
@@ -855,7 +853,7 @@ public void When_asserting_a_String_property_does_not_returnOfT_an_Int32_it_succ
         }
 
         [Fact]
-        public void When_asserting_a_String_property_does_not_returnsOfT_a_String_it_throw_with_a_useful_message()
+        public void When_asserting_a_string_property_does_not_returnsOfT_a_String_it_throw_with_a_useful_message()
         {
             // Arrange
             PropertyInfo propertyInfo = typeof(ClassWithProperties).GetRuntimeProperty("StringProperty");
@@ -865,7 +863,7 @@ public void When_asserting_a_String_property_does_not_returnsOfT_a_String_it_thr
 
             // Assert
             action.Should().Throw<XunitException>()
-                .WithMessage("Expected Type of property StringProperty not to be*String*because we want to test the error " +
+                .WithMessage("Expected type of property ClassWithProperties.StringProperty not to be*String*because we want to test the error " +
                     "message, but it is.");
         }
     }
diff --git a/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorAssertionSpecs.cs
index cf3dca9c6c..650b56fd00 100644
--- a/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorAssertionSpecs.cs
@@ -1,4 +1,5 @@
 using System;
+using FluentAssertions.Execution;
 using FluentAssertions.Types;
 using Xunit;
 using Xunit.Sdk;
@@ -53,9 +54,9 @@ public void
                 .WithMessage("Expected all selected properties" +
                     " to be virtual because we want to test the error message," +
                     " but the following properties are not virtual:*" +
-                    "String FluentAssertions*ClassWithNonVirtualPublicProperties.PublicNonVirtualProperty*" +
-                    "String FluentAssertions*ClassWithNonVirtualPublicProperties.InternalNonVirtualProperty*" +
-                    "String FluentAssertions*ClassWithNonVirtualPublicProperties.ProtectedNonVirtualProperty");
+                    "ClassWithNonVirtualPublicProperties.PublicNonVirtualProperty*" +
+                    "ClassWithNonVirtualPublicProperties.InternalNonVirtualProperty*" +
+                    "ClassWithNonVirtualPublicProperties.ProtectedNonVirtualProperty");
         }
     }
 
@@ -159,9 +160,9 @@ public void
                 .WithMessage("Expected all selected properties to be decorated with" +
                     " FluentAssertions*DummyPropertyAttribute because we want to test the error message," +
                     " but the following properties are not:*" +
-                    "String FluentAssertions*ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty*" +
-                    "String FluentAssertions*ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.InternalProperty*" +
-                    "String FluentAssertions*ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.ProtectedProperty");
+                    "ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty*" +
+                    "ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.InternalProperty*" +
+                    "ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.ProtectedProperty");
         }
     }
 
@@ -236,8 +237,8 @@ public void When_a_read_only_property_is_expected_to_be_writable_it_should_throw
                 .WithMessage(
                     "Expected all selected properties to have a setter because we want to test the error message, " +
                     "but the following properties do not:*" +
-                    "String FluentAssertions*ClassWithReadOnlyProperties.ReadOnlyProperty*" +
-                    "String FluentAssertions*ClassWithReadOnlyProperties.ReadOnlyProperty2");
+                    "ClassWithReadOnlyProperties.ReadOnlyProperty*" +
+                    "ClassWithReadOnlyProperties.ReadOnlyProperty2");
         }
 
         [Fact]
@@ -271,8 +272,8 @@ public void When_a_writable_property_is_expected_to_be_read_only_it_should_throw
                 .WithMessage(
                     "Expected selected properties to not have a setter because we want to test the error message, " +
                     "but the following properties do:*" +
-                    "String FluentAssertions*ClassWithWritableProperties.ReadWriteProperty*" +
-                    "String FluentAssertions*ClassWithWritableProperties.ReadWriteProperty2");
+                    "ClassWithWritableProperties.ReadWriteProperty*" +
+                    "ClassWithWritableProperties.ReadWriteProperty2");
         }
 
         [Fact]
@@ -295,7 +296,7 @@ public class Miscellaneous
         public void When_accidentally_using_equals_it_should_throw_a_helpful_error()
         {
             // Arrange
-            var someObject = new PropertyInfoSelectorAssertions();
+            var someObject = new PropertyInfoSelectorAssertions(AssertionChain.GetOrCreate());
 
             // Act
             var action = () => someObject.Equals(null);
diff --git a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveExplicitConversionOperator.cs b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveExplicitConversionOperator.cs
index 5eedb90a94..89fa79cdd3 100644
--- a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveExplicitConversionOperator.cs
+++ b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveExplicitConversionOperator.cs
@@ -1,4 +1,5 @@
 using System;
+using FluentAssertions.Common;
 using Xunit;
 using Xunit.Sdk;
 
@@ -19,15 +20,30 @@ public void When_asserting_a_type_has_an_explicit_conversion_operator_which_it_d
             var sourceType = typeof(TypeWithConversionOperators);
             var targetType = typeof(byte);
 
+            // Act / Assert
+            type.Should()
+                .HaveExplicitConversionOperator(sourceType, targetType)
+                .Which.Should()
+                .NotBeNull();
+        }
+
+        [Fact]
+        public void Can_chain_an_additional_assertion_on_the_implicit_conversion_operator()
+        {
+            // Arrange
+            var type = typeof(TypeWithConversionOperators);
+            var sourceType = typeof(TypeWithConversionOperators);
+            var targetType = typeof(byte);
+
             // Act
-            Action act = () =>
-                type.Should()
-                    .HaveExplicitConversionOperator(sourceType, targetType)
-                    .Which.Should()
-                    .NotBeNull();
+            Action act = () => type
+                .Should().HaveExplicitConversionOperator(sourceType, targetType)
+                .Which.Should().HaveAccessModifier(CSharpAccessModifier.Private);
 
             // Assert
-            act.Should().NotThrow();
+            act.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected method explicit operator Byte(TypeWithConversionOperators) to be Private, but it is Public.");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveImplicitConversionOperator.cs b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveImplicitConversionOperator.cs
index d5ef12601b..f3194619e9 100644
--- a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveImplicitConversionOperator.cs
+++ b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveImplicitConversionOperator.cs
@@ -1,4 +1,5 @@
 using System;
+using FluentAssertions.Common;
 using Xunit;
 using Xunit.Sdk;
 
@@ -118,6 +119,24 @@ public void When_asserting_a_type_has_an_implicit_conversion_operatorOfT_which_i
             act.Should().NotThrow();
         }
 
+        [Fact]
+        public void Can_chain_an_additional_assertion_on_the_implicit_conversion_operator()
+        {
+            // Arrange
+            var type = typeof(TypeWithConversionOperators);
+
+            // Act
+            Action act = () =>
+                type.Should()
+                    .HaveImplicitConversionOperator<TypeWithConversionOperators, int>()
+                    .Which.Should()
+                    .HaveAccessModifier(CSharpAccessModifier.Internal);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected method implicit operator Int32(TypeWithConversionOperators) to be Internal, but it is Public.");
+        }
+
         [Fact]
         public void When_asserting_a_type_has_an_implicit_conversion_operatorOfT_which_it_does_not_it_fails()
         {
diff --git a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveProperty.cs b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveProperty.cs
index fe7f4cbb6a..543f439ff3 100644
--- a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveProperty.cs
+++ b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveProperty.cs
@@ -30,6 +30,21 @@ public void When_asserting_a_type_has_a_property_which_it_does_then_it_succeeds(
             act.Should().NotThrow();
         }
 
+        [Fact]
+        public void The_name_of_the_property_is_passed_to_the_chained_assertion()
+        {
+            // Arrange
+            var type = typeof(ClassWithMembers);
+
+            // Act
+            Action act = () => type
+                .Should().HaveProperty(typeof(string), "PrivateWriteProtectedReadProperty")
+                .Which.Should().NotBeWritable();
+
+            // Assert
+            act.Should().Throw<XunitException>("Expected property PrivateWriteProtectedReadProperty not to have a setter.");
+        }
+
         [Fact]
         public void When_asserting_a_type_has_a_property_which_it_does_not_it_fails()
         {
@@ -42,7 +57,7 @@ public void When_asserting_a_type_has_a_property_which_it_does_not_it_fails()
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected String *ClassWithNoMembers.PublicProperty to exist *failure message*, but it does not.");
+                .WithMessage("Expected ClassWithNoMembers to have a property PublicProperty of type String because we want to test the failure message, but it does not.");
         }
 
         [Fact]
@@ -58,9 +73,8 @@ public void When_asserting_a_type_has_a_property_which_it_has_with_a_different_t
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected String *.ClassWithMembers.PrivateWriteProtectedReadProperty to be of type System.Int32 " +
-                    "*failure message*, but it is not.");
+                .WithMessage("Expected property PrivateWriteProtectedReadProperty " +
+                    "to be of type System.Int32 because we want to test the failure message, but it is not.");
         }
 
         [Fact]
@@ -75,7 +89,7 @@ public void When_subject_is_null_have_property_should_fail()
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected String type.PublicProperty to exist *failure message*, but type is <null>.");
+                .WithMessage("Cannot determine if a type has a property named PublicProperty if the type is <null>.");
         }
 
         [Fact]
@@ -184,8 +198,7 @@ public void When_asserting_a_type_does_not_have_a_property_which_it_does_not_it_
             var type = typeof(ClassWithoutMembers);
 
             // Act
-            Action act = () =>
-                type.Should().NotHaveProperty("Property");
+            Action act = () => type.Should().NotHaveProperty("Property");
 
             // Assert
             act.Should().NotThrow();
@@ -203,9 +216,7 @@ public void When_asserting_a_type_does_not_have_a_property_which_it_does_it_fail
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected String *.ClassWithMembers.PrivateWriteProtectedReadProperty to not exist *failure message*" +
-                    ", but it does.");
+                .WithMessage("Did not expect ClassWithMembers to have a property PrivateWriteProtectedReadProperty because we want to test the failure message, but it does.");
         }
 
         [Fact]
@@ -220,7 +231,7 @@ public void When_subject_is_null_not_have_property_should_fail()
 
             // Assert
             act.Should().Throw<XunitException>()
-                .WithMessage("Expected type.PublicProperty to not exist *failure message*, but type is <null>.");
+                .WithMessage("Cannot determine if a type has an unexpected property named PublicProperty if the type is <null>.");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Xml/XDocumentAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Xml/XDocumentAssertionSpecs.cs
index f09023363c..0c7270b0b0 100644
--- a/Tests/FluentAssertions.Specs/Xml/XDocumentAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Xml/XDocumentAssertionSpecs.cs
@@ -990,6 +990,25 @@ public void When_asserting_document_has_root_element_with_ns_but_it_does_not_it_
                 "Expected theDocument to have root element \"{http://www.example.com/2012/test}unknown\", but found <parent>…</parent>.");
         }
 
+        [Fact]
+        public void Can_chain_another_assertion_on_the_root_element()
+        {
+            // Arrange
+            var theDocument = XDocument.Parse(
+                """
+                <parent>
+                    <child />
+                </parent>
+                """);
+
+            // Act
+            Action act = () => theDocument.Should().HaveRoot("parent").Which.Should().HaveElement("unknownChild");
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage(
+                "Expected theDocument/parent to have child element*unknownChild*");
+        }
+
         [Fact]
         public void When_asserting_document_has_root_element_with_ns_but_it_does_not_it_should_fail_with_descriptive_message()
         {
@@ -1036,6 +1055,24 @@ public void When_document_has_the_expected_child_element_it_should_not_throw_and
             element.Should().BeSameAs(document.Element("parent").Element("child"));
         }
 
+        [Fact]
+        public void Can_chain_another_assertion_on_the_root_element()
+        {
+            // Arrange
+            var document = XDocument.Parse(
+                """
+                <parent>
+                    <child />
+                </parent>
+                """);
+
+            // Act
+            var act = () => document.Should().HaveElement("child").Which.Should().HaveElement("grandChild");
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage("Expected document/child to have child element*grandChild*");
+        }
+
         [Fact]
         public void When_asserting_document_has_root_with_child_element_but_it_does_not_it_should_fail()
         {
diff --git a/qodana.yaml b/qodana.yaml
index 3f248f5a33..c4d518d378 100644
--- a/qodana.yaml
+++ b/qodana.yaml
@@ -33,6 +33,7 @@ exclude:
   - name: SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
   - name: UnusedMemberInSuper.Global
   - name: ArrangeAccessorOwnerBody
+  - name: ParameterHidesMember
   - name: CollectionNeverUpdated.Local
     paths:
       - Tests