@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/typedDict4.py

@@ -0,0 +1,68 @@
+# This sample tests the type analyzer's handling of TypedDict classes.
+
+from typing import Literal, Optional, TypedDict, Union
+
+
+class Movie(TypedDict, total=False):
+    name: str
+    year: int
+
+
+class BookBasedMovie(Movie, total=True):
+    based_on: str
+
+
+movie1 = Movie(name="Blade Runner", year=1982)
+
+
+def get_value(movie: Movie, key: Literal["year", "name"]) -> Optional[Union[int, str]]:
+    if "year" in movie and "name" in movie:
+        return movie[key]
+
+
+def make_movie(name: str, year: int) -> Movie:
+    return {"name": name, "year": year}
+
+
+name1 = movie1.get("name", "Blue Nile")
+year1 = movie1.get("year", 1921)
+movie2 = make_movie(name1, year1)
+
+# This should generate an error because all indices need
+# to be string literals.
+year2 = movie1[3]
+
+# This should generate an error because only one index
+# is allowed.
+year3 = movie1[3, 3]
+
+movie1["name"] = "Transformers"
+movie1["year"] = 2007
+
+# This should generate an error because the RHS is the wrong type.
+movie1["name"] = [3]
+
+# This should generate an error because the RHS is the wrong type.
+movie1["year"] = {}
+
+del movie1["year"]
+
+# This should generate an error because the key is not in the dictionary.
+del movie1["year2"]
+
+# This should generate an error because entries in a TypedDict
+# are not accessible through member access.
+name2 = movie1.name
+
+book1 = BookBasedMovie(based_on="E.T.")
+make_movie(name=book1["based_on"], year=1923)
+
+del book1["name"]
+
+# This should generate an error because you can't delete a required key.
+del book1["based_on"]
+
+# Make sure "in" operator works with TypedDict.
+movie3 = Movie()
+if "d" in movie3:
+    pass

package/src/tests/samples/typedDict5.py

@@ -0,0 +1,50 @@
+# This sample tests the type analyzer's handling of TypedDict classes.
+
+from typing import TypedDict
+
+
+class Movie1(TypedDict, total=False):
+    name: str
+    year: int
+
+
+class Movie2(TypedDict, total=False):
+    name: str
+    year: int
+
+
+class Movie3(TypedDict, total=True):
+    name: str
+    year: int
+
+
+class Movie4(TypedDict, total=True):
+    name: str
+    year: int
+    earnings: float
+
+
+movie1: Movie1 = Movie2(name="hello", year=1971)
+
+# This should generate an error because
+# items are required in Movie3 but not Movie2.
+movie2: Movie2 = Movie3(name="hello", year=1971)
+
+# This should generate an error because
+# items are required in Movie3 but not Movie2.
+movie3: Movie3 = Movie2(name="hello", year=1971)
+
+# This should generate an error
+movie4: Movie4 = Movie3(name="hello", year=1971)
+
+movie5: Movie3 = Movie4(name="hello", year=1971, earnings=23)
+
+
+movie6 = Movie2(name="hello", year=1971)
+movie6["name"] = "goodbye"
+
+movie7 = {"name": "hello", "year": 1971}
+movie7["name"] = "goodbye"
+
+movie8: Movie2 = {"year": 1981, "name": "test"}
+movie8["year"] = 1982

package/src/tests/samples/typedDict6.py

