use iterative approach when cloning deeply nested objects to avoid running out of stack

lofcz · lofcz · commit 88dfe9a8e59b · 2025-09-27T22:33:56.000+02:00
diff --git a/FastCloner.Tests/SpecialCaseTests.cs b/FastCloner.Tests/SpecialCaseTests.cs
@@ -2883,10 +2883,10 @@ public void JsonObjectConstructorTest()
         // JsonObject has constructor: JsonObject(JsonNodeOptions? options = null)
         // So it should be callable with no arguments
 
-        var original = new JsonObject { ["test"] = "value" };
+        JsonObject original = new JsonObject { ["test"] = "value" };
 
         // This should now work without the special JsonNode processors
-        var clone = original.DeepClone();
+        JsonNode clone = original.DeepClone();
 
         Assert.Multiple(() =>
         {
@@ -3046,15 +3046,15 @@ public void Drawing_Brush_DeepClone_Test()
     public void AssemblyName_DeepClone_Test()
     {
         // Arrange
-        var original = new AssemblyName
+        AssemblyName original = new AssemblyName
         {
             Name = "MyTestAssembly",
             Version = new Version(1, 2, 3, 4)
         };
-        var originalVersion = new Version(1, 2, 3, 4);
+        Version originalVersion = new Version(1, 2, 3, 4);
 
         // Act
-        var clone = original.DeepClone();
+        AssemblyName clone = original.DeepClone();
         original.Version = new Version(5, 6, 7, 8); // Modify the original
 
         // Assert
@@ -3067,4 +3067,72 @@ public void AssemblyName_DeepClone_Test()
             Assert.That(clone.Version, Is.Not.EqualTo(original.Version));
         });
     }
+    
+    public class LargeNode
+    {
+        public LargeNode Parent { get; set; }
+        public LargeNode Child { get; set; }
+        public LargeNode Previous { get; set; }
+        public LargeNode Next { get; set; }
+        public List<int> Data { get; set; } = [];
+    }
+    
+    [Test]
+    public void LargeCircular_Test()
+    {
+        // Arrange
+        LargeNode root = new LargeNode { Data = [0] };
+        LargeNode current = root;
+        const int nodeCount = 10_000; // stackoverflow for n >= 8000
+
+        for (int i = 1; i < nodeCount; i++)
+        {
+            LargeNode next = new LargeNode { Data = [i], Parent = current };
+            current.Child = next;
+            next.Previous = current;
+            current.Next = next;
+            current = next;
+        }
+        
+        current.Next = root;
+        root.Previous = current;
+
+        // Act
+        LargeNode clone = root.DeepClone();
+
+        // Assert
+        Assert.That(clone, Is.Not.SameAs(root));
+        
+        LargeNode forward = clone;
+        for (int i = 0; i < nodeCount; i++)
+        {
+            forward = forward.Next;
+        }
+        Assert.That(forward, Is.SameAs(clone));
+
+        LargeNode backward = clone;
+        for (int i = 0; i < nodeCount; i++)
+        {
+            backward = backward.Previous;
+        }
+        Assert.That(backward, Is.SameAs(clone));
+
+        // Traverse to a deeply nested node
+        LargeNode originalNode = root;
+        LargeNode clonedNode = clone;
+        for (int i = 0; i < nodeCount / 2; i++)
+        {
+            originalNode = originalNode.Next;
+            clonedNode = clonedNode.Next;
+        }
+        
+        Assert.That(clonedNode, Is.Not.SameAs(originalNode));
+        Assert.That(clonedNode.Data, Is.Not.SameAs(originalNode.Data));
+        Assert.That(clonedNode.Data, Is.EqualTo(originalNode.Data));
+        
+        clonedNode.Data.Add(999);
+        Assert.That(originalNode.Data, Has.Count.EqualTo(1));
+        Assert.That(clonedNode.Data, Has.Count.EqualTo(2));
+        Assert.That(originalNode.Data[0], Is.Not.EqualTo(clonedNode.Data[1]));
+    }
 }
diff --git a/FastCloner/Code/FastCloneState.cs b/FastCloner/Code/FastCloneState.cs
@@ -1,13 +1,37 @@
-﻿namespace FastCloner.Code;
+﻿using System.Reflection;
+
+namespace FastCloner.Code;
 
 using System.Runtime.CompilerServices;
 
 internal sealed class FastCloneState
 {
+    internal static readonly PropertyInfo UseWorkListProp = typeof(FastCloneState).GetProperty("UseWorkList")!;
+    
     private MiniDictionary? loops;
     private readonly object[] baseFromTo = new object[6];
     private int idx;
 
+    // iterative worklist support
+    private WorkItem[]? workItems;
+    private int workCount;
+    public bool UseWorkList { get; set; }
+    private int callDepth;
+
+    private readonly struct WorkItem
+    {
+        public readonly object From;
+        public readonly object To;
+        public readonly Type Type;
+
+        public WorkItem(object from, object to, Type type)
+        {
+            From = from;
+            To = to;
+            Type = type;
+        }
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public object? GetKnownRef(object from)
     {
@@ -37,6 +61,47 @@ public void AddKnownRef(object from, object to)
         loops.Insert(from, to);
     }
 
+    public void EnqueueProcess(object from, object to, Type type)
+    {
+        WorkItem[] local = workItems ??= new WorkItem[16];
+        if (workCount == local.Length)
+        {
+            int newSize = local.Length * 2;
+            WorkItem[] resized = new WorkItem[newSize];
+            Array.Copy(local, resized, workCount);
+            workItems = local = resized;
+        }
+
+        local[workCount++] = new WorkItem(from, to, type);
+    }
+
+    public bool TryPop(out object from, out object to, out Type type)
+    {
+        if (workCount == 0)
+        {
+            from = null;
+            to = null;
+            type = null;
+            return false;
+        }
+
+        WorkItem wi = workItems![--workCount];
+        from = wi.From;
+        to = wi.To;
+        type = wi.Type;
+        return true;
+    }
+
+    public int IncrementDepth()
+    {
+        return ++callDepth;
+    }
+
+    public void DecrementDepth()
+    {
+        if (callDepth > 0) callDepth--;
+    }
+
     private sealed class MiniDictionary
     {
         private struct Entry(int hashCode, int next, object key, object value)
diff --git a/FastCloner/Code/FastClonerExprGenerator.cs b/FastCloner/Code/FastClonerExprGenerator.cs
@@ -288,21 +288,25 @@ private static void AddMemberCloneExpressions(
                     continue;
                 }
 
-                MethodInfo cloneMethodInfo = memberType.IsValueType()
-                    ? typeof(FastClonerGenerator).GetPrivateStaticMethod(nameof(FastClonerGenerator.CloneStructInternal))!.MakeGenericMethod(memberType)
-                    : typeof(FastClonerGenerator).GetPrivateStaticMethod(nameof(FastClonerGenerator.CloneClassInternal))!;
-
+                Expression clonedValueExpression;
                 MemberExpression getMemberValue = Expression.MakeMemberAccess(fromLocal, member);
                 Expression originalMemberValue = getMemberValue;
 
-                Expression callClone = Expression.Call(cloneMethodInfo, originalMemberValue, state);
-
-                if (!memberType.IsValueType())
+                if (memberType.IsValueType())
                 {
-                    callClone = Expression.Convert(callClone, memberType);
+                    MethodInfo structClone = typeof(FastClonerGenerator).GetPrivateStaticMethod(nameof(FastClonerGenerator.CloneStructInternal))!.MakeGenericMethod(memberType);
+                    clonedValueExpression = Expression.Call(structClone, originalMemberValue, state);
+                }
+                else
+                {
+                    MethodInfo classDeep = typeof(FastClonerGenerator).GetPrivateStaticMethod(nameof(FastClonerGenerator.CloneClassInternal))!;
+                    MethodInfo classShallowTrack = typeof(FastClonerGenerator).GetPrivateStaticMethod(nameof(FastClonerGenerator.CloneClassShallowAndTrack))!;
+                    PropertyInfo useWorkListProp = FastCloneState.UseWorkListProp;
+                    Expression deepCall = Expression.Call(classDeep, originalMemberValue, state);
+                    Expression shallowCall = Expression.Call(classShallowTrack, originalMemberValue, state);
+                    Expression selected = Expression.Condition(Expression.Property(state, useWorkListProp), shallowCall, deepCall);
+                    clonedValueExpression = Expression.Convert(selected, memberType);
                 }
-
-                Expression clonedValueExpression = callClone;
 
                 switch (member)
                 {
diff --git a/FastCloner/Code/FastClonerGenerator.cs b/FastCloner/Code/FastClonerGenerator.cs
@@ -67,10 +67,75 @@ internal static class FastClonerGenerator
         if (obj == null)
             return null;
 
-        Func<object, FastCloneState, object>? cloner = (Func<object, FastCloneState, object>?)FastClonerCache.GetOrAddClass(obj.GetType(), t => GenerateCloner(t, true));
+        Type rootType = obj.GetType();
+        Func<object, FastCloneState, object>? cloner = (Func<object, FastCloneState, object>?)FastClonerCache.GetOrAddClass(rootType, t => GenerateCloner(t, true));
 
         // null -> should return same type
-        return cloner is null ? obj : cloner(obj, new FastCloneState());
+        if (cloner is null)
+        {
+            return obj;
+        }
+        
+        FastCloneState state = new FastCloneState
+        {
+            UseWorkList = TypeHasDirectSelfReference(rootType)
+        };
+        
+        if (!state.UseWorkList)
+        {
+            try
+            {
+                int current = state.IncrementDepth();
+                
+                if (current >= FastCloner.MaxRecursionDepth)
+                {
+                    state.DecrementDepth();
+                    state.UseWorkList = true;
+                }
+                else
+                {
+                    object resultNormal = cloner(obj, state);
+                    state.DecrementDepth();
+                    return resultNormal;
+                }
+            }
+            catch
+            {
+                state.DecrementDepth();
+                throw;
+            }
+        }
+
+        object result = cloner(obj, state);
+        while (state.TryPop(out object from, out object to, out Type type))
+        {
+            Func<object, object, FastCloneState, object> clonerTo = (Func<object, object, FastCloneState, object>)FastClonerCache.GetOrAddDeepClassTo(type, t => ClonerToExprGenerator.GenerateClonerInternal(t, true));
+            clonerTo(from, to, state);
+        }
+
+        return result;
+    }
+
+    private static bool TypeHasDirectSelfReference(Type type)
+    {
+        Type? tp = type;
+        while (tp != null && tp != typeof(ContextBoundObject))
+        {
+            foreach (FieldInfo fi in tp.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly))
+            {
+                Type ft = fi.FieldType;
+                if (ft == type)
+                {
+                    return true;
+                }
+                if (ft.IsArray && ft.GetElementType() == type)
+                {
+                    return true;
+                }
+            }
+            tp = tp.BaseType;
+        }
+        return false;
     }
 
     internal static object? CloneClassInternal(object? obj, FastCloneState state)
@@ -94,10 +159,68 @@ internal static class FastClonerGenerator
         {
             return obj;
         }
+        
+        if (state.UseWorkList)
+        {
+            object? knownA = state.GetKnownRef(obj);
+            return knownA ?? CloneClassShallowAndTrack(obj, state);
+        }
+
+        try
+        {
+            int current = state.IncrementDepth();
+            if (current > 1000)
+            {
+                state.DecrementDepth();
+                state.UseWorkList = true;
+                object? knownB = state.GetKnownRef(obj);
+                return knownB ?? CloneClassShallowAndTrack(obj, state);
+            }
+
+            object? knownRef = state.GetKnownRef(obj);
+            return knownRef ?? cloner(obj, state);
+        }
+        finally
+        {
+            state.DecrementDepth();
+        }
+    }
+    
+    internal static object? CloneClassShallowAndTrack(object? obj, FastCloneState state)
+    {
+        if (obj is null)
+        {
+            return null;
+        }
+
+        Type objType = obj.GetType();
+
+        if (FastClonerCache.IsTypeIgnored(objType))
+        {
+            return null;
+        }
+
+        if (FastClonerSafeTypes.CanReturnSameObject(objType))
+        {
+            return obj;
+        }
 
-        // loop
         object? knownRef = state.GetKnownRef(obj);
-        return knownRef ?? cloner(obj, state);
+        if (knownRef is not null)
+        {
+            return knownRef;
+        }
+        
+        MethodInfo methodInfo = typeof(object).GetPrivateMethod(nameof(MemberwiseClone))!;
+        object? shallow = methodInfo.Invoke(obj, null);
+        state.AddKnownRef(obj, shallow);
+
+        if (state.UseWorkList)
+        {
+            state.EnqueueProcess(obj, shallow, objType);
+        }
+
+        return shallow;
     }
 
     internal static T CloneStructInternal<T>(T obj, FastCloneState state)
@@ -266,10 +389,9 @@ internal static T[] Clone1DimArraySafeInternal<T>(T[] obj, FastCloneState state)
             throw new InvalidOperationException("From object should be derived from From object, but From object has type " + objFrom.GetType().FullName + " and to " + objTo.GetType().FullName);
         if (objFrom is string)
             throw new InvalidOperationException("It is forbidden to clone strings");
-        Func<object, object, FastCloneState, object>? cloner = (Func<object, object, FastCloneState, object>)(isDeep
+        Func<object, object, FastCloneState, object>? cloner = (Func<object, object, FastCloneState, object>?)(isDeep
             ? FastClonerCache.GetOrAddDeepClassTo(type, t => ClonerToExprGenerator.GenerateClonerInternal(t, true))
             : FastClonerCache.GetOrAddShallowClassTo(type, t => ClonerToExprGenerator.GenerateClonerInternal(t, false)));
-        if (cloner == null) return objTo;
-        return cloner(objFrom, objTo, new FastCloneState());
+        return cloner is null ? objTo : cloner(objFrom, objTo, new FastCloneState());
     }
 }
diff --git a/FastCloner/FastCloner.cs b/FastCloner/FastCloner.cs
diff --git a/FastCloner/FastCloner.csproj b/FastCloner/FastCloner.csproj
