Fix StackOverflowException from Dictionary properties during injection

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## Version 1.2.4
+
+### Fixes
+
+- Fixed a `StackOverflowException` during injection when a component exposed a `Dictionary` property that had been iterated at edit time (e.g. from `OnDrawGizmos`), which leaves an internal reference cycle for traversal to follow. Generic collection types are no longer treated as nested serializable, so injection no longer recurses into their internal fields.
+
+### Tests
+
+- Added coverage ensuring generic collection types are excluded from nested serializable traversal while plain `[Serializable]` classes are still included.
+
 ## Version 1.2.3
 
 ### Fixes

UnityProject/Saneject/Assets/Plugins/Saneject/Editor/Extensions/TypeExtensions.cs

@@ -45,6 +45,12 @@ public static bool IsNestedSerializable(this Type type)
             if (type == typeof(string))
                 return false;
 
+            // Unity does not serialize generic types (e.g. Dictionary<,>, List<T>) as nested custom
+            // classes, and their internal fields can form reference cycles (Dictionary <-> ValueCollection),
+            // so never recurse into them during traversal.
+            if (type.IsGenericType)
+                return false;
+
             return !typeof(Object).IsAssignableFrom(type) &&
                    type.IsDefined(typeof(SerializableAttribute), inherit: false);
         }

UnityProject/Saneject/Assets/Plugins/Saneject/package.json

@@ -2,7 +2,7 @@
   "name": "com.alexanderlarsen.saneject",
   "author": "Alexander Larsen",
   "displayName": "Saneject",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Inject dependencies in the Unity Editor, not Play Mode, by writing them directly into serialized fields at edit-time using familiar DI APIs, so everything stays visible in the Inspector, including interfaces.\n\nNo runtime container. No startup cost. No hidden wiring. No weird lifecycles. Just simple, deterministic edit-time DI that works with Unity, not around it.",
   "documentationUrl": "https://github.com/alexanderlarsen/Saneject/blob/main/README.md",
   "changelogUrl": "https://github.com/alexanderlarsen/Saneject/blob/main/CHANGELOG.md",

UnityProject/Saneject/Assets/Tests/Saneject/Editor/Extensions/TypeExtensionsTests.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Plugins.Saneject.Editor.Extensions;
+using Tests.Saneject.Fixtures.Scripts.InjectionTargets;
+using UnityEngine;
+
+namespace Tests.Saneject.Editor.Extensions
+{
+    public class TypeExtensionsTests
+    {
+        // Regression: generic collection types (e.g. Dictionary<,>, List<>) carry [Serializable] and would
+        // otherwise be treated as nested serializable, causing traversal to recurse into their internal
+        // fields. A Dictionary property's cached ValueCollection holds a back-reference to the dictionary,
+        // producing a reference cycle and an uncatchable StackOverflowException during injection.
+        [Test]
+        public void IsNestedSerializable_ReturnsFalse_ForGenericCollectionTypes()
+        {
+            Assert.That(typeof(Dictionary<Vector3, NestedChildTarget>).IsNestedSerializable(), Is.False);
+            Assert.That(typeof(List<NestedChildTarget>).IsNestedSerializable(), Is.False);
+        }
+
+        // Guard rail: the generic exclusion above must not stop plain [Serializable] user classes from
+        // being traversed for nested injection.
+        [Test]
+        public void IsNestedSerializable_ReturnsTrue_ForPlainSerializableClass()
+        {
+            Assert.That(typeof(NestedChildTarget).IsNestedSerializable(), Is.True);
+        }
+    }
+}