diff --git a/Src/FluentAssertions/Common/ObjectExtensions.cs b/Src/FluentAssertions/Common/ObjectExtensions.cs
index 7ba5e3bdc..e1bf0f003 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/Execution/AssertionChain.cs b/Src/FluentAssertions/Execution/AssertionChain.cs
index ef72a3f6b..ce085dcfe 100644
--- a/Src/FluentAssertions/Execution/AssertionChain.cs
+++ b/Src/FluentAssertions/Execution/AssertionChain.cs
@@ -253,12 +253,23 @@ private Continuation FailWith(Func<string> getFailureReason)
     public void OverrideCallerIdentifier(Func<string> getCallerIdentifier)
     {
         this.getCallerIdentifier = getCallerIdentifier;
+        HasOverriddenCallerIdentifier = true;
     }
 
     public AssertionChain WithCallerPostfix(string postfix)
     {
         var originalCallerIdentifier = getCallerIdentifier;
         getCallerIdentifier = () => originalCallerIdentifier() + postfix;
+        HasOverriddenCallerIdentifier = true;
+
+        return this;
+    }
+
+    public AssertionChain WithCallerPrefix(string prefix)
+    {
+        var originalCallerIdentifier = getCallerIdentifier;
+        getCallerIdentifier = () => prefix + originalCallerIdentifier();
+        HasOverriddenCallerIdentifier = true;
 
         return this;
     }
@@ -305,4 +316,6 @@ public AssertionChain UsingLineBreaks
             return this;
         }
     }
+
+    public bool HasOverriddenCallerIdentifier { get; private set; }
 }
diff --git a/Src/FluentAssertions/Formatting/Formatter.cs b/Src/FluentAssertions/Formatting/Formatter.cs
index 93ba19030..4ac3f13bf 100644
--- a/Src/FluentAssertions/Formatting/Formatter.cs
+++ b/Src/FluentAssertions/Formatting/Formatter.cs
@@ -26,6 +26,7 @@ public static class Formatter
         new XElementValueFormatter(),
         new XAttributeValueFormatter(),
         new PropertyInfoFormatter(),
+        new MethodInfoFormatter(),
         new NullValueFormatter(),
         new GuidValueFormatter(),
         new DateTimeOffsetValueFormatter(),
diff --git a/Src/FluentAssertions/Formatting/MethodInfoFormatter.cs b/Src/FluentAssertions/Formatting/MethodInfoFormatter.cs
new file mode 100644
index 000000000..ad32c3199
--- /dev/null
+++ b/Src/FluentAssertions/Formatting/MethodInfoFormatter.cs
@@ -0,0 +1,31 @@
+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
+        {
+            formattedGraph.AddFragment($"{method!.DeclaringType!.Name + "." + method.Name}");
+        }
+    }
+}
diff --git a/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs b/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs
index c9746c290..7ec15ed75 100644
--- a/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs
+++ b/Src/FluentAssertions/Formatting/PropertyInfoFormatter.cs
@@ -18,6 +18,17 @@ public bool CanHandle(object value)
 
     public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
     {
-        formattedGraph.AddFragment(((PropertyInfo)value).Name);
+        var property = (PropertyInfo)value;
+
+        if (property is null)
+        {
+            formattedGraph.AddFragment("<null>");
+        }
+        else
+        {
+            var propTypeName = property.PropertyType.Name;
+
+            formattedGraph.AddFragment($"{propTypeName} {property.DeclaringType}.{property.Name}");
+        }
     }
 }
