@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/typeVar9.py

@@ -0,0 +1,118 @@
+# This sample tests the reporting of incorrect TypeVar usage within
+# a generic function. A TypeVar must appear at least twice to be
+# considered legitimate.
+
+# pyright: reportInvalidTypeVarUse=true
+
+from typing import AnyStr, Callable, Dict, Generic, List, TypeVar
+
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+
+class A(Generic[_T]):
+    def m1(self, v1: _T) -> None:
+        ...
+
+    # This should generate an error because _S
+    # is a local typeVar and appears only once.
+    def m2(self, v1: _S) -> None:
+        ...
+
+    # This should generate an error because _S
+    # is a local typeVar and appears only once.
+    def m3(self, v1: _T) -> _S:
+        ...
+
+
+# This should generate an error because _T
+# is a local typeVar and appears only once.
+def f1(v1: _T) -> None:
+    ...
+
+
+def f2(v1: _T, v2: List[_T]) -> None:
+    ...
+
+
+def f3(v1: _T) -> _T:
+    ...
+
+
+def f4() -> Dict[_T, _T]:
+    ...
+
+
+# This should generate an error because _T
+# is a local typeVar and appears only once.
+def f5() -> List[_T]:
+    ...
+
+
+_T_Bound = TypeVar("_T_Bound", bound=int)
+_T_Constrained = TypeVar("_T_Constrained", int, str)
+
+
+# Constrained TypeVars are exempt.
+def f6(v1: _T_Constrained):
+    ...
+
+
+# Bound TypeVars are not exempt.
+def f7(v1: _T_Bound):
+    ...
+
+
+# Bound TypeVars as type arguments are exempt when used in an
+# input parameter annotation.
+def f8(v1: List[_T_Bound]):
+    ...
+
+
+# Bound TypeVars as type arguments are not exempt when used in a
+# return annotation.
+def f9() -> List[_T_Bound]:
+    ...
+
+
+# TypeVars used as type args to a generic type alias are exempt.
+MyCallable = Callable[[_T], _T]
+
+
+def f10() -> MyCallable[_T]:
+    ...
+
+
+# This should generate an error because AnyStr can go unsolved.
+def f11(x: AnyStr = ...) -> AnyStr:
+    ...
+
+
+# This should generate an error because AnyStr can go unsolved.
+def f12(x: AnyStr = ...) -> List[AnyStr]:
+    ...
+
+
+def f13(x: AnyStr = ...) -> AnyStr | None:
+    ...
+
+
+def f14(x: AnyStr = "") -> AnyStr:
+    ...
+
+
+# This should generate an error because AnyStr can go unsolved.
+def f15(x: AnyStr = ...) -> List[AnyStr] | None:
+    ...
+
+
+class B(Generic[AnyStr]):
+    # This should generate an error because AnyStr can go unsolved.
+    def __init__(self, *, mode: AnyStr = ...) -> None:
+        ...
+
+
+class C(Generic[AnyStr]):
+    def __init__(self, *, mode: AnyStr = "") -> None:
+        ...

package/src/tests/samples/typedDict1.py

@@ -0,0 +1,63 @@
+# This sample tests the type analyzer's handling of TypedDict classes.
+
+from typing import Any, Dict, TypedDict
+
+not_total = False
+
+# This should generate an error because
+# the value of the total argument must
+# be a literal "True" or "False".
+class TD1(TypedDict, total=not_total):
+    pass
+
+
+class TD2(TypedDict, total=False):
+    """ This is a test """
+
+    a: int
+
+    # This should generate an error because "b"
+    # is redeclared below with a different type.
+    b: str
+
+    b: float
+
+    c: "Dict[Any, Any]"
+
+    # This should generate an error because
+    # assignments are not allowed.
+    d: float = 3.0
+
+    # This should generate an error because
+    # methods are not allowed.
+    def foo(self):
+        pass
+
+
+class TD3(TypedDict, total=True):
+    a: int
+    b: float
+    c: str
+
+
+class TD4(TypedDict):
+    d: str
+
+
+class TD5(TD3, total=False):
+    e: str
+
+    # This should generate an error because
+    # methods are not allowed.
+    def foo(self):
+        pass
+
+
+class NotATD:
+    pass
+
+
+# This should generate an error because non-TypeDict
+# base classes shouldn't be allowed for TD classes.
+class TD6(TD3, NotATD):
+    pass

package/src/tests/samples/typedDict10.py

