Cherry pick fixes from develop to master

Directory.Build.props

@@ -2,6 +2,7 @@
   <PropertyGroup>
     <LangVersion>11.0</LangVersion>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <WarningsNotAsErrors>$(WarningsNotAsErrors);NU1902;NU1903</WarningsNotAsErrors> <!-- disable EOL warnings -->
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
 
@@ -13,7 +14,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(TargetFramework)' == 'net6.0'">
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
-    <AnalysisLevel>latest</AnalysisLevel>
+    <AnalysisLevel>7.0</AnalysisLevel>
     <AnalysisMode>All</AnalysisMode>
     <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
   </PropertyGroup>

Src/FluentAssertions/CallerIdentifier.cs

@@ -26,9 +26,7 @@ public static string DetermineCallerIdentity()
         {
             var stack = new StackTrace(fNeedFileInfo: true);
 
-            var allStackFrames = stack.GetFrames()
-                .Where(frame => frame is not null && !IsCompilerServices(frame))
-                .ToArray();
+            var allStackFrames = GetFrames(stack);
 
             int searchStart = allStackFrames.Length - 1;
 
@@ -55,7 +53,8 @@ public static string DetermineCallerIdentity()
                 if (frame.GetMethod() is not null
                     && !IsDynamic(frame)
                     && !IsDotNet(frame)
-                    && !IsCustomAssertion(frame))
+                    && !IsCustomAssertion(frame)
+                    && !IsCurrentAssembly(frame))
                 {
                     caller = ExtractVariableNameFrom(frame);
                     break;
@@ -81,9 +80,7 @@ public StackFrameReference()
         {
             var stack = new StackTrace();
 
-            var allStackFrames = stack.GetFrames()
-                .Where(frame => frame is not null && !IsCompilerServices(frame))
-                .ToArray();
+            var allStackFrames = GetFrames(stack);
 
             int firstUserCodeFrameIndex = 0;
 
@@ -114,9 +111,7 @@ internal static IDisposable OverrideStackSearchUsingCurrentScope()
 
     internal static bool OnlyOneFluentAssertionScopeOnCallStack()
     {
-        var allStackFrames = new StackTrace().GetFrames()
-            .Where(frame => frame is not null && !IsCompilerServices(frame))
-            .ToArray();
+        var allStackFrames = GetFrames(new StackTrace());
 
         int firstNonFluentAssertionsStackFrameIndex = Array.FindIndex(
             allStackFrames,
@@ -256,4 +251,18 @@ private static bool IsBooleanLiteral(string candidate)
     {
         return candidate is "true" or "false";
     }
+
+    private static StackFrame[] GetFrames(StackTrace stack)
+    {
+        var frames = stack.GetFrames();
+#if !NET6_0_OR_GREATER
+        if (frames == null)
+        {
+            return Array.Empty<StackFrame>();
+        }
+#endif
+        return frames
+            .Where(frame => !IsCompilerServices(frame))
+            .ToArray();
+    }
 }

Src/FluentAssertions/Collections/GenericCollectionAssertions.cs

@@ -79,7 +79,7 @@ public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeAssignabl
             Execute.Assertion
                 .BecauseOf(because, becauseArgs)
                 .WithExpectation("Expected type to be {0}{reason}, ", typeof(TExpectation).FullName)
-                .ForCondition(Subject.All(x => x is not null))
+                .ForCondition(Subject!.All(x => x is not null))
                 .FailWith("but found a null element.")
                 .Then
                 .ForCondition(Subject.All(x => typeof(TExpectation).IsAssignableFrom(GetType(x))))
@@ -226,7 +226,7 @@ public AndWhichConstraint<TAssertions, IEnumerable<TExpectation>> AllBeOfType<TE
             Execute.Assertion
                 .BecauseOf(because, becauseArgs)
                 .WithExpectation("Expected type to be {0}{reason}, ", typeof(TExpectation).FullName)
-                .ForCondition(Subject.All(x => x is not null))
+                .ForCondition(Subject!.All(x => x is not null))
                 .FailWith("but found a null element.")
                 .Then
                 .ForCondition(Subject.All(x => typeof(TExpectation) == GetType(x)))
@@ -286,15 +286,16 @@ public AndConstraint<TAssertions> AllBeOfType(Type expectedType, string because
     /// </param>
     public AndConstraint<TAssertions> BeEmpty(string because = "", params object[] becauseArgs)
     {
+        var singleItemArray = Subject?.Take(1).ToArray();
         Execute.Assertion
             .BecauseOf(because, becauseArgs)
             .WithExpectation("Expected {context:collection} to be empty{reason}, ")
-            .Given(() => Subject)
+            .Given(() => singleItemArray)
             .ForCondition(subject => subject is not null)
             .FailWith("but found <null>.")
             .Then
-            .ForCondition(subject => !subject.Any())
-            .FailWith("but found {0}.", Subject)
+            .ForCondition(subject => subject.Length == 0)
+            .FailWith("but found at least one item {0}.", singleItemArray)
             .Then
             .ClearExpectation();
 
@@ -639,13 +640,14 @@ public AndConstraint<SubsequentOrderingAssertions<T>> BeInDescendingOrder(Func<T
     /// </param>
     public AndConstraint<TAssertions> BeNullOrEmpty(string because = "", params object[] becauseArgs)
     {
-        var nullOrEmpty = Subject is null || !Subject.Any();
+        var singleItemArray = Subject?.Take(1).ToArray();
+        var nullOrEmpty = singleItemArray is null || singleItemArray.Length == 0;
 
         Execute.Assertion.ForCondition(nullOrEmpty)
             .BecauseOf(because, becauseArgs)
             .FailWith(
-                "Expected {context:collection} to be null or empty{reason}, but found {0}.",
-                Subject);
+                "Expected {context:collection} to be null or empty{reason}, but found at least one item {0}.",
+                singleItemArray);
 
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
@@ -748,7 +750,7 @@ public AndWhichConstraint<TAssertions, T> Contain(Expression<Func<T, bool>> pred
             Func<T, bool> func = predicate.Compile();
 
             Execute.Assertion
-                .ForCondition(Subject.Any(func))
+                .ForCondition(Subject!.Any(func))
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context:collection} {0} to have an item matching {1}{reason}.", Subject, predicate.Body);
 
@@ -786,7 +788,7 @@ public AndConstraint<TAssertions> Contain(IEnumerable<T> expected, string becaus
 
         if (success)
         {
-            IEnumerable<T> missingItems = expectedObjects.Except(Subject);
+            IEnumerable<T> missingItems = expectedObjects.Except(Subject!);
 
             if (missingItems.Any())
             {
@@ -811,13 +813,18 @@ public AndConstraint<TAssertions> Contain(IEnumerable<T> expected, string becaus
     }
 
     /// <summary>
-    /// Asserts that a collection of objects contains at least one object equivalent to another object.
+    /// Asserts that at least one element in the collection is equivalent to <paramref name="expectation"/>.
     /// </summary>
     /// <remarks>
-    /// Objects within the collection are equivalent to the expected object when both object graphs have equally named properties with the same
-    /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
-    /// and the result is equal.
+    /// <para>
+    /// <b>Important:</b> You cannot use this method to assert whether a subset of the collection is equivalent to the <paramref name="expectation"/>.
+    /// This usually means that the expectation is meant to be a <i>single</i> item.
+    /// </para>
+    /// <para>
+    /// By default, objects within the collection are seen as equivalent to the expected object when both object graphs have equally named properties with the same
+    /// value, irrespective of the type of those objects.
     /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
+    /// </para>
     /// </remarks>
     /// <param name="expectation">The expected element.</param>
     /// <param name="because">
@@ -834,13 +841,18 @@ public AndWhichConstraint<TAssertions, T> ContainEquivalentOf<TExpectation>(TExp
     }
 
     /// <summary>
-    /// Asserts that a collection of objects contains at least one object equivalent to another object.
+    /// Asserts that at least one element in the collection is equivalent to <paramref name="expectation"/>.
     /// </summary>
     /// <remarks>
-    /// Objects within the collection are equivalent to the expected object when both object graphs have equally named properties with the same
-    /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
-    /// and the result is equal.
+    /// <para>
+    /// <b>Important:</b> You cannot use this method to assert whether a subset of the collection is equivalent to the <paramref name="expectation"/>.
+    /// This usually means that the expectation is meant to be a <i>single</i> item.
+    /// </para>
+    /// <para>
+    /// By default, objects within the collection are seen as equivalent to the expected object when both object graphs have equally named properties with the same
+    /// value, irrespective of the type of those objects.
     /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
+    /// </para>
     /// </remarks>
     /// <param name="expectation">The expected element.</param>
     /// <param name="config">
@@ -875,7 +887,7 @@ public AndWhichConstraint<TAssertions, T> ContainEquivalentOf<TExpectation>(TExp
             using var scope = new AssertionScope();
             scope.AddReportable("configuration", () => options.ToString());
 
-            foreach (T actualItem in Subject)
+            foreach (T actualItem in Subject!)
             {
                 var context =
                     new EquivalencyValidationContext(Node.From<TExpectation>(() => AssertionScope.Current.CallerIdentity),
@@ -1375,7 +1387,7 @@ public AndConstraint<TAssertions> HaveCount(int expected, string because = "", p
 
         if (success)
         {
-            int actualCount = Subject.Count();
+            int actualCount = Subject!.Count();
 
             Execute.Assertion
                 .ForCondition(actualCount == expected)
@@ -1415,7 +1427,7 @@ public AndConstraint<TAssertions> HaveCount(Expression<Func<int, bool>> countPre
         {
             Func<int, bool> compiledPredicate = countPredicate.Compile();
 
-            int actualCount = Subject.Count();
+            int actualCount = Subject!.Count();
 
             if (!compiledPredicate(actualCount))
             {
@@ -1579,7 +1591,7 @@ public AndWhichConstraint<TAssertions, T> HaveElementAt(int index, T element, st
 
         if (success)
         {
-            if (index < Subject.Count())
+            if (index < Subject!.Count())
             {
                 actual = Subject.ElementAt(index);
 
@@ -1731,7 +1743,7 @@ public AndConstraint<TAssertions> IntersectWith(IEnumerable<T> otherCollection,
 
         if (success)
         {
-            IEnumerable<T> sharedItems = Subject.Intersect(otherCollection);
+            IEnumerable<T> sharedItems = Subject!.Intersect(otherCollection);
 
             Execute.Assertion
                 .BecauseOf(because, becauseArgs)
@@ -1844,7 +1856,7 @@ public AndConstraint<TAssertions> NotBeEquivalentTo<TExpectation>(IEnumerable<TE
 
         using (var scope = new AssertionScope())
         {
-            Subject.Should().BeEquivalentTo(unexpected, config);
+            BeEquivalentTo(unexpected, config);
 
             failures = scope.Discard();
         }
@@ -2225,7 +2237,7 @@ public AndConstraint<TAssertions> NotContain(Expression<Func<T, bool>> predicate
         if (success)
         {
             Func<T, bool> compiledPredicate = predicate.Compile();
-            IEnumerable<T> unexpectedItems = Subject.Where(item => compiledPredicate(item));
+            IEnumerable<T> unexpectedItems = Subject!.Where(item => compiledPredicate(item));
 
             Execute.Assertion
                 .BecauseOf(because, becauseArgs)
@@ -2267,7 +2279,7 @@ public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected, string b
 
         if (success)
         {
-            IEnumerable<T> foundItems = unexpectedObjects.Intersect(Subject);
+            IEnumerable<T> foundItems = unexpectedObjects.Intersect(Subject!);
 
             if (foundItems.Any())
             {
@@ -2292,13 +2304,18 @@ public AndConstraint<TAssertions> NotContain(IEnumerable<T> unexpected, string b
     }
 
     /// <summary>
-    /// Asserts that a collection of objects does not contain any object equivalent to another object.
+    /// Asserts that no element in the collection is equivalent to <paramref name="unexpected"/>.
     /// </summary>
     /// <remarks>
-    /// Objects within the collection are equivalent to the expected object when both object graphs have equally named properties with the same
-    /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
-    /// and the result is equal.
+    /// <para>
+    /// <b>Important:</b> You cannot use this method to assert whether a subset of the collection is not equivalent to the <paramref name="unexpected"/>.
+    /// This usually means that the expectation is meant to be a <i>single</i> item.
+    /// </para>
+    /// <para>
+    /// By default, objects within the collection are seen as not equivalent to the expected object when both object graphs have unequally named properties with the same
+    /// value, irrespective of the type of those objects.
     /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
+    /// </para>
     /// </remarks>
     /// <param name="unexpected">The unexpected element.</param>
     /// <param name="because">
@@ -2315,13 +2332,18 @@ public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectat
     }
 
     /// <summary>
-    /// Asserts that a collection of objects does not contain any object equivalent to another object.
+    /// Asserts that no element in the collection is equivalent to <paramref name="unexpected"/>.
     /// </summary>
     /// <remarks>
-    /// Objects within the collection are equivalent to the expected object when both object graphs have equally named properties with the same
-    /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
-    /// and the result is equal.
+    /// <para>
+    /// <b>Important:</b> You cannot use this method to assert whether a subset of the collection is not equivalent to the <paramref name="unexpected"/>.
+    /// This usually means that the expectation is meant to be a <i>single</i> item.
+    /// </para>
+    /// <para>
+    /// By default, objects within the collection are seen as not equivalent to the expected object when both object graphs have unequally named properties with the same
+    /// value, irrespective of the type of those objects.
     /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
+    /// </para>
     /// </remarks>
     /// <param name="unexpected">The unexpected element.</param>
     /// <param name="config">
@@ -2361,7 +2383,7 @@ public AndConstraint<TAssertions> NotContainEquivalentOf<TExpectation>(TExpectat
             {
                 int index = 0;
 
-                foreach (T actualItem in Subject)
+                foreach (T actualItem in Subject!)
                 {
                     var context =
                         new EquivalencyValidationContext(Node.From<TExpectation>(() => AssertionScope.Current.CallerIdentity),
@@ -2598,7 +2620,7 @@ public AndConstraint<TAssertions> NotContainNulls<TKey>(Expression<Func<T, TKey>
         {
             Func<T, TKey> compiledPredicate = predicate.Compile();
 
-            T[] values = Subject
+            T[] values = Subject!
                 .Where(e => compiledPredicate(e) is null)
                 .ToArray();
 
@@ -2631,7 +2653,7 @@ public AndConstraint<TAssertions> NotContainNulls(string because = "", params ob
 
         if (success)
         {
-            int[] indices = Subject
+            int[] indices = Subject!
                 .Select((item, index) => (Item: item, Index: index))
                 .Where(e => e.Item is null)
                 .Select(e => e.Index)
@@ -2870,7 +2892,7 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems<TKey>(Expression<Func<T, T
         {
             Func<T, TKey> compiledPredicate = predicate.Compile();
 
-            IGrouping<TKey, T>[] groupWithMultipleItems = Subject
+            IGrouping<TKey, T>[] groupWithMultipleItems = Subject!
                 .GroupBy(compiledPredicate)
                 .Where(g => g.Count() > 1)
                 .ToArray();
@@ -2920,7 +2942,7 @@ public AndConstraint<TAssertions> OnlyHaveUniqueItems(string because = "", param
 
         if (success)
         {
-            IEnumerable<T> groupWithMultipleItems = Subject
+            IEnumerable<T> groupWithMultipleItems = Subject!
                 .GroupBy(o => o)
                 .Where(g => g.Count() > 1)
                 .Select(g => g.Key);