@@ -0,0 +1,77 @@
+# This sample tests the type analyzer's handling of TypedDict
+# "alternate syntax" defined in PEP 589.
+
+from typing import TypedDict
+
+Movie = TypedDict("Movie", {"name": str, "year": int})
+
+# This should generate an error because
+# the arguments are missing.
+Movie2 = TypedDict()
+
+# This should generate an error because
+# the arguments are missing.
+Movie3 = TypedDict("Movie3")
+
+# This should generate an error because
+# the argument type is wrong.
+Movie4 = TypedDict("Movie4", 3)
+
+# This should generate an error because
+# the argument type is wrong.
+Movie5 = TypedDict(3, {})
+
+Movie6 = TypedDict("Movie6", {}, total=False)
+Movie7 = TypedDict("Movie7", {}, total=True)
+
+# This should generate an error because the total param
+# accepts only True or False.
+Movie8 = TypedDict("Movie8", {}, total=3)
+
+# This should generate an error because the third arg
+# is unknown.
+Movie9 = TypedDict("Movie9", {}, random=3)
+
+# This should generate an error because the third arg
+# is unknown.
+Movie10 = TypedDict("Movie10", {}, 3)
+
+# This should generate an error because a fourth arg
+# is not supported.
+Movie11 = TypedDict("Movie11", {}, total=True, foo=3)
+
+
+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"
+}
+
+MovieNotTotal = TypedDict("MovieNotTotal", {"name": str, "year": int}, total=False)
+
+movie5: MovieNotTotal = {"name": "Blade Runner"}
+
+
+def foo(unknown_str_value: str):
+    a = movie5[unknown_str_value]

package/src/tests/samples/typedDict7.py

@@ -0,0 +1,22 @@
+# This sample tests synthesized get methods in TypedDict classes.
+
+from typing import TypedDict, Union
+
+UserType1 = TypedDict("UserType1", {"name": str, "age": int}, total=False)
+user1: UserType1 = {"name": "Bob", "age": 40}
+
+name1: str = user1.get("name", "n/a")
+age1: int = user1.get("age", 42)
+
+UserType2 = TypedDict("UserType2", name=str, age=int)
+user2: UserType2 = {"name": "Bob", "age": 40}
+
+name2: Union[str, None] = user2.get("name")
+
+name3: str = user2.get("name")
+
+age2: int = user2.get("age", 42)
+
+age3: Union[int, str] = user2.get("age", "42")
+
+age4: int = user2.get("age", "42")

package/src/tests/samples/typedDict8.py

@@ -0,0 +1,19 @@
+# This sample tests the ability of the type checker to
+# perform bidirectional type inference involving TypedDict
+# classes and dict literal expressions.
+
+from typing import List, TypedDict
+
+
+class Entry(TypedDict):
+    index: int
+    value: str
+
+
+entries1: List[Entry] = [{"index": 2, "value": "a"}, {"index": 5, "value": "b"}]
+
+# This should generate an error
+entries2: List[Entry] = [{"index": 2, "value": "a"}, {"index": "2", "value": "b"}]
+
+# This should generate an error
+entries3: List[Entry] = [{"index": 2, "value": "a"}, 3]

package/src/tests/samples/typedDict9.py

@@ -0,0 +1,22 @@
+# This sample tests the handling of nested TypedDict fields.
+
+from typing import TypedDict
+
+
+class Inner1(TypedDict):
+    inner_key: str
+
+
+class Inner2(TypedDict):
+    inner_key: Inner1
+
+
+class Outer(TypedDict):
+    outer_key: Inner2
+
+
+o1: Outer = {"outer_key": {"inner_key": {"inner_key": "hi"}}}
+
+# This should generate an error because the inner-most value
+# should be a string.
+o2: Outer = {"outer_key": {"inner_key": {"inner_key": 1}}}

package/src/tests/samples/unbound1.py

@@ -0,0 +1,18 @@
+# This sample tests the type checker's ability to determine which
+# symbols are potentially unbound.
+
+if True:
+
+    class X:
+        # This should generate an error because 'X' is not yet declared.
+        def foo(self) -> X:
+            return X()
+
+    a: X
+
+    class A:
+        a: X
+        b = X
+
+        def fn(self) -> X:
+            return X()

package/src/tests/samples/unbound2.py

@@ -0,0 +1,12 @@
+# This sample validates that an unbound variable error is reported
+# even if that variable has a type declaration.
+
+
+def fn1():
+    aaa: int
+
+    # This should generate an error because aaa is unbound.
+    return aaa
+
+
+fn1()