@@ -0,0 +1,34 @@
+# This sample tests the type analyzer's handling of a variant
+# of the TypedDict "alternate syntax" defined in the Python docs.
+
+from typing import TypedDict
+
+Movie = TypedDict("Movie", name=str, year=int)
+
+
+def get_movie_name(movie: Movie):
+    return movie["name"]
+
+
+name2 = get_movie_name({"name": "ET", "year": 1982})
+
+movie1: Movie = {"name": "Blade Runner", "year": 1982}
+
+movie2: Movie = {
+    "name": "Blade Runner",
+    # This should generate an error because
+    # the type is incorrect.
+    "year": "1982",
+}
+
+movie3: Movie = {
+    # This should generate an error because
+    # all keys are required.
+    "name": "Blade Runner"
+}
+
+movie4: Movie = {
+    # This should generate an error because
+    # the key name is not supported.
+    "name2": "Blade Runner"
+}

package/src/tests/samples/typedDict11.py

@@ -0,0 +1,12 @@
+# This sample tests bidirectional type inference (expected type) for
+# lists that include TypedDicts.
+
+from typing import List, TypedDict
+
+
+MessageTypeDef = TypedDict("MessageTypeDef", {"Id": str, "Handle": str})
+
+msgs = [{"Id": "1", "Handle": "2"}]
+list2: List[MessageTypeDef] = [
+    {"Id": msg["Id"], "Handle": msg["Handle"]} for msg in msgs
+]

package/src/tests/samples/typedDict12.py

@@ -0,0 +1,103 @@
+# This sample tests the synthesized methods get, setdefault
+# pop, and __delitem__ for a TypedDict.
+
+# pyright: strict
+
+from typing import Optional, TypedDict, Union, final
+from typing_extensions import NotRequired, Required
+
+
+class TD1(TypedDict):
+    bar: NotRequired[str]
+
+
+class TD2(TD1):
+    foo: Required[str]
+
+
+td1: TD1 = {}
+td2: TD2 = {"foo": "hi"}
+
+v1: Optional[str] = td1.get("bar")
+
+v2: str = td1.get("bar", "")
+
+v3: Union[str, int] = td1.get("bar", 3)
+
+v4: str = td1.setdefault("bar", "1")
+
+# This should generate an error.
+td1.setdefault("bar", 3)
+
+# This should generate an error.
+td1.setdefault("bar")
+
+# This should generate an error.
+td1.setdefault("baz", "")
+
+v6: str = td1.pop("bar")
+v7: str = td1.pop("bar", "none")
+v8: Union[str, int] = td1.pop("bar", 3)
+
+# This should generate an error.
+v9: str = td2.pop("foo")
+
+td1.__delitem__("bar")
+
+
+@final
+class A(TypedDict):
+    foo: int
+    baz: NotRequired[int]
+
+
+class B(TypedDict):
+    bar: str
+
+
+C = Union[A, B]
+
+
+def test(a: A, b: B, c: C, s: str) -> Optional[int]:
+    a1 = a.get("foo")
+    reveal_type(a1, expected_text="int")
+    a2 = a.get("foo", 1.0)
+    reveal_type(a2, expected_text="int")
+    a3 = a.get("bar")
+    reveal_type(a3, expected_text="None")
+    a4 = a.get("bar", 1.0)
+    reveal_type(a4, expected_text="float")
+    a5 = a.get("baz")
+    reveal_type(a5, expected_text="int | None")
+    a6 = a.get("baz", 1.0)
+    reveal_type(a6, expected_text="int | float")
+    a7 = a.get(s)
+    reveal_type(a7, expected_text="Any | None")
+    a8 = a.get(s, 1.0)
+    reveal_type(a8, expected_text="Any | float")
+
+    b1 = b.get("bar")
+    reveal_type(b1, expected_text="str")
+    b2 = b.get("bar", 1.0)
+    reveal_type(b2, expected_text="str")
+    b3 = b.get("foo")
+    reveal_type(b3, expected_text="Any | None")
+    b4 = b.get("foo", 1.0)
+    reveal_type(b4, expected_text="Any | float")
+    b5 = b.get(s)
+    reveal_type(b5, expected_text="Any | None")
+    b6 = b.get(s, 1.0)
+    reveal_type(b6, expected_text="Any | float")
+
+    c1 = c.get("foo")
+    reveal_type(c1, expected_text="int | Any | None")
+    c2 = c.get("foo", 1.0)
+    reveal_type(c2, expected_text="int | Any | float")
+    c3 = c.get("bar")
+    reveal_type(c3, expected_text="str | None")
+    c4 = c.get("bar", 1.0)
+    reveal_type(c4, expected_text="float | str")
+    c5 = c.get("baz")
+    reveal_type(c5, expected_text="int | Any | None")
+    c6 = c.get("baz", 1.0)
+    reveal_type(c6, expected_text="int | float | Any")

