Allow clear() and popitem() when all TypedDict items are non-read-only and non-required

Summary:
For #946.

Note that the non-read-only case covers open TypedDicts, as they are considered to have extra items `ReadOnly[object]`.

Reviewed By: samwgoldman

Differential Revision: D80870303

fbshipit-source-id: 981ee7b4137fa04fe124d207e79303c09c2e3b9b

Author: rchen152

conformance/third_party/conformance.exp

@@ -10121,36 +10121,6 @@
       "stop_column": 44,
       "stop_line": 294
     },
-    {
-      "code": -2,
-      "column": 1,
-      "concise_description": "Object of class `IntDictWithNum` has no attribute `clear`",
-      "description": "Object of class `IntDictWithNum` has no attribute `clear`",
-      "line": 328,
-      "name": "missing-attribute",
-      "stop_column": 28,
-      "stop_line": 328
-    },
-    {
-      "code": -2,
-      "column": 12,
-      "concise_description": "assert_type(Any, tuple[str, int]) failed",
-      "description": "assert_type(Any, tuple[str, int]) failed",
-      "line": 330,
-      "name": "assert-type",
-      "stop_column": 62,
-      "stop_line": 330
-    },
-    {
-      "code": -2,
-      "column": 13,
-      "concise_description": "Object of class `IntDictWithNum` has no attribute `popitem`",
-      "description": "Object of class `IntDictWithNum` has no attribute `popitem`",
-      "line": 330,
-      "name": "missing-attribute",
-      "stop_column": 42,
-      "stop_line": 330
-    },
     {
       "code": -2,
       "column": 25,

conformance/third_party/conformance.result

@@ -424,9 +424,7 @@
     "Line 68: Unexpected errors ['Cannot extend closed TypedDict `ClosedBase` with extra item `age`']",
     "Line 74: Unexpected errors ['TypedDict `ExtraItemsBase` with non-read-only `extra_items` cannot be extended with required extra item `age`']",
     "Line 182: Unexpected errors ['TypedDict `MovieBase2` with non-read-only `extra_items` cannot be extended with required extra item `year`']",
-    "Line 185: Unexpected errors ['`int` is not consistent with `extra_items` type `int | None` of TypedDict `MovieBase2`']",
-    "Line 328: Unexpected errors ['Object of class `IntDictWithNum` has no attribute `clear`']",
-    "Line 330: Unexpected errors ['assert_type(Any, tuple[str, int]) failed', 'Object of class `IntDictWithNum` has no attribute `popitem`']"
+    "Line 185: Unexpected errors ['`int` is not consistent with `extra_items` type `int | None` of TypedDict `MovieBase2`']"
   ],
   "typeddicts_final.py": [],
   "typeddicts_inheritance.py": [

conformance/third_party/results.json

@@ -3,7 +3,7 @@
   "pass": 81,
   "fail": 57,
   "pass_rate": 0.59,
-  "differences": 253,
+  "differences": 251,
   "passing": [
     "aliases_explicit.py",
     "aliases_newtype.py",
@@ -141,7 +141,7 @@
     "qualifiers_final_decorator.py": 1,
     "specialtypes_never.py": 1,
     "specialtypes_type.py": 8,
-    "typeddicts_extra_items.py": 8,
+    "typeddicts_extra_items.py": 6,
     "typeddicts_inheritance.py": 1,
     "typeddicts_readonly_inheritance.py": 4,
     "typeddicts_required.py": 1

pyrefly/lib/alt/class/typed_dict.rs

@@ -51,8 +51,10 @@ use crate::types::types::TParam;
 use crate::types::types::TParams;
 use crate::types::types::Type;
 
+const CLEAR_METHOD: Name = Name::new_static("clear");
 const GET_METHOD: Name = Name::new_static("get");
 const POP_METHOD: Name = Name::new_static("pop");
+const POPITEM_METHOD: Name = Name::new_static("popitem");
 const SETDEFAULT_METHOD: Name = Name::new_static("setdefault");
 const KEY_PARAM: Name = Name::new_static("key");
 const DEFAULT_PARAM: Name = Name::new_static("default");
@@ -681,6 +683,61 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         })))
     }
 
