avoid duplicated TypedDict assignment diagnostics

Author: ibraheemdev

crates/ty_python_semantic/resources/mdtest/snapshots/typed_dict.md_-_`TypedDict`_-_Diagnostics_(e5289abf5c570c29).snap

@@ -40,19 +40,18 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/typed_dict.md
 26 | 
 27 | def create_with_invalid_string_key():
 28 |     # error: [invalid-key]
-29 |     # error: [invalid-assignment]
-30 |     alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
-31 | 
-32 |     # error: [invalid-key]
-33 |     bob = Person(name="Bob", age=25, unknown="Bar")
-34 | from typing_extensions import ReadOnly
-35 | 
-36 | class Employee(TypedDict):
-37 |     id: ReadOnly[int]
-38 |     name: str
-39 | 
-40 | def write_to_readonly_key(employee: Employee):
-41 |     employee["id"] = 42  # error: [invalid-assignment]
+29 |     alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
+30 | 
+31 |     # error: [invalid-key]
+32 |     bob = Person(name="Bob", age=25, unknown="Bar")
+33 | from typing_extensions import ReadOnly
+34 | 
+35 | class Employee(TypedDict):
+36 |     id: ReadOnly[int]
+37 |     name: str
+38 | 
+39 | def write_to_readonly_key(employee: Employee):
+40 |     employee["id"] = 42  # error: [invalid-assignment]
 ```
 
 # Diagnostics
@@ -160,69 +159,54 @@ info: rule `invalid-key` is enabled by default
 
 ```
 
-```
-error[invalid-assignment]: Object of type `dict[Unknown | str, Unknown | str | int]` is not assignable to `Person`
-  --> src/mdtest_snippet.py:30:5
-   |
-28 |     # error: [invalid-key]
-29 |     # error: [invalid-assignment]
-30 |     alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
-   |     ^^^^^
-31 |
-32 |     # error: [invalid-key]
-   |
-info: rule `invalid-assignment` is enabled by default
-
-```
-
 ```
 error[invalid-key]: Invalid key for TypedDict `Person`
-  --> src/mdtest_snippet.py:30:21
+  --> src/mdtest_snippet.py:29:21
    |
+27 | def create_with_invalid_string_key():
 28 |     # error: [invalid-key]
-29 |     # error: [invalid-assignment]
-30 |     alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
+29 |     alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
    |                     -----------------------------^^^^^^^^^--------
    |                     |                            |
    |                     |                            Unknown key "unknown"
    |                     TypedDict `Person`
-31 |
-32 |     # error: [invalid-key]
+30 |
+31 |     # error: [invalid-key]
    |
 info: rule `invalid-key` is enabled by default
 
 ```
 
 ```
 error[invalid-key]: Invalid key for TypedDict `Person`
-  --> src/mdtest_snippet.py:33:11
+  --> src/mdtest_snippet.py:32:11
    |
-32 |     # error: [invalid-key]
-33 |     bob = Person(name="Bob", age=25, unknown="Bar")
+31 |     # error: [invalid-key]
+32 |     bob = Person(name="Bob", age=25, unknown="Bar")
    |           ------ TypedDict `Person`  ^^^^^^^^^^^^^ Unknown key "unknown"
-34 | from typing_extensions import ReadOnly
+33 | from typing_extensions import ReadOnly
    |
 info: rule `invalid-key` is enabled by default
 
 ```
 
 ```
 error[invalid-assignment]: Cannot assign to key "id" on TypedDict `Employee`
-  --> src/mdtest_snippet.py:41:5
+  --> src/mdtest_snippet.py:40:5
    |
-40 | def write_to_readonly_key(employee: Employee):
-41 |     employee["id"] = 42  # error: [invalid-assignment]
+39 | def write_to_readonly_key(employee: Employee):
+40 |     employee["id"] = 42  # error: [invalid-assignment]
    |     -------- ^^^^ key is marked read-only
    |     |
    |     TypedDict `Employee`
    |
 info: Item declaration
-  --> src/mdtest_snippet.py:37:5
+  --> src/mdtest_snippet.py:36:5
    |
-36 | class Employee(TypedDict):
-37 |     id: ReadOnly[int]
+35 | class Employee(TypedDict):
+36 |     id: ReadOnly[int]
    |     ----------------- Read-only item declared here
-38 |     name: str
+37 |     name: str
    |
 info: rule `invalid-assignment` is enabled by default
 

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -83,7 +83,6 @@ CAPITALIZED_NAME = "Name"
 
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "Name" - did you mean "name"?"
 # error: [missing-typed-dict-key] "Missing required key 'name' in TypedDict `Person` constructor"
-# error: [invalid-assignment]
 dave: Person = {CAPITALIZED_NAME: "Dave", "age": 20}
 
 def age() -> Literal["age"] | None:
@@ -96,7 +95,6 @@ The construction of a `TypedDict` is checked for type correctness:
 
 ```py
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Person`"
-# error: [invalid-assignment]
 eve1a: Person = {"name": b"Eve", "age": None}
 
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Person`"
@@ -106,7 +104,6 @@ reveal_type(eve1a)  # revealed: Person
 reveal_type(eve1b)  # revealed: Person
 
 # error: [missing-typed-dict-key] "Missing required key 'name' in TypedDict `Person` constructor"