package/src/tests/samples/unbound3.py

@@ -0,0 +1,13 @@
+# This sample tests that "possibly unbound" error messages don't propagate.
+
+
+def foo(a: bool):
+    if a:
+        b = 3
+
+    # This should generate an error.
+    c = b
+
+    # These should not.
+    d = c
+    e = d

package/src/tests/samples/unbound4.py

@@ -0,0 +1,25 @@
+# This sample tests that an unbound variable that is generated in
+# a function does not propagate beyond that function to callers.
+
+
+def func1():
+    # This should generate an error
+    return a
+
+
+# This should not.
+b = func1()
+reveal_type(b, expected_text="Unknown")
+
+
+def func2(val: int):
+    if val < 3:
+        return val
+
+    # This should generate an error
+    return a
+
+
+# This should not.
+c = func2(36)
+reveal_type(c, expected_text="int | Unknown")

package/src/tests/samples/unicode1.py

@@ -0,0 +1,39 @@
+# This sample tests a variety of unicode characters including those that
+# require two-code (surrogate) forms.
+
+# Old Italic
+𐌎𐌘𐌟𐌁 = 42
+
+# Egyptian hieroglyphs
+𓃘𓐭𓇀𓅨𓆙 = 2
+
+# Linear B Ideograms
+𐂂𐃪𐃯 = ""
+
+# Cuneiform
+𒀟𒀕𒀰𒁜𒂐𒄊 = ""
+
+# Old Persian
+𐎠𐏊𐏏 = 3
+
+# Lydian
+𐤢𐤷𐤬𐤮 = 4
+
+# Phoenician
+𐤔𐤑𐤇 = 4
+
+# Nabataean
+𐢖𐢊ﬗ = 0
+
+# This should generate an error because "𐢭" is outside the range of
+# characters supported by the Python standard.
+𐢭 = 0
+
+# Other surrogate characters
+𝓐 = 3
+𝙰 = 4
+𝚫 = 3
+𞡏 = 4
+𞥁 = 0
+
+

package/src/tests/samples/uninitializedVariable1.py

@@ -0,0 +1,27 @@
+# This sample tests the reportUninitializedInstanceVariable functionality.
+
+from dataclasses import dataclass
+from typing import TypedDict
+
+
+class A:
+    # This should generate an error if reportUninitializedInstanceVariable
+    # is enabled.
+    v1: int
+    v2: int
+    v3 = 2
+    v4: int = 3
+
+    def __init__(self) -> None:
+        self.v2 = 3
+        super().__init__()
+
+
+@dataclass
+class B:
+    x: int
+
+
+class C(TypedDict):
+    member1: str
+    member2: str

package/src/tests/samples/unions1.py

@@ -0,0 +1,79 @@
+# This sample tests the alternative syntax for unions as
+# documented in PEP 604.
+
+from typing import Callable, Generic, TypeVar, Union
+
+
+def foo2(a: int | str):
+    if isinstance(a, int):
+        return 1
+    else:
+        return 2
+
+
+B = bytes | None | Callable[[], None]
+A = int | str | B
+
+
+def foo3(a: A) -> B:
+    if a == 3 or a is None:
+        return b""
+    elif not isinstance(a, (int, str, bytes)):
+        a()
+
+
+def foo4(A: "int | str"):
+    return 1
+
+
+T = TypeVar("T")
+
+
+def foo5(a: str):
+    def helper(value: T) -> T | None:
+        ...
+
+    class Baz(Generic[T]):
+        qux: T | None
+
+    reveal_type(helper(a), expected_text="str | None")
+    reveal_type(Baz[str].qux, expected_text="str | None")
+
+
+T = TypeVar("T")
+TT = TypeVar("TT", bound=type)
+
+
+def decorator1(value: type[T]) -> type[T]:
+    ...
+
+
+def decorator2(value: TT) -> TT:
+    ...
+
+
+class ClassA:
+    class ClassA_A:
+        pass
+
+    @decorator1
+    class ClassA_B:
+        pass
+
+    @decorator2
+    class ClassA_C:
+        pass
+
+
+a_or_str: "ClassA.ClassA_A | str"
+b_or_str: "ClassA.ClassA_B | str"
+b_or_str_Union: Union[ClassA.ClassA_B, str]
+c_or_str: "ClassA.ClassA_C | str"
+
+Alias1 = None | str
+Alias2 = str | None
+
+_T = TypeVar("_T")
+
+Alias3 = _T | str
+Alias4 = str | _T

