@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/literals1.py

@@ -0,0 +1,48 @@
+# This sample tests type checking support for "Literal"
+
+from typing import Literal
+
+ValidResponses = Literal["a", b"b", "c" "c", True, None]
+
+
+def foo(a: ValidResponses):
+    pass
+
+
+foo("a")
+foo(b"b")
+foo("cc")
+foo(True)
+foo(None)
+
+# This should generate an error because 'b'
+# isn't a valid literal value.
+foo("b")
+
+# This should generate an error because 'cc'
+# isn't a valid literal value.
+foo("c")
+
+# This should generate an error because False
+# isn't a valid literal value.
+foo(False)
+
+# This should generate an error because 3
+# isn't a valid literal value.
+foo(3)
+
+
+# This should generate an error because floats
+# cannot be used as literals.
+invalidType = 3  # type: Literal[3.4]
+
+# This should generate an error because 2
+# is not a valid literal value.
+mismatch = 2  # type: Literal[3, 4, '5']
+
+a: Literal[3] = -(-(+++3))
+b: Literal[-2] = +-+2
+
+# This should generate an error because literals are
+# not instantiable.
+c = Literal[1]()

package/src/tests/samples/literals2.py

@@ -0,0 +1,30 @@
+# This sample tests assignment of literals to declared
+# types that use literals in their type arguments.
+
+from typing import Dict, List, Literal, Set, TypeVar
+
+Number = Literal["One", "Two"]
+
+# This should generate an error because 'Three' is not
+# allowed in the Number type.
+numbers_mapping: Dict[Number, int] = {"One": 1, "Two": 2, "Three": 3}
+
+# This should generate an error because 'Three' is not
+# allowed in the Number type.
+a: List[Number] = ["Three"]
+
+# This should generate an error because 'Three' is not
+# allowed in the Number type.
+b: Set[Number] = {"One", "Three"}
+
+
+LetterGrade = Literal["A", "B", "C", "D", "F"]
+
+_T = TypeVar("_T")
+
+
+def func1(x: _T) -> _T:
+    ...
+
+
+grade: LetterGrade = func1("A")

package/src/tests/samples/literals3.py

@@ -0,0 +1,40 @@
+# This sample tests that literal enums work.
+
+from enum import Enum
+from typing import Literal
+
+
+class SomeEnum(Enum):
+    SOME_ENUM_VALUE1 = "1"
+    SOME_ENUM_VALUE2 = "2"
+    SOME_ENUM_VALUE3 = "3"
+
+
+class Foo:
+    pass
+
+
+# This should generate an error because Foo is not an
+# allowed literal value.
+a: Literal["hi", Foo()]
+
+# This should generate an error because SomeEnum is not an
+# allowed literal value.
+b: Literal["hi", SomeEnum]
+
+L2 = Literal["hi", SomeEnum.SOME_ENUM_VALUE1]
+
+
+def foo(a: int) -> L2:
+    if a > 3:
+        return "hi"
+    elif a > 4:
+        return SomeEnum.SOME_ENUM_VALUE1
+    elif a > 5:
+        # This should generate an error because it's
+        # not part of the L1 literal.
+        return SomeEnum.SOME_ENUM_VALUE2
+    else:
+        # This should generate an error because it's
+        # not part of the L1 literal.
+        return "bye"

package/src/tests/samples/literals4.py

@@ -0,0 +1,10 @@
+# This sample tests various aliases of the typing module
+# when used with Literal.
+
+import typing
+import typing as t
+import typing as typ
+
+a: typing.Literal[True] = True
+b: t.Literal["Hello"] = "Hello"
+c: typ.Literal[True, "Hello"] = True

package/src/tests/samples/literals5.py

@@ -0,0 +1,28 @@
+# This sample tests literals that employ type aliases.
+
+from typing import Literal, Union
+
+
+Numeric = Literal[1, "3.4"]
+
+DerivedLiteral1 = Literal["a", Numeric]
+
+var1: DerivedLiteral1 = "3.4"
+
+# This should generate an error.
+var2: DerivedLiteral1 = "3.5"
+
+
+NotNumeric = Union[Literal[1, 3], int]
+
+# This should generate an error because NotNumeric
+# isn't a legal literal.
+DerivedLiteral2: Literal[NotNumeric, 3]
+
+
+ReadOnlyMode = Literal["r", "r+"]
+WriteAndTruncateMode = Literal["w", "w+", "wt", "w+t"]
+WriteNoTruncateMode = Literal["r+", "r+t"]
+AppendMode = Literal["a", "a+", "at", "a+t"]
+
+AllModes = Literal[ReadOnlyMode, WriteAndTruncateMode, WriteNoTruncateMode, AppendMode]