diff --git a/Src/FluentAssertions/Types/MethodBaseAssertions.cs b/Src/FluentAssertions/Types/MethodBaseAssertions.cs
index 7aaac75eb..3b7c995b5 100644
--- a/Src/FluentAssertions/Types/MethodBaseAssertions.cs
+++ b/Src/FluentAssertions/Types/MethodBaseAssertions.cs
@@ -47,17 +47,20 @@ public AndConstraint<TAssertions> HaveAccessModifier(
         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 (assertionChain.Succeeded)
         {
             CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
 
+            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);
@@ -90,10 +93,14 @@ public AndConstraint<TAssertions> NotHaveAccessModifier(CSharpAccessModifier acc
         {
             CSharpAccessModifier subjectAccessModifier = Subject.GetCSharpAccessModifier();
 
+            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/PropertyInfoAssertions.cs b/Src/FluentAssertions/Types/PropertyInfoAssertions.cs
index a1beee41d..11d3b9b80 100644
--- a/Src/FluentAssertions/Types/PropertyInfoAssertions.cs
+++ b/Src/FluentAssertions/Types/PropertyInfoAssertions.cs
@@ -4,6 +4,7 @@
 using System.Reflection;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
+using FluentAssertions.Formatting;
 
 namespace FluentAssertions.Types;
 
@@ -44,7 +45,7 @@ public AndConstraint<PropertyInfoAssertions> BeVirtual(
             assertionChain
                 .ForCondition(Subject.IsVirtual())
                 .BecauseOf(because, becauseArgs)
-                .FailWith($"Expected property {GetDescriptionFor(Subject)} to be virtual{{reason}}, but it is not.");
+                .FailWith("Expected property {0} to be virtual{{reason}}, but it is not.", Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -60,7 +61,8 @@ 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)
     {
         assertionChain
             .BecauseOf(because, becauseArgs)
@@ -72,7 +74,7 @@ public AndConstraint<PropertyInfoAssertions> NotBeVirtual([StringSyntax("Composi
             assertionChain
                 .ForCondition(!Subject.IsVirtual())
                 .BecauseOf(because, becauseArgs)
-                .FailWith($"Expected property {GetDescriptionFor(Subject)} not to be virtual{{reason}}, but it is.");
+                .FailWith("Expected property {0} not to be virtual{{reason}}, but it is.", Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -130,21 +132,17 @@ public AndConstraint<PropertyInfoAssertions> BeWritable(CSharpAccessModifier acc
         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!.CanWrite)
+            .BecauseOf(because, becauseArgs)
+            .FailWith("Expected {0} to have a setter {{reason}}.", assertionChain.HasOverriddenCallerIdentifier ? assertionChain.CallerIdentifier : Subject);
 
         if (assertionChain.Succeeded)
         {
-            assertionChain
-                .ForCondition(Subject!.CanWrite)
-                .BecauseOf(because, becauseArgs)
-                .FailWith(
-                    "Expected {context:property} {0} to have a setter{reason}.",
-                    Subject);
-
-            if (assertionChain.Succeeded)
-            {
-                Subject!.GetSetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
-            }
+            assertionChain.WithCallerPrefix("setter of ");
+            assertionChain.ReuseOnce();
+            Subject!.GetSetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -166,17 +164,11 @@ public AndConstraint<PropertyInfoAssertions> NotBeWritable(
         assertionChain
             .BecauseOf(because, becauseArgs)
             .ForCondition(Subject is not null)
-            .FailWith("Expected property not to have a setter{reason}, but {context:property} is <null>.");
-
-        if (assertionChain.Succeeded)
-        {
-            assertionChain
-                .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("Expected {0} not to have a setter {{reason}}.", Subject);
 
         return new AndConstraint<PropertyInfoAssertions>(this);
     }
@@ -191,7 +183,8 @@ 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)
     {
         assertionChain
             .BecauseOf(because, becauseArgs)
@@ -202,7 +195,7 @@ public AndConstraint<PropertyInfoAssertions> BeReadable([StringSyntax("Composite
         {
             assertionChain.ForCondition(Subject!.CanRead)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected property " + Subject.Name + " to have a getter{reason}, but it does not.");
+                .FailWith("Expected property {0}, to have a getter{reason}, but it does not.", Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -229,18 +222,15 @@ public AndConstraint<PropertyInfoAssertions> BeReadable(CSharpAccessModifier acc
         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 {0} to have a getter {{reason}}, but it does not.", Subject);
 
         if (assertionChain.Succeeded)
         {
-            assertionChain.ForCondition(Subject!.CanRead)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected property " + Subject.Name + " to have a getter{reason}, but it does not.");
-
-            if (assertionChain.Succeeded)
-            {
-                Subject!.GetGetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
-            }
+            Subject!.GetGetMethod(nonPublic: true).Should().HaveAccessModifier(accessModifier, because, becauseArgs);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -270,8 +260,7 @@ public AndConstraint<PropertyInfoAssertions> NotBeReadable(
                 .ForCondition(!Subject!.CanRead)
                 .BecauseOf(because, becauseArgs)
                 .FailWith(
-                    "Expected {context:property} {0} not to have a getter{reason}.",
-                    Subject);
+                    "Expected {0} not to have a getter {{reason}}.", Subject);
         }
 
         return new AndConstraint<PropertyInfoAssertions>(this);
@@ -303,8 +292,8 @@ public AndConstraint<PropertyInfoAssertions> Return(Type 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);
@@ -321,7 +310,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);
     }
@@ -353,7 +343,7 @@ public AndConstraint<PropertyInfoAssertions> NotReturn(Type propertyType,
             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);
@@ -370,24 +360,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);
+    internal 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 a4aa31bb5..4aca17468 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;
 
@@ -221,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 0af347192..55cf26d97 100644
--- a/Src/FluentAssertions/Types/TypeAssertions.cs
+++ b/Src/FluentAssertions/Types/TypeAssertions.cs
@@ -269,7 +269,7 @@ public AndWhich<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute>(
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="isMatchingAttributePredicate"/> is <see langword="null"/>.</exception>
-    public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute>(
+    public AndWhich<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute>(
         Expression<Func<TAttribute, bool>> isMatchingAttributePredicate,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TAttribute : Attribute
@@ -287,7 +287,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute
                 "Expected type {0} to be decorated with {1} that matches {2}{reason}, but no matching attribute was found.",
                 Subject, typeof(TAttribute), isMatchingAttributePredicate);
 
-        return new AndWhichConstraint<TypeAssertions, TAttribute>(this, attributes);
+        return new AndWhich<TypeAssertions, TAttribute>(this, attributes);
     }
 
     /// <summary>
@@ -300,7 +300,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWith<TAttribute
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<TAttribute>(
+    public AndWhich<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<TAttribute>(
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TAttribute : Attribute
     {
@@ -312,7 +312,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<T
             .FailWith("Expected type {0} to be decorated with or inherit {1}{reason}, but the attribute was not found.",
                 Subject, typeof(TAttribute));
 
-        return new AndWhichConstraint<TypeAssertions, TAttribute>(this, attributes);
+        return new AndWhich<TypeAssertions, TAttribute>(this, attributes);
     }
 
     /// <summary>
@@ -330,7 +330,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<T
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="isMatchingAttributePredicate"/> is <see langword="null"/>.</exception>
-    public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<TAttribute>(
+    public AndWhich<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<TAttribute>(
         Expression<Func<TAttribute, bool>> isMatchingAttributePredicate,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
         where TAttribute : Attribute
@@ -348,7 +348,7 @@ public AndWhichConstraint<TypeAssertions, TAttribute> BeDecoratedWithOrInherit<T
                 "Expected type {0} to be decorated with or inherit {1} that matches {2}{reason}" +
                 ", but no matching attribute was found.", Subject, typeof(TAttribute), isMatchingAttributePredicate);
 
-        return new AndWhichConstraint<TypeAssertions, TAttribute>(this, attributes);
+        return new AndWhich<TypeAssertions, TAttribute>(this, attributes);
     }
 
     /// <summary>
@@ -889,7 +889,7 @@ public AndConstraint<TypeAssertions> NotBeStatic([StringSyntax("CompositeFormat"
     /// <exception cref="ArgumentNullException"><paramref name="propertyType"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
-    public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveProperty(
+    public AndWhich<TypeAssertions, PropertyInfo> HaveProperty(
         Type propertyType, string name,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
@@ -907,7 +907,6 @@ public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveProperty(
         if (assertionChain.Succeeded)
         {
             propertyInfo = Subject.FindPropertyByName(name);
-            var propertyInfoDescription = PropertyInfoAssertions.GetDescriptionFor(propertyInfo);
 
             assertionChain
                 .BecauseOf(because, becauseArgs)
@@ -915,10 +914,10 @@ public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveProperty(
                 .FailWith($"Expected {propertyType.Name} {Subject}.{name} to exist{{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 {0} to be of type {propertyType}{{reason}}, but it is not.", propertyInfo);
         }
 
-        return new AndWhichConstraint<TypeAssertions, PropertyInfo>(this, propertyInfo);
+        return new AndWhich<TypeAssertions, PropertyInfo>(this, propertyInfo);
     }
 
     /// <summary>
@@ -936,7 +935,7 @@ public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveProperty(
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
-    public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveProperty<TProperty>(
+    public AndWhich<TypeAssertions, PropertyInfo> HaveProperty<TProperty>(
         string name, [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         return HaveProperty(typeof(TProperty), name, because, becauseArgs);
@@ -968,12 +967,11 @@ public AndConstraint<TypeAssertions> NotHaveProperty(string name,
         if (assertionChain.Succeeded)
         {
             PropertyInfo propertyInfo = Subject.FindPropertyByName(name);
-            var propertyInfoDescription = PropertyInfoAssertions.GetDescriptionFor(propertyInfo);
 
             assertionChain
                 .BecauseOf(because, becauseArgs)
                 .ForCondition(propertyInfo is null)
-                .FailWith($"Expected {propertyInfoDescription} to not exist{{reason}}, but it does.");
+                .FailWith("Expected {0} to not exist{{reason}}, but it does.", propertyInfo);
         }
 
         return new AndConstraint<TypeAssertions>(this);
@@ -1275,18 +1273,20 @@ public AndConstraint<TypeAssertions> NotHaveExplicitMethod<TInterface>(
     /// </param>
     /// <exception cref="ArgumentNullException"><paramref name="indexerType"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="parameterTypes"/> is <see langword="null"/>.</exception>
-    public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveIndexer(
+    public AndWhich<TypeAssertions, PropertyInfo> HaveIndexer(
         Type indexerType, IEnumerable<Type> parameterTypes,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         Guard.ThrowIfArgumentIsNull(indexerType);
         Guard.ThrowIfArgumentIsNull(parameterTypes);
 
+        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;
@@ -1294,20 +1294,20 @@ public AndWhichConstraint<TypeAssertions, PropertyInfo> HaveIndexer(
         if (assertionChain.Succeeded)
         {
             propertyInfo = Subject.GetIndexerByParameterTypes(parameterTypes);
-            var propertyInfoDescription = PropertyInfoAssertions.GetDescriptionFor(propertyInfo);
 
             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 AndWhich<TypeAssertions, PropertyInfo>(this, propertyInfo, assertionChain,
+            $"[{parameterString}]");
     }
 
     /// <summary>
diff --git a/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
index 0bd236d7b..debf5e2c0 100644
--- a/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
@@ -191,7 +191,8 @@ public void Can_continue_assertions_on_the_found_type()
                 .Which.Should().BeDecoratedWith<SerializableAttribute>();
 
             // Assert
-            act.Should().Throw<XunitException>().WithMessage("blah");
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected*WellKnownClassWithAttribute*decorated*SerializableAttribute*not found.");
         }
 
         [Fact]
diff --git a/Tests/FluentAssertions.Specs/Types/MethodBaseAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodBaseAssertionSpecs.cs
index 84a2bf8dc..997f09fb2 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 e4479a345..9ca993568 100644
--- a/Tests/FluentAssertions.Specs/Types/PropertyInfoAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Types/PropertyInfoAssertionSpecs.cs
@@ -428,7 +428,7 @@ public void When_asserting_a_readwrite_property_is_not_writable_it_fails_with_us
             action
                 .Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected propertyInfo ReadWriteProperty not to have a setter because we want to test the error message.");
+                    "Expected ReadWriteProperty not to have a setter because we want to test the error message.");
         }
 
         [Fact]
@@ -444,7 +444,7 @@ public void When_asserting_a_writeonly_property_is_not_writable_it_fails_with_us
             action
                 .Should().Throw<XunitException>()
                 .WithMessage(
-                    "Expected propertyInfo WriteOnlyProperty not to have a setter because we want to test the error message.");
+                    "Expected WriteOnlyProperty not to have a setter because we want to test the error message.");
         }
 
         [Fact]
@@ -459,7 +459,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>.");
         }
     }
 
@@ -587,7 +587,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]
@@ -652,7 +652,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 ReadOnlyProperty to have a setter.");
         }
 
         [Fact]
@@ -667,7 +667,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]
diff --git a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveIndexer.cs b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveIndexer.cs
index 9f3bd5022..bf1b69182 100644
--- a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveIndexer.cs
+++ b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveIndexer.cs
@@ -23,7 +23,7 @@ public void When_asserting_a_type_has_an_indexer_which_it_does_then_it_succeeds(
                 type.Should()
                     .HaveIndexer(typeof(string), [typeof(string)])
                     .Which.Should()
-                    .BeWritable(CSharpAccessModifier.Internal)
+                    .BeWritable(CSharpAccessModifier.Public)
                     .And.BeReadable(CSharpAccessModifier.Private);
 
             // Assert
diff --git a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveProperty.cs b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.HaveProperty.cs
index fe7f4cbb6..a7d96a9b0 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()
         {