While correctness is more important that speed, I'm curious what effect deletion of the cache has.

I thought about that, but the GetEqualityStrategy method uses its own cache. The only concern I had is that the IsRecord method might be expensive as well, but looking at the build time, it doesn't seem to have such an effect. I'll run a profile session on my big machine when I have time.

I added the caching of OverridesEquals in 12bd297.
I've tried to rerun the benchmark code from #817 before and after this PR to get a sense of the impact.
Note, I haven't given much thought into, if this the most representative benchmark.

using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Jobs;
using FluentAssertions;

namespace Benchmarks
{
    [MemoryDiagnoser]
    [SimpleJob(RuntimeMoniker.Net472)]
    [SimpleJob(RuntimeMoniker.Net50)]
    public class PR817
    {
        public class Complex
        {
            public int A { get; set; }
            public Complex B { get; set; }
        }

        private static Complex CreateComplex(int i)
        {
            if (i == 0)
            {
                return new Complex();
            }

            return new Complex
            {
                A = i,
                B = CreateComplex(i - 1)
            };
        }

        [Params(1, 10, 100, 500)]
        public int N { get; set; }

        [Params(1, 2, 6)]
        public int Depth { get; set; }

        [GlobalSetup]
        public void GlobalSetup()
        {
            list = Enumerable.Range(0, N).Select(_ => CreateComplex(Depth)).ToList();
            list2 = Enumerable.Range(0, N).Select(_ => CreateComplex(Depth)).ToList();
        }

        private List<Complex> list;
        private List<Complex> list2;

        [Benchmark]
        public void BeEquivalentTo()
        {
            list.Should().BeEquivalentTo(list2);
        }
    }
}

Before - 9190b26

After - b6bab8f

Relative + absolute diffs

Conclusion

So across time and GC for this benchmark, there's a 4-10% regression.

A quick profile showed that GetEqualityStrategy accounted for 11.24% of the time.

Some ideas:

• type.IsRecord can be statically cached.
• The calls to Any allocates the delegate (as it captures type) if even the collection is referenceTypes/valueTypes are empty, which I guess they are most of the time.
• Could we make an instance scoped Type -> EqualityStrategy cache?
  • Perhaps instead of the existing hasValueSemanticsMap cache.

While profiling the 400 equivalency specs using dotTrace (and Rider's integrated profiler), I get this:

So it seems we have several opportunities:

• Cache IsRecord() globally
• Cache OverridesEqualls globally. It was called 217K times.
• Cache GetEqualityStrategy within SelfReferenceEquivalencyAssertionOptions

I'll create a follow-up PR