always cache typed dict inferred types

Author: ibraheemdev

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -5785,8 +5785,13 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 //
                 // Infer all expressions with diagnostics enabled before starting multi-inference.
                 for item in items {
-                    self.infer_optional_expression(item.key.as_ref(), TypeContext::default());
-                    self.infer_expression(&item.value, TypeContext::default());
+                    if let Some(key) = item.key.as_ref() {
+                        let key_ty = self.infer_expression(key, TypeContext::default());
+                        item_types.insert(key.node_index().load(), key_ty);
+                    }
+
+                    let value_ty = self.infer_expression(&item.value, TypeContext::default());
+                    item_types.insert(item.value.node_index().load(), value_ty);
                 }
 
                 // Disable diagnostics as we attempt to narrow to specific elements of the union.
@@ -5795,6 +5800,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     self.set_multi_inference_state(MultiInferenceState::Ignore);
 
                 let mut narrowed_tys = Vec::new();
+                let mut item_types = FxHashMap::default();
                 for element in tcx.elements(self.db()) {
                     let typed_dict = element
                         .as_typed_dict()
@@ -5835,8 +5841,9 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         // dictionary literal as a `TypedDict`. This also allows us to infer using the
         // type context of the expected `TypedDict` field.
         let mut infer_elt_ty = |builder: &mut Self, (_, elt, tcx): ArgExpr<'db, '_>| {
-            builder
-                .try_expression_type(elt)
+            item_types
+                .get(&elt.node_index().load())
+                .copied()
                 .unwrap_or_else(|| builder.infer_expression(elt, tcx))
         };