Using default comparer builder option throws StackOverflowException. about comparers HOT 8 CLOSED

   public class Component
    {
        public double AccumulatedWeight { get; set; }

        public double Weight { get; set; }
        
        public Nested NestedRef { get; set; }
    }
    
    public class Nested
    {
        public double NestedProp { get; set; }
    }
    
    class Program
    {
        static void Main(string[] args)
        {   
            var c1 = new Component
            {
                Weight = 0.7,
                AccumulatedWeight = 0.2,
                NestedRef = new Nested
                {
                    NestedProp = 223
                }
            };
            
            var c2 = new Component
            {
                Weight = 0.7,
                AccumulatedWeight = 0.2,
                NestedRef = new Nested
                {
                    NestedProp = 223
                }
            };

            var result = BuildEquals<Component>()(c1, c2);
            
            Console.WriteLine(result);
        }
        
        public static Func<T, T, bool> BuildEquals<T>()
        {
            return ((Expression<Func<T, T, bool>>) BuildEquals(typeof(T))).Compile();
        }

        public static Expression BuildEquals(Type type)
        {
            bool IsComplexType(Type nestedType)
            {
                return !nestedType.Namespace.StartsWith("System.Collections") && nestedType.IsClass;
            }
            
            var arg1 = Expression.Parameter(type);
            var arg2 = Expression.Parameter(type);
            
            var body = type
                .GetProperties()
                .Select(x =>
                {
                    if (IsComplexType(x.PropertyType))
                    {
                        return (Expression) Expression.Invoke(BuildEquals(x.PropertyType),
                            Expression.Property(arg1, x.Name),
                            Expression.Property(arg2, x.Name));
                    }
                    else
                    {
                        return Expression.Equal(Expression.Property(arg1, x.Name), Expression.Property(arg2, x.Name));
                    }
                })
                .Aggregate((x, y) => Expression.And(x, y));

            return Expression.Lambda(body, arg1, arg2);
        } 

public static IFullEqualityComparer<T> BuildAllMembersEqualityComparer<T>()
{
    var result = EqualityComparerBuilder.For<T>().Null();
    var type = typeof(T);
    var parameter = Expression.Parameter(type);
    foreach (var prop in type.GetProperties())
    {
        var expression = Expression.Property(parameter, prop.Name);
        dynamic selector = Expression.Lambda(expression, parameter).Compile();
        dynamic childComparer = null;
        if (IsComplexType(prop.PropertyType))
            childComparer = ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(prop.PropertyType).Invoke(null, null);
        result = EqualityComparerExtensions.ThenEquateBy(result, selector, childComparer);
    }
    return result;

    bool IsComplexType(Type nestedType) => !nestedType.Namespace.StartsWith("System.Collections") && nestedType.IsClass;
}