Adjust recursion identity for array type references in checker

Agent-Logs-Url: https://github.com/RyanCavanaugh/TypeScript/sessions/dee5edef-e472-4317-8876-e1ca781fb3bf

Co-authored-by: RyanCavanaugh <[email protected]>

Author: Copilot

src/compiler/checker.ts

@@ -25297,14 +25297,19 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     // instantiations of that type have the same recursion identity. The default recursion identity is the object
     // identity of the type, meaning that every type is unique. Generally, types with constituents that could circularly
     // reference the type have a recursion identity that differs from the object identity.
-    function getRecursionIdentity(type: Type): object {
-        // Object and array literals are known not to contain recursive references and don't need a recursion identity.
-        if (type.flags & TypeFlags.Object && !isObjectOrArrayLiteralType(type)) {
-            if (getObjectFlags(type) & ObjectFlags.Reference && (type as TypeReference).node) {
-                // Deferred type references are tracked through their associated AST node. This gives us finer
-                // granularity than using their associated target because each manifest type reference has a
-                // unique AST node.
-                return (type as TypeReference).node!;
+    function getRecursionIdentity(type: Type): object {
+        // Object and array literals are known not to contain recursive references and don't need a recursion identity.
+        if (type.flags & TypeFlags.Object && !isObjectOrArrayLiteralType(type)) {
+            if (isArrayType(type)) {
+                // Array wrappers are common and finite in non-recursive object graphs; track recursion identity through
+                // the element type instead of the shared global Array symbol to avoid false positives in deep nesting.
+                return getRecursionIdentity(getTypeArguments(type as TypeReference)[0]);
+            }
+            if (getObjectFlags(type) & ObjectFlags.Reference && (type as TypeReference).node) {
+                // Deferred type references are tracked through their associated AST node. This gives us finer
+                // granularity than using their associated target because each manifest type reference has a
+                // unique AST node.
+                return (type as TypeReference).node!;
             }
             if (type.symbol && !(getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol.flags & SymbolFlags.Class)) {
                 // We track object types that have a symbol by that symbol (representing the origin of the type), but