Fix exponential memory blowup in dict literal type inference

Summary:
Deeply-nested dict literals (e.g. `{"a": {"b": {"c": ...}}}`) caused exponential memory growth during type inference, with a depth-25 literal consuming ~7.7 GB and triggering OOM.

The root cause was `AnonymousTypedDictInner` storing both the individual `fields` and a pre-computed `value_type` (the union of all field types). Since `value_type` was a clone of the field types, each nesting level doubled the size of the type tree on `Clone`, producing O(2^N) memory usage.

The fix removes the redundant `value_type` field and instead computes it on demand via `compute_value_type()`. This ensures the type tree is only as deep as the actual nesting, reducing pyrefly's total memory for a depth-25 dict from ~7.7 GB to ~239 MB.

fixes #3286

Reviewed By: stroxler

Differential Revision: D103479382

fbshipit-source-id: 6734b427217ba54e5a3276291811bb77f98654f6

Author: kinto0

crates/pyrefly_types/src/display.rs

@@ -26,6 +26,7 @@ use starlark_map::smallmap;
 
 use crate::callable::Function;
 use crate::class::Class;
+use crate::heap::TypeHeap;
 use crate::literal::Lit;
 use crate::quantified::Quantified;
 use crate::quantified::QuantifiedIdentity;
@@ -38,6 +39,7 @@ use crate::type_output::DisplayOutput;
 use crate::type_output::OutputWithLocations;
 use crate::type_output::TypeOutput;
 use crate::type_var::Restriction;
+use crate::typed_dict::AnonymousTypedDictInner;
 use crate::typed_dict::TypedDict;
 use crate::types::AnyStyle;
 use crate::types::BoundMethod;
@@ -421,6 +423,21 @@ impl<'a> TypeDisplayContext<'a> {
         }
     }
 
+    /// Format the value type of an anonymous typed dict by computing the union
+    /// of all field types on-the-fly. This avoids storing a redundant clone in the
+    /// type tree (which caused exponential memory growth for nested dict literals).
+    /// Delegates to `compute_value_type` + `fmt_helper_generic` so that union
+    /// display (dedup, literal grouping, etc.) stays in one place.
+    fn fmt_anonymous_typed_dict_value_type(
+        &self,
+        inner: &AnonymousTypedDictInner,
+        output: &mut impl TypeOutput,
+    ) -> fmt::Result {
+        let heap = TypeHeap::new();
+        let value_type = inner.compute_value_type(&heap);
+        self.fmt_helper_generic(&value_type, false, output)
+    }
+
     /// Core formatting logic for types that works with any `TypeOutput` implementation.
     ///
     /// The method uses the `TypeOutput` trait abstraction to write output in various ways.
@@ -507,7 +524,7 @@ impl<'a> TypeDisplayContext<'a> {
                     let str_qname = self.stdlib.map(|s| s.str().qname());
                     output.write_builtin("str", str_qname)?;
                     output.write_str(", ")?;
-                    self.fmt_helper_generic(&inner.value_type, false, output)?;
+                    self.fmt_anonymous_typed_dict_value_type(inner, output)?;
                     output.write_str("]")
                 }
             },
@@ -523,7 +540,7 @@ impl<'a> TypeDisplayContext<'a> {
                     let str_qname = self.stdlib.map(|s| s.str().qname());
                     output.write_builtin("str", str_qname)?;
                     output.write_str(", ")?;
-                    self.fmt_helper_generic(&inner.value_type, false, output)?;
+                    self.fmt_anonymous_typed_dict_value_type(inner, output)?;
                     output.write_str("]")
                 }
             },

crates/pyrefly_types/src/simplify.rs