package/src/tests/samples/typedDict13.py

@@ -0,0 +1,14 @@
+# This sample tests that TypedDicts that inherit from other
+# TypedDicts do not override field names with incompatible types.
+
+from typing import TypedDict
+
+
+ParentTD = TypedDict("ParentTD", {"name": str, "age": int})
+
+
+class ChildTD(ParentTD):
+    # This should generate an error because the type of "age" is redefined.
+    age: float
+
+    name: str

package/src/tests/samples/typedDict14.py

@@ -0,0 +1,25 @@
+# This sample tests bidirectional type inference when assigning
+# a value to a typedDict element.
+
+from typing import List, Optional, TypedDict, Union
+
+
+class Thing(TypedDict):
+    v1: bool
+    v2: str
+
+
+class Thing2(TypedDict):
+    v3: Optional[Thing]
+    v4: Optional[List[Union[str, int]]]
+
+
+thing2: Thing2 = {"v3": None, "v4": None}
+thing2["v3"] = {"v1": False, "v2": "a"}
+thing2["v4"] = []
+thing2["v4"] = [3]
+thing2["v4"] = ["hi"]
+thing2["v4"] = ["hi", 4]
+
+# This should generate an error
+thing2["v4"] = ["hi", 4.0]

package/src/tests/samples/typedDict15.py

@@ -0,0 +1,53 @@
+# This sample tests the type compatibility checks when the source
+# is a TypedDict and the dest is a protocol.
+
+from typing import Protocol, TypeVar, TypedDict
+
+
+class HasName(Protocol):
+    name: str
+
+
+class SupportsClear(Protocol):
+    def clear(self) -> None:
+        ...
+
+
+_T = TypeVar("_T")
+
+
+class SupportsUpdate(Protocol):
+    def update(self: _T, __m: _T) -> None:
+        ...
+
+
+class B(TypedDict):
+    name: str
+
+
+def print_name(x: HasName):
+    print(x.name)
+
+
+my_typed_dict: B = {"name": "my name"}
+
+# This should generate an error. The "name"
+# attribute of a TypedDict can't be accessed
+# through a member access expression.
+print_name(my_typed_dict)
+
+
+def do_clear(x: SupportsClear):
+    x.clear()
+
+
+# This should generate an error. Although a "dict"
+# class supports clear, a TypedDict does not.
+do_clear(my_typed_dict)
+
+
+def do_update(x: SupportsUpdate):
+    x.update(x)
+
+
+do_update(my_typed_dict)

package/src/tests/samples/typedDict16.py

@@ -0,0 +1,103 @@
+# This sample tests that type compatibility between TypedDicts.
+
+from typing import List, TypedDict, final
+
+
+class TD0(TypedDict):
+    key: str
+
+
+class TD1(TD0):
+    value: str
+
+
+class TD2(TypedDict):
+    key: str
+    value: str
+
+
+v1: TD2 = TD1(key="", value="")
+v2: TD1 = TD2(key="", value="")
+
+v3 = [v2]
+v4: List[TD2] = v3
+v5 = [v1]
+v6: List[TD1] = v5
+
+
+class TD10(TypedDict, total=False):
+    key: str
+
+
+class TD11(TD10):
+    value: str
+
+
+class TD12(TypedDict):
+    key: str
+    value: str
+
+
+# This should generate an error.
+v10: TD12 = TD11(key="", value="")
+
+# This should generate an error.
+v11: TD11 = TD12(key="", value="")
+
+
+v12 = [v10]
+# This should generate an error.
+v13: List[TD10] = v12
+
+v14 = [v11]
+# This should generate an error.
+v15: List[TD12] = v14
+
+
+class TD20(TypedDict):
+    key: str
+    value: str
+
+
+class TD21(TypedDict):
+    key: str
+    value: str
+    extra: str
+
+
+# This should generate an error.
+v20: TD21 = TD20(key="", value="")
+
+v21: TD20 = TD21(key="", value="", extra="")
+
+
+v22 = [v20]
+# This should generate an error.
+v23: List[TD20] = v22
+
+v24: List[TD20] = [v21]
+# This should generate an error.
+v25: List[TD21] = v24
+
+
+@final
+class TD30(TypedDict):
+    value: str
+
+@final
+class TD31(TypedDict):
+    value: str
+
+class TD32(TypedDict):
+    value: str
+
+
+v30: TD30 = TD31(value="")
+v31: TD31 = TD30(value="")
+
+# This should generate an error because of a @final mismatch.
+v32: TD32 = TD30(value="")
+
+# This should generate an error because of a @final mismatch.
+v33: TD30 = TD32(value="")
+

package/src/tests/samples/typedDict17.py