+    fn all_items_are_removable(&self, cls: &Class, fields: &SmallMap<Name, bool>) -> bool {
+        !self
+            .typed_dict_extra_items(cls)
+            .extra_item(self.stdlib)
+            .read_only
+            && self
+                .names_to_fields(cls, fields)
+                .all(|(_, field)| !field.is_read_only() && !field.required)
+    }
+
+    fn get_typed_dict_clear(
+        &self,
+        cls: &Class,
+        fields: &SmallMap<Name, bool>,
+    ) -> Option<ClassSynthesizedField> {
+        if !self.all_items_are_removable(cls, fields) {
+            return None;
+        }
+        Some(ClassSynthesizedField::new(Type::Function(Box::new(
+            Function {
+                signature: Callable::list(
+                    ParamList::new(vec![self.class_self_param(cls, true)]),
+                    Type::None,
+                ),
+                metadata: FuncMetadata::def(self.module().name(), cls.name().clone(), CLEAR_METHOD),
+            },
+        ))))
+    }
+
+    fn get_typed_dict_popitem(
+        &self,
+        cls: &Class,
+        fields: &SmallMap<Name, bool>,
+    ) -> Option<ClassSynthesizedField> {
+        if !self.all_items_are_removable(cls, fields) {
+            return None;
+        }
+        Some(ClassSynthesizedField::new(Type::Function(Box::new(
+            Function {
+                signature: Callable::list(
+                    ParamList::new(vec![self.class_self_param(cls, true)]),
+                    Type::Tuple(Tuple::Concrete(vec![
+                        self.stdlib.str().clone().to_type(),
+                        self.get_typed_dict_value_type_from_fields(cls, fields),
+                    ])),
+                ),
+                metadata: FuncMetadata::def(
+                    self.module().name(),
+                    cls.name().clone(),
+                    POPITEM_METHOD,
+                ),
+            },
+        ))))
+    }
+
     pub fn get_typed_dict_synthesized_fields(&self, cls: &Class) -> Option<ClassSynthesizedFields> {
         let metadata = self.get_metadata_for_class(cls);
         let td = metadata.typed_dict_metadata()?;
@@ -691,9 +748,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             UPDATE_METHOD => self.get_typed_dict_update(cls, &td.fields),
             VALUES_METHOD => self.get_typed_dict_values(cls, &td.fields),
         };
+        if let Some(m) = self.get_typed_dict_clear(cls, &td.fields) {
+            fields.insert(CLEAR_METHOD, m);
+        }
         if let Some(m) = self.get_typed_dict_pop(cls, &td.fields) {
             fields.insert(POP_METHOD, m);
         }
+        if let Some(m) = self.get_typed_dict_popitem(cls, &td.fields) {
+            fields.insert(POPITEM_METHOD, m);
+        }
         if let Some(m) = self.get_typed_dict_setdefault(cls, &td.fields) {
             fields.insert(SETDEFAULT_METHOD, m);
         }

pyrefly/lib/test/typed_dict.rs

@@ -1693,3 +1693,19 @@ def f(a: A, k: str):
     assert_type(a.get(k, b'hello world'), str | int | bytes)
     "#,
 );
+
+testcase!(
+    test_remove_arbitrary_items,
+    r#"
+from typing import assert_type, NotRequired, TypedDict
+class A(TypedDict, extra_items=int):
+    x: NotRequired[str]
+class B(TypedDict, extra_items=int):
+    x: str
+def f(a: A, b: B):
+    assert_type(a.popitem(), tuple[str, int | str])
+    a.clear()
+    b.popitem()  # E: `B` has no attribute `popitem`
+    b.clear()  # E: `B` has no attribute `clear`
+    "#,
+);