@@ -260,9 +260,8 @@ fn collapse_literals(
 fn promote_anonymous_typed_dicts(types: &mut [Type], stdlib: &Stdlib, heap: &TypeHeap) {
     for ty in types.iter_mut() {
         if let Type::TypedDict(TypedDict::Anonymous(inner)) = ty {
-            *ty = heap.mk_class_type(
-                stdlib.dict(stdlib.str().clone().to_type(), inner.value_type.clone()),
-            );
+            let value_type = inner.compute_value_type(heap);
+            *ty = heap.mk_class_type(stdlib.dict(stdlib.str().clone().to_type(), value_type));
         }
     }
 }

crates/pyrefly_types/src/typed_dict.rs

@@ -17,6 +17,7 @@ use crate::annotation::Qualifier;
 use crate::class::Class;
 use crate::heap::TypeHeap;
 use crate::read_only::ReadOnlyReason;
+use crate::simplify;
 use crate::stdlib::Stdlib;
 use crate::types::Substitution;
 use crate::types::TArgs;
@@ -86,7 +87,16 @@ impl TypedDictInner {
 )]
 pub struct AnonymousTypedDictInner {
     pub fields: Vec<(Name, TypedDictField)>,
-    pub value_type: Type,
+}
+
+impl AnonymousTypedDictInner {
+    /// Compute the union of all field value types. This is derived from `fields`
+    /// rather than stored, to avoid duplicating the type tree at each nesting
+    /// level (which caused 2^N memory growth for nested dict literals).
+    pub fn compute_value_type(&self, heap: &TypeHeap) -> Type {
+        let tys: Vec<Type> = self.fields.iter().map(|(_, f)| f.ty.clone()).collect();
+        simplify::unions(tys, heap)
+    }
 }
 
 #[derive(

pyrefly/lib/alt/class/typed_dict.rs

@@ -741,7 +741,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     self.heap.mk_class_type(self.stdlib.object().clone())
                 }
             }
-            TypedDict::Anonymous(inner) => inner.value_type.clone(),
+            TypedDict::Anonymous(inner) => inner.compute_value_type(self.heap),
         }
     }
 

pyrefly/lib/alt/expr.rs

@@ -1213,17 +1213,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 && !typed_dict_fields_map.is_empty()
                 && typed_dict_fields_map.len() <= ANONYMOUS_TYPED_DICT_MAX_ITEMS
             {
-                // Compute the fallback value type from the field mapping, not from value_tys which
-                // may contain types from overridden keys
-                let final_value_tys: Vec<_> = typed_dict_fields_map
-                    .values()
-                    .map(|f| f.ty.clone())
-                    .collect();
                 let typed_dict_fields: Vec<_> = typed_dict_fields_map.into_iter().collect();
                 return self.heap.mk_typed_dict(TypedDict::Anonymous(Box::new(
                     AnonymousTypedDictInner {
                         fields: typed_dict_fields,
-                        value_type: self.unions(final_value_tys),
                     },
                 )));
             }

pyrefly/lib/test/dict.rs

@@ -151,3 +151,20 @@ assert_type(f(d), TD)  # E: assert_type(dict[str, int], TD)
 assert_type(f({"x": 0}), TD)  # E: `dict[str, int]` is not assignable to upper bound `TD`  # E: assert_type(dict[str, int], TD)
     "#,
 );
+
+// Regression test: deeply nested dict literals previously caused exponential memory growth
+// because AnonymousTypedDictInner stored the value type both in `fields` and a redundant
+// `value_type` field, doubling the cloned type tree at each nesting level. The fix removed
+// the redundant field and computes the value type on demand from `fields`.
+//
+// Depth 15 is used for CI speed. The fix was verified at depth 25 (239 MB, down from 7.7 GB)
+// and depth 50 (236 MB), confirming linear rather than exponential growth.
+testcase!(
+    test_deeply_nested_dict_literal,
+    r#"
+from typing import assert_type
+
+x = {"a": {"b": {"c": {"d": {"e": {"f": {"g": {"h": {"i": {"j": {"k": {"l": {"m": {"n": {"o": "deep"}}}}}}}}}}}}}}}
+assert_type(x, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, dict[str, str]]]]]]]]]]]]]]])
+"#,
+);

pyrefly/lib/test/pysa/types.rs

@@ -690,11 +690,6 @@ class MyTypedDict(TypedDict):
                             read_only_reason: None,
                         },
                     )],
-                    value_type: context
-                        .answers_context
-                        .answers
-                        .heap()
-                        .mk_class_type(context.answers_context.stdlib.int().clone()),
                 }))),
             &context,
         ),