package/src/tests/samples/literals6.py

@@ -0,0 +1,90 @@
+# This sample tests various illegal forms of Literal.
+
+from typing import Any, Literal, TypeVar
+from pathlib import Path
+
+# This should generate an error.
+Wrong1 = Literal[3 + 4]
+
+# This should generate an error.
+Wrong2 = Literal["foo".replace("o", "b")]
+
+# This should generate an error.
+Wrong3 = Literal[4 + 3j]
+
+# This should generate an error.
+Wrong4 = Literal[-4 + 2j]
+
+# This should generate an error.
+Wrong5 = Literal[(1, "foo", "bar")]
+
+# This should generate an error.
+Wrong6 = Literal[{"a": "b", "c": "d"}]
+
+# This should generate an error.
+Wrong7 = Literal[Path("abcd")]
+T = TypeVar("T")
+
+# This should generate an error.
+Wrong8 = Literal[T]
+
+# This should generate an error.
+Wrong9 = Literal[3.14]
+
+# This should generate an error.
+Wrong10 = Literal[Any]
+
+# This should generate an error.
+Wrong11 = Literal[...]
+
+
+def func():
+    ...
+
+
+# This should generate an error.
+Wrong12 = Literal[func]
+some_variable = "foo"
+
+# This should generate an error.
+Wrong13 = Literal[some_variable]
+
+
+# This should generate an error.
+var1: Literal[3 + 4]
+
+# This should generate an error.
+var2: Literal["foo".replace("o", "b")]
+
+# This should generate an error.
+var3: Literal[4 + 3j]
+
+# This should generate an error.
+var4: Literal[-4 + 2j]
+
+# This should generate an error.
+var5: Literal[(1, "foo", "bar")]
+
+# This should generate an error.
+var6: Literal[{"a": "b", "c": "d"}]
+
+# This should generate an error.
+var7: Literal[Path("abcd")]
+
+# This should generate an error.
+var8: Literal[T]
+
+# This should generate an error.
+var9: Literal[3.14]
+
+# This should generate an error.
+var10: Literal[Any]
+
+# This should generate an error.
+var11: Literal[...]
+
+# This should generate an error.
+var12: Literal[func]
+
+# This should generate an error.
+var13: Literal[some_variable]

package/src/tests/samples/literals7.py

@@ -0,0 +1,38 @@
+# This sample tests the handling of very large integer values used in
+# literals.
+
+from typing import Literal
+
+
+# This should generate an error.
+y1: Literal[
+    900001231231231456487987456452132130000000000000000000000000000001
+] = 900001231231231456487987456452132130000000000000000000000000000000
+
+y2: Literal[
+    900001231231231456487987456452132130000000000000000000000000000001
+] = 900001231231231456487987456452132130000000000000000000000000000001
+
+reveal_type(
+    y2,
+    expected_text="Literal[900001231231231456487987456452132130000000000000000000000000000001]",
+)
+
+y3 = y2 + 1
+reveal_type(
+    y3,
+    expected_text="Literal[900001231231231456487987456452132130000000000000000000000000000002]",
+)
+
+y4 = 0xFFFFFFFFFFF123456789456123456789456123456789456123
+reveal_type(
+    y4,
+    expected_text="Literal[1606938044258905427252460960878516708721138816242982137979171]",
+)
+
+y5 = 0b101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010
+reveal_type(y5, expected_text="Literal[886151997189943915269204706853563050]")
+
+
+y6 = 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
+y7 = y6 * y6

package/src/tests/samples/loops1.py