package/src/tests/samples/unions2.py

@@ -0,0 +1,15 @@
+# This sample verifies that bitwise or operator is not
+# interpreted as a Union operator in cases where it
+# shouldn't be.
+
+from typing import Any
+
+
+class my_class:
+    def __init__(self, v):
+        self._v = v
+
+
+def test_bad_syntax(a: Any, b: Any):
+    r = my_class(a | b)
+    print(r)

package/src/tests/samples/unions3.py

@@ -0,0 +1,48 @@
+# This sample verifies that the "logical or" operator
+# is supported for classes that have a custom metaclass
+# with a __or__ or __ror__ method defined.
+
+
+from typing import Type, TypeVar
+
+
+class ClassWithNoMeta1:
+    pass
+
+
+class ClassWithNoMeta2:
+    pass
+
+
+NoMetaUnion = ClassWithNoMeta1 | ClassWithNoMeta2
+reveal_type(
+    NoMetaUnion, expected_text="Type[ClassWithNoMeta1] | Type[ClassWithNoMeta2]"
+)
+
+_T = TypeVar("_T")
+
+
+class Metaclass1(type):
+    def __or__(cls: _T, other: type) -> _T:
+        ...
+
+
+class Metaclass2(type):
+    def __ror__(cls: _T, other: type) -> _T:
+        ...
+
+
+class ClassWithMeta1(metaclass=Metaclass1):
+    pass
+
+
+class ClassWithMeta2(metaclass=Metaclass2):
+    pass
+
+
+def requires_class_with_meta1(val: Type[ClassWithMeta1]):
+    pass
+
+
+MetaOr1 = ClassWithMeta1 | ClassWithNoMeta1
+requires_class_with_meta1(MetaOr1)

package/src/tests/samples/unions4.py

@@ -0,0 +1,20 @@
+# This sample tests the incorrect usage of Union types.
+
+from typing import Union
+
+x = Union[int, str]
+
+
+# This should generate an error.
+y = Union[int]
+
+z = Union
+
+
+# This should generate an error.
+def func1() -> Union:
+    ...
+
+
+# This should generate an error.
+var1: Union

package/src/tests/samples/unions5.py

@@ -0,0 +1,43 @@
+# This sample tests the handling of runtime union expressions that
+# are used in contexts other than a type annotation.
+
+from typing import Union
+
+
+class Foo:
+    a: int
+
+
+class Bar:
+    a: int
+
+
+# This should generate an error
+a1: type[Foo] | type[Bar] = Foo | Bar
+
+print(a1.a)
+a1()
+
+# This should generate an error
+a2: type[Foo] | type[Bar] = Union[Foo, Bar]
+
+print(a2.a)
+a2()
+
+
+b1 = Foo | Bar
+
+# This should generate an error
+print(b1.a)
+
+# This should generate an error
+b1()
+
+
+b2 = Union[Foo, Bar]
+
+# This should generate an error
+print(b2.a)
+
+# This should generate an error
+b2()

package/src/tests/samples/unnecessaryCast1.py

@@ -0,0 +1,13 @@
+# This sample tests the type checker's reportUnnecessaryCast feature.
+
+from typing import cast, Union
+
+
+def foo(a: int):
+    # This should generate an error if
+    # reportUnnecessaryCast is enabled.
+    b = cast(int, a)
+
+
+c: Union[int, str] = "hello"
+d = cast(int, c)