EXPERIMENT: closer to what Carl suggested

Author: oconnor663

crates/ty_python_semantic/src/types/builder.rs

@@ -463,11 +463,10 @@ impl<'db> UnionBuilder<'db> {
             None
         };
 
-        // If an alias gets here, it means we aren't unpacking aliases, and we also shouldn't try
-        // to simplify aliases out of the union, because that will require unpacking them.
-        // `TypedDict`s also run into trouble here when their fields refer to a recursive union, so
-        // and we need to skip simplification to break cycles.
-        let should_simplify_full = !matches!(ty, Type::TypeAlias(_) | Type::TypedDict(_));
+        // If an alias gets here, it means we aren't unpacking aliases, and we also
+        // shouldn't try to simplify aliases out of the union, because that will require
+        // unpacking them.
+        let should_simplify_full = !matches!(ty, Type::TypeAlias(_));
 
         let mut to_remove = SmallVec::<[usize; 2]>::new();
         let ty_negated = if should_simplify_full {
@@ -503,6 +502,18 @@ impl<'db> UnionBuilder<'db> {
                 return;
             }
 
+            // Comparing `TypedDict`s for redundancy requires iterating over their fields, which is
+            // problematic if some of those fields point to recursive `Union`s. To avoid cycles,
+            // compare `TypedDict`s by name/identity instead of using the `has_relation_to`
+            // machinery.
+            if let (Type::TypedDict(element_td), Type::TypedDict(ty_td)) = (element_type, ty) {
+                if element_td == ty_td {
+                    return;
+                } else {
+                    continue;
+                }
+            }
+
             if should_simplify_full && !matches!(element_type, Type::TypeAlias(_)) {
                 if ty.is_redundant_with(self.db, element_type) {
                     return;