BeEquivalentTo For().Exclude() does not work for complex type hierarchies

[marcin-dardzinski]

Description

I have a case where a base class is generic and the generic argument should be the class deriving from it. I'm trying to compare an object graph and exclude one property from this type, from a collection, i.e.
ShouldBeEquvalentTo(..., o => o.For(a => a.BS).Exclude(b => b.X.Y)
X is my type and Y is a property I want to exclude.
Note that if I have just one object and not the collection, it works fine.

Complete minimal example reproducing the issue

using System;
using FluentAssertions;
using Xunit;

namespace Tests
{
    public class FluentAssertionsTests
    {
        [Fact]
        public void Should_exclude_property()
        {
            var d1 = new Derived
            {
                Value = 5,
                LastModified = new DateTime(2022, 9, 5, 8, 0, 0),
            };

            var d2 = new Derived
            {
                Value = 5,
                LastModified = new DateTime(2022, 9, 5, 9, 0, 0),
            };

            d1.Should().BeEquivalentTo(d2, opts => opts.Excluding(d => d.LastModified));

            var foo = new Foo
            {
                Bars = new Bar[]
                {
                    new()
                    {
                        X = 1,
                        Y = d1,
                    },
                },
            };

            foo.Should()
                .BeEquivalentTo(
                    new
                    {
                        Bars = new[]
                        {
                            new
                            {
                                X = 1,
                                Y = d2,
                            },
                        },
                    },
                    opts => opts.For(x => x.Bars).Exclude(b => b.Y.LastModified));
        }

        public abstract class Base<TSelf>
            where TSelf : Base<TSelf>
        {
            public DateTime LastModified { get; set; }
        }

        public class Derived : Base<Derived>
        {
            public int Value { get; set; }
        }

        internal class Foo
        {
            public Bar[]? Bars { get; set; } = default!;
        }

        internal class Bar
        {
            public int X { get; set; }
            public Derived Y { get; set; } = default!;
        }
    }
}

Expected behavior:

The test passes, objects are equivalent except for foo.Bars[0].Y.LastModified.

Actual behavior:

The test fails with the following error:

Expected property foo.Bars[0].Y.LastModified to be <2022-09-05 09:00:00>, but found <2022-09-05 08:00:00>.

With configuration:
- Use declared types and members
- Compare enums by value
- Compare tuples by their properties
- Compare anonymous types by their properties
- Compare records by their members
- Include non-browsable members
- Exclude member Bars[]Y.LastModified
- Match member by name (or throw)
- Be strict about the order of items in byte arrays
- Without automatic conversion.

Versions

FluentAssertions: 6.7.0
.NET 6.0 (sdk: 6.0.400, runtime: 6.0.8)

[dennisdoomen]

@whymatter could this be caused by the same problem as is mentioned in #1919 ?

[whymatter]

Sorry I missed the @ guys ...
We can close this as it works since 6.8.0 (this fixed it: #1953)
@dennisdoomen @marcin-dardzinski

[jnyrup]

I can confirm that the included test fails with 6.7.0 and passes with 6.8.0