@@ -0,0 +1,45 @@
+# This sample tests the type checker's ability to handle type
+# inferences within loop constructs.
+
+
+def bar(a: list):
+    pass
+
+
+def func1():
+    data = None
+
+    for x in [2, 3]:
+        if not data:
+            data = [1, 2]
+        else:
+            # This should not generate an error because the
+            # type checker should be able to determine that
+            # data must be a list at this point in the code.
+            bar(data)
+    else:
+        # This should generate an error because the
+        # type checker should be able to determine that
+        # data must contain None at this point.
+        bar(data)
+
+
+x = 20 + 20
+
+
+def func2():
+    data = None
+
+    while x:
+        if not data:
+            data = [1, 2]
+        else:
+            # This should not generate an error because the
+            # type checker should be able to determine that
+            # data must be a list at this point in the code.
+            bar(data)
+    else:
+        # This should generate an error because the
+        # type checker should be able to determine that
+        # data must contain None at this point.
+        bar(data)

package/src/tests/samples/loops10.py

@@ -0,0 +1,11 @@
+# This sample tests the case where dependent types within
+# a loop are assigned using tuples.
+
+
+def fibonacci():
+    a, b = 1, 1
+    while True:
+        yield a
+        a, b = b, a + b
+        reveal_type(a, expected_text="int")
+        reveal_type(b, expected_text="int")

package/src/tests/samples/loops11.py

@@ -0,0 +1,22 @@
+# This sample tests for the detection of unbound or partially-unbound
+# variables within loops.
+
+import random
+
+for a in [1, 2, 3]:
+    # This should generate an error because b is unbound.
+    if b == 1:
+        b = 2
+
+
+for a in [1, 2, 3]:
+    if random.random() > 0.5:
+        c = 2
+
+    # This should generate an error because c is potentially unbound.
+    print(c)
+
+while True:
+    # This should generate an error because d is unbound.
+    if d == 1:
+        d = 2

package/src/tests/samples/loops12.py

@@ -0,0 +1,18 @@
+# This sample tests the evaluation of a variable whose type is narrowed
+# within a loop body.
+
+
+class Foo:
+    def non_property(self) -> int:
+        ...
+
+    def do_stuff(self, x: int | None):
+        while True:
+            if x is not None:
+                a = x
+            else:
+                a = self.non_property
+
+            # This should generate an error because the type of "a"
+            # is not compatible with a "-" operator.
+            _ = a - 0

package/src/tests/samples/loops13.py

@@ -0,0 +1,13 @@
+# This sample tests the case where a loop uses tuple assignments. It verifies
+# that no "unknown" values are evaluated for variables assigned in the loop.
+
+# pyright: strict
+
+nums: list[int] = [1, 2, 3]
+max_product, min_product = nums[0], nums[0]
+
+for x in nums[1:]:
+    candidates = max_product * x, min_product * x
+    min_product = min(candidates)
+    max_product = max(candidates)
+    reveal_type(candidates, expected_text="tuple[int, int]")

package/src/tests/samples/loops14.py

@@ -0,0 +1,22 @@
+# This sample tests a loop that modifies a variable through type narrowing.
+
+from typing import Union
+
+
+class State:
+    def confirm_dialog(self) -> Union["State", bool]:
+        return False
+
+
+state = State()
+reveal_type(state, expected_text="State")
+
+for _ in range(1):
+    result = state.confirm_dialog()
+    if isinstance(result, State):
+        reveal_type(state, expected_text="State")
+        reveal_type(result, expected_text="State")
+        state = result
+    else:
+        reveal_type(state, expected_text="State")
+        reveal_type(result, expected_text="bool")

package/src/tests/samples/loops15.py

@@ -0,0 +1,22 @@
+# This sample tests loops that contain nested comprehensions and
+# variables that depend on each other.
+
+# pyright: strict
+
+
+def func1(boards: list[list[list[int]]]):
+    for _ in [0]:
+        remain = [[set(line) for line in zip(*b)] for b in boards]
+        boards = [b for b, u in zip(boards, remain) if all(u)]
+
+
+def func2(boards: list[list[list[int]]]):
+    for _ in [1]:
+        remain = [[set(line) for line in b] for b in boards]
+        boards = [b for b, u in zip(boards, remain) if all(u)]
+
+
+def func3(boards: list[list[list[int]]]):
+    for _ in [1]:
+        remain = [[set(line) for line in (*b, *zip(*b))] for b in boards]
+        boards = [b for b, u in zip(boards, remain) if all(u)]