dict is not assignable to TypedDict

Author: ibraheemdev

crates/ty_python_semantic/resources/mdtest/bidirectional.md

@@ -76,6 +76,7 @@ def _() -> TD:
 
 def _() -> TD:
     # error: [missing-typed-dict-key] "Missing required key 'x' in TypedDict `TD` constructor"
+    # error: [invalid-return-type]
     return {}
 ```
 

crates/ty_python_semantic/resources/mdtest/call/overloads.md

@@ -1685,8 +1685,7 @@ def int_or_str() -> int | str:
 x = f([{"x": 1}], int_or_str())
 reveal_type(x)  # revealed: int | str
 
-# TODO: error: [no-matching-overload] "No overload of function `f` matches arguments"
-# we currently incorrectly consider `list[dict[str, int]]` a subtype of `list[T]`
+# error: [no-matching-overload] "No overload of function `f` matches arguments"
 f([{"y": 1}], int_or_str())
 ```
 

crates/ty_python_semantic/resources/mdtest/call/union.md

@@ -277,7 +277,6 @@ def _(flag: bool):
     x = f({"x": 1})
     reveal_type(x)  # revealed: int
 
-    # TODO: error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `T`, found `dict[str, int]`"
-    # we currently consider `TypedDict` instances to be subtypes of `dict`
+    # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `T`, found `dict[Unknown | str, Unknown | int]`"
     f({"y": 1})
 ```

crates/ty_python_semantic/resources/mdtest/comprehensions/basic.md

@@ -162,10 +162,13 @@ The type context is propagated down into the comprehension:
 class Person(TypedDict):
     name: str
 
+# TODO: This should not error.
+# error: [invalid-assignment]
 persons: list[Person] = [{"name": n} for n in ["Alice", "Bob"]]
 reveal_type(persons)  # revealed: list[Person]
 
-# TODO: This should be an error
+# TODO: This should be an invalid-key error.
+# error: [invalid-assignment]
 invalid: list[Person] = [{"misspelled": n} for n in ["Alice", "Bob"]]
 ```
 

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

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

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -83,6 +83,7 @@ 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:
@@ -95,30 +96,33 @@ 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`"
 eve1b = Person(name=b"Eve", age=None)
 
-# TODO should reveal Person (should be fixed by implementing assignability for TypedDicts)
-reveal_type(eve1a)  # revealed: dict[Unknown | str, Unknown | bytes | None]
+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"
 eve2b = Person(age=22)
 
-# TODO should reveal Person (should be fixed by implementing assignability for TypedDicts)
-reveal_type(eve2a)  # revealed: dict[Unknown | str, Unknown | int]
+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""
 eve3b = Person(name="Eve", age=25, extra=True)
 
-# TODO should reveal Person (should be fixed by implementing assignability for TypedDicts)
-reveal_type(eve3a)  # revealed: dict[Unknown | str, Unknown | str | int]
+reveal_type(eve3a)  # revealed: Person
 reveal_type(eve3b)  # revealed: Person
 ```
 
@@ -201,6 +205,8 @@ 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}}
 ```
 
@@ -237,64 +243,88 @@ 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"
 Person(name="Alice")
+
 # error: [missing-typed-dict-key] "Missing required key 'age' in TypedDict `Person` constructor"
 Person({"name": "Alice"})
 
 # error: [missing-typed-dict-key] "Missing required key 'age' in TypedDict `Person` constructor"
+# error: [invalid-argument-type]
 accepts_person({"name": "Alice"})
 
-# TODO: this should be an error, similar to the above
+# TODO: this should be an invalid-key error, similar to the above
+# error: [invalid-assignment]
 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`"
 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`"
 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-argument-type]
 accepts_person({"name": None, "age": 30})
-# TODO: this should be an error, similar to the above
+
+# TODO: this should be an invalid-key error
+# error: [invalid-assignment]
 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""
 Person(name="Alice", age=30, extra=True)
+
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
 Person({"name": "Alice", "age": 30, "extra": True})
 
 # error: [invalid-key] "Invalid key for TypedDict `Person`: Unknown key "extra""
+# error: [invalid-argument-type]
 accepts_person({"name": "Alice", "age": 30, "extra": True})
-# TODO: this should be an error
+
+# TODO: this should be an invalid-key error
+# error: [invalid-assignment]
 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})
 ```
 
@@ -760,6 +790,7 @@ 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):
@@ -861,6 +892,7 @@ 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]):
@@ -894,6 +926,7 @@ 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):
@@ -928,6 +961,9 @@ 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}}}
 ```
 
@@ -977,7 +1013,7 @@ class Person(TypedDict):
     name: str
     age: int | None
 
-# TODO: this should be an error
+# error: [invalid-assignment] "Object of type `MyDict` is not assignable to `Person`"
 x: Person = MyDict({"name": "Alice", "age": 30})
 ```
 
@@ -1029,8 +1065,12 @@ def write_to_non_literal_string_key(person: Person, str_key: str):
     person[str_key] = "Alice"  # error: [invalid-key]
 
 def create_with_invalid_string_key():
-    alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}  # error: [invalid-key]
-    bob = Person(name="Bob", age=25, unknown="Bar")  # error: [invalid-key]
+    # error: [invalid-key]
+    # error: [invalid-assignment]
+    alice: Person = {"name": "Alice", "age": 30, "unknown": "Foo"}
+
+    # error: [invalid-key]
+    bob = Person(name="Bob", age=25, unknown="Bar")
 ```
 
 Assignment to `ReadOnly` keys:

crates/ty_python_semantic/src/types.rs

@@ -1975,11 +1975,14 @@ impl<'db> Type<'db> {
                 ConstraintSet::from(false)
             }
 
-            (Type::TypedDict(_), _) | (_, Type::TypedDict(_)) => {
+            (Type::TypedDict(_), _) => {
                 // TODO: Implement assignability and subtyping for TypedDict
                 ConstraintSet::from(relation.is_assignability())
             }
 
+            // A non-`TypedDict` cannot subtype a `TypedDict`
+            (_, Type::TypedDict(_)) => ConstraintSet::from(false),
+
             // Note that the definition of `Type::AlwaysFalsy` depends on the return value of `__bool__`.
             // If `__bool__` always returns True or False, it can be treated as a subtype of `AlwaysTruthy` or `AlwaysFalsy`, respectively.
             (left, Type::AlwaysFalsy) => ConstraintSet::from(left.bool(db).is_always_false()),