-# error: [invalid-assignment]
 eve2a: Person = {"age": 22}
 
 # error: [missing-typed-dict-key] "Missing required key 'name' in TypedDict `Person` constructor"
@@ -116,7 +113,6 @@ reveal_type(eve2a)  # revealed: Person
 reveal_type(eve2b)  # revealed: Person
 
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
-# error: [invalid-assignment]
 eve3a: Person = {"name": "Eve", "age": 25, "extra": True}
 
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
@@ -205,8 +201,6 @@ reveal_type(alice["inner"]["age"])  # revealed: int | None
 reveal_type(alice["inner"]["non_existing"])  # revealed: Unknown
 
 # error: [invalid-key] "Invalid key for TypedDict `Inner`: Unknown key "extra""
-# error: [invalid-argument-type]
-# error: [invalid-assignment]
 alice: Person = {"inner": {"name": "Alice", "age": 30, "extra": 1}}
 ```
 
@@ -243,7 +237,6 @@ All of these are missing the required `age` field:
 
 ```py
 # error: [missing-typed-dict-key] "Missing required key 'age' in TypedDict `Person` constructor"
-# error: [invalid-assignment]
 alice2: Person = {"name": "Alice"}
 
 # error: [missing-typed-dict-key] "Missing required key 'age' in TypedDict `Person` constructor"
@@ -262,15 +255,13 @@ house.owner = {"name": "Alice"}
 
 a_person: Person
 # error: [missing-typed-dict-key] "Missing required key 'age' in TypedDict `Person` constructor"
-# error: [invalid-assignment]
 a_person = {"name": "Alice"}
 ```
 
 All of these have an invalid type for the `name` field:
 
 ```py
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Person`: value of type `None`"
-# error: [invalid-assignment]
 alice3: Person = {"name": None, "age": 30}
 
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Person`: value of type `None`"
@@ -289,19 +280,16 @@ house.owner = {"name": None, "age": 30}
 
 a_person: Person
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Person`: value of type `None`"
-# error: [invalid-assignment]
 a_person = {"name": None, "age": 30}
 
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Person`: value of type `None`"
-# error: [invalid-assignment]
 (a_person := {"name": None, "age": 30})
 ```
 
 All of these have an extra field that is not defined in the `TypedDict`:
 
 ```py
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
-# error: [invalid-assignment]
 alice4: Person = {"name": "Alice", "age": 30, "extra": True}
 
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
@@ -320,11 +308,9 @@ house.owner = {"name": "Alice", "age": 30, "extra": True}
 
 a_person: Person
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
-# error: [invalid-assignment]
 a_person = {"name": "Alice", "age": 30, "extra": True}
 
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
-# error: [invalid-assignment]
 (a_person := {"name": "Alice", "age": 30, "extra": True})
 ```
 
@@ -520,6 +506,15 @@ dangerous(alice)
 reveal_type(alice["name"])  # revealed: str
 ```
 
+Likewise, `dict`s are not assignable to typed dictionaries:
+
+```py
+alice: dict[str, str] = {"name": "Alice"}
+
+# error: [invalid-assignment] "Object of type `dict[str, str]` is not assignable to `Person`"
+alice: Person = alice
+```
+
 ## Key-based access
 
 ### Reading
@@ -790,7 +785,6 @@ class Employee(Person):
 alice: Employee = {"name": "Alice", "employee_id": 1}
 
 # error: [missing-typed-dict-key] "Missing required key 'employee_id' in TypedDict `Employee` constructor"
-# error: [invalid-assignment]
 eve: Employee = {"name": "Eve"}
 
 def combine(p: Person, e: Employee):
@@ -892,7 +886,6 @@ p1: TaggedData[int] = {"data": 42, "tag": "number"}
 p2: TaggedData[str] = {"data": "Hello", "tag": "text"}
 
 # error: [invalid-argument-type] "Invalid argument to key "data" with declared type `int` on TypedDict `TaggedData`: value of type `Literal["not a number"]`"
-# error: [invalid-assignment]
 p3: TaggedData[int] = {"data": "not a number", "tag": "number"}
 
 class Items(TypedDict, Generic[T]):
@@ -926,7 +919,6 @@ p1: TaggedData[int] = {"data": 42, "tag": "number"}
 p2: TaggedData[str] = {"data": "Hello", "tag": "text"}
 
 # error: [invalid-argument-type] "Invalid argument to key "data" with declared type `int` on TypedDict `TaggedData`: value of type `Literal["not a number"]`"
-# error: [invalid-assignment]
 p3: TaggedData[int] = {"data": "not a number", "tag": "number"}
 
 class Items[T](TypedDict):
@@ -961,9 +953,6 @@ grandchild: Node = {"name": "grandchild", "parent": child}
 nested: Node = {"name": "n1", "parent": {"name": "n2", "parent": {"name": "n3", "parent": None}}}
 
 # error: [invalid-argument-type] "Invalid argument to key "name" with declared type `str` on TypedDict `Node`: value of type `Literal[3]`"
-# error: [invalid-assignment]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
 nested_invalid: Node = {"name": "n1", "parent": {"name": "n2", "parent": {"name": 3, "parent": None}}}
 ```
 
@@ -1066,7 +1055,6 @@ def write_to_non_literal_string_key(person: Person, str_key: str):
 
 def create_with_invalid_string_key():
     # error: [invalid-key]
-    # error: [invalid-assignment]
     alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
 
     # error: [invalid-key]

crates/ty_python_semantic/src/types/call/bind.rs

@@ -3582,6 +3582,11 @@ impl<'db> BindingError<'db> {
                 expected_ty,
                 provided_ty,
             } => {
+                // TODO: Ideally we would not emit diagnostics for `TypedDict` literal arguments
+                // here (see `diagnostic::is_invalid_typed_dict_literal`). However, we may have
+                // silenced diagnostics during overload evaluation, and rely on the assignability
+                // diagnostic being emitted here.
+
                 let range = Self::get_node(node, *argument_index);
                 let Some(builder) = context.report_lint(&INVALID_ARGUMENT_TYPE, range) else {
                     return;

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -2003,6 +2003,20 @@ pub(super) fn report_slice_step_size_zero(context: &InferContext, node: AnyNodeR
     builder.into_diagnostic("Slice step size can not be zero");
 }
 
+// We avoid emitting invalid assignment diagnostic for literal assignments to a `TypedDict`, as
+// they can only occur if we already failed to validate the dict (and emitted some diagnostic).
+pub(crate) fn is_invalid_typed_dict_literal(
+    db: &dyn Db,
+    target_ty: Type,
+    source: AnyNodeRef<'_>,
+) -> bool {
+    target_ty
+        .filter_union(db, Type::is_typed_dict)
+        .as_typed_dict()
+        .is_some()
+        && matches!(source, AnyNodeRef::ExprDict(_))
+}
+
 fn report_invalid_assignment_with_message(
     context: &InferContext,
     node: AnyNodeRef,
@@ -2040,15 +2054,27 @@ pub(super) fn report_invalid_assignment<'db>(
     target_ty: Type,
     mut source_ty: Type<'db>,
 ) {
+    let value_expr = match definition.kind(context.db()) {
+        DefinitionKind::Assignment(def) => Some(def.value(context.module())),
+        DefinitionKind::AnnotatedAssignment(def) => def.value(context.module()),
+        DefinitionKind::NamedExpression(def) => Some(&*def.node(context.module()).value),
+        _ => None,
+    };
+
+    if let Some(value_expr) = value_expr
+        && is_invalid_typed_dict_literal(context.db(), target_ty, value_expr.into())
+    {
+        return;
+    }
+
     let settings =
         DisplaySettings::from_possibly_ambiguous_type_pair(context.db(), target_ty, source_ty);
 
-    if let DefinitionKind::AnnotatedAssignment(annotated_assignment) = definition.kind(context.db())
-        && let Some(value) = annotated_assignment.value(context.module())
-    {
+    if let Some(value_expr) = value_expr {
         // Re-infer the RHS of the annotated assignment, ignoring the type context for more precise
         // error messages.
-        source_ty = infer_isolated_expression(context.db(), definition.scope(context.db()), value);
+        source_ty =
+            infer_isolated_expression(context.db(), definition.scope(context.db()), value_expr);
     }
 
     report_invalid_assignment_with_message(
@@ -2070,6 +2096,11 @@ pub(super) fn report_invalid_attribute_assignment(
     source_ty: Type,
     attribute_name: &'_ str,
 ) {
+    // TODO: Ideally we would not emit diagnostics for `TypedDict` literal arguments
+    // here (see `diagnostic::is_invalid_typed_dict_literal`). However, we may have
+    // silenced diagnostics during attribute resolution, and rely on the assignability
+    // diagnostic being emitted here.
+
     report_invalid_assignment_with_message(
         context,
         node,

crates/ty_python_semantic/src/types/typed_dict.rs

@@ -8,7 +8,7 @@ use ruff_text_size::Ranged;
 use super::class::{ClassType, CodeGeneratorKind, Field};
 use super::context::InferContext;
 use super::diagnostic::{
-    INVALID_ARGUMENT_TYPE, INVALID_ASSIGNMENT, report_invalid_key_on_typed_dict,
+    self, INVALID_ARGUMENT_TYPE, INVALID_ASSIGNMENT, report_invalid_key_on_typed_dict,
     report_missing_typed_dict_key,
 };
 use super::{ApplyTypeMappingVisitor, Type, TypeMapping, visitor};
@@ -213,9 +213,13 @@ pub(super) fn validate_typed_dict_key_assignment<'db, 'ast>(
         return true;
     }
 
+    let value_node = value_node.into();
+    if diagnostic::is_invalid_typed_dict_literal(context.db(), item.declared_ty, value_node) {
+        return false;
+    }
+
     // Invalid assignment - emit diagnostic
-    if let Some(builder) = context.report_lint(assignment_kind.diagnostic_type(), value_node.into())
-    {
+    if let Some(builder) = context.report_lint(assignment_kind.diagnostic_type(), value_node) {
         let typed_dict_ty = Type::TypedDict(typed_dict);
         let typed_dict_d = typed_dict_ty.display(db);
         let value_d = value_ty.display(db);