@@ -0,0 +1,24 @@
+# This sample tests the handling of the "|" and "|=" operators
+# for TypedDicts.
+
+from typing import TypedDict
+
+
+class Person(TypedDict, total=False):
+    name: str
+    age: int
+
+
+person: Person = {}
+
+person.update({"name": "Michael"})
+
+person |= {"name": "Michael"}
+person = person | {"name": "Michael"}
+
+
+# This should generate an error.
+person |= {"name": "Michael", "other": 1}
+
+# This should generate an error.
+person = person | {"name": 1}

package/src/tests/samples/typedDict18.py

@@ -0,0 +1,43 @@
+# This sample tests the handling of generic TypedDicts which are
+# supported in Python 3.11 and newer.
+
+from typing import Generic, TypeVar, TypedDict
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+
+
+class TD1(TypedDict, Generic[_T1, _T2]):
+    a: dict[_T1, _T2]
+    b: _T1
+
+
+v1_1: TD1[str, int] = {"a": {"x": 3}, "b": "y"}
+
+# This should generate an error.
+v1_2: TD1[str, str] = {"a": {"x": 3}, "b": "y"}
+
+
+class TD2(TD1[_T1, int]):
+    c: _T1
+
+
+v2_1: TD2[int] = {"a": {3: 3}, "b": 1, "c": 5}
+
+
+class TD3(TypedDict):
+    a: int
+
+
+class TD4(TD3, Generic[_T1]):
+    b: _T1
+
+
+v4: TD4[str] = {"a": 3, "b": ""}
+
+
+def func1(x: TD1[_T1, _T2]) -> dict[_T1, _T2]:
+    return x["a"]
+
+v1_3 = func1({"a": {"x": 3}, "b": "y"})
+reveal_type(v1_3, expected_text="dict[str, int]")

package/src/tests/samples/typedDict2.py

@@ -0,0 +1,56 @@
+# This sample tests the type analyzer's handling of TypedDict classes.
+
+from typing import TypedDict
+
+
+class Movie(TypedDict, total=False):
+    name: str
+    year: int
+
+
+class BookBasedMovie(Movie, total=True):
+    based_on: str
+
+
+def get_movie_name(movie: Movie):
+    return movie.get("name")
+
+
+name2 = get_movie_name({"name": "ET", "year": 1982})
+
+movie1: Movie = {"name": "Blade Runner", "year": 1982}
+
+movie2: Movie = {
+    "name": "Blade Runner",
+    # This should generate an error because
+    # the type is incorrect.
+    "year": "1982",
+}
+
+movie3: Movie = {"name": "Blade Runner"}
+
+movie4: Movie = {
+    # This should generate an error because
+    # the key name is not supported.
+    "name2": "Blade Runner"
+}
+
+book1: BookBasedMovie = {"name": "Moonraker", "year": 1979, "based_on": "Moonraker"}
+
+book2: BookBasedMovie = {"year": 1979, "based_on": "Moonraker"}
+
+book3: BookBasedMovie = {"based_on": "Moonraker"}
+
+book4: BookBasedMovie = {
+    # This should generate an error because 'author' isn't
+    # a defined field.
+    "author": "Ian Fleming",
+    "based_on": "Moonraker",
+}
+
+book5: BookBasedMovie = {
+    "name": "Moonraker",
+    "year": 1979
+    # This should generate an error because 'based_on' is
+    # a required field, and it's not provided.
+}

package/src/tests/samples/typedDict3.py

@@ -0,0 +1,40 @@
+# This sample tests the type analyzer's handling of TypedDict classes.
+
+from typing import TypedDict
+
+
+class Movie(TypedDict, total=False):
+    name: str
+    year: int
+
+
+class BookBasedMovie(Movie, total=True):
+    based_on: str
+
+
+movie1 = Movie(year=1982, name="Blade Runner")
+
+# This should generate an error because
+# the type is incorrect.
+movie2 = Movie(name="Blade Runner", year="1982")
+
+movie3 = Movie(name="Blade Runner")
+
+# This should generate an error because
+# the key name is not supported.
+movie4 = Movie(name2="Blade Runner")
+
+
+book1 = BookBasedMovie(year=1979, name="Moonraker", based_on="Moonraker")
+
+book2 = BookBasedMovie(based_on="Moonraker", year=1979)
+
+book3 = BookBasedMovie(based_on="Moonraker")
+
+# This should generate an error because 'author' isn't
+# a defined field.
+book4 = BookBasedMovie(based_on="Moonraker", author="Ian Fleming")
+
+# This should generate an error because 'based_on' is
+# a required field, and it's not provided.
+book5 = BookBasedMovie(year=1982, name="Blade Runner")