@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/constructor8.py

@@ -0,0 +1,99 @@
+# This sample verifies that a class can be assigned to a Callable
+# type if its constructor conforms to that type.
+
+from typing import Any, Callable, Generic, Literal, TypeVar, Union, overload
+
+_T1 = TypeVar("_T1")
+_S = TypeVar("_S")
+
+
+def func1(callback: Callable[[_T1], _S], val: _T1) -> _S:
+    ...
+
+
+class A(Generic[_T1]):
+    def __new__(cls, x: _T1) -> "A[_T1]":
+        ...
+
+
+a1 = func1(A[float], 3.4)
+reveal_type(a1, expected_text="A[float]")
+
+# This should generate an error.
+a2 = func1(A[int], 3.4)
+
+a3 = func1(A[int], 3)
+reveal_type(a3, expected_text="A[int]")
+
+
+class B(Generic[_T1]):
+    @overload
+    def __new__(cls, x: int, y: Literal[True]) -> "B[None]":
+        ...
+
+    @overload
+    def __new__(cls, x: _T1, y: bool = ...) -> "B[_T1]":
+        ...
+
+    def __new__(cls, x: Union[_T1, int], y: bool = False) -> "B[Any]":
+        ...
+
+
+b1 = func1(B[int], 3)
+reveal_type(b1, expected_text="B[int]")
+
+# This should generate an error.
+b2 = func1(B[None], 3.5)
+
+b3 = func1(B[float], 3.5)
+reveal_type(b3, expected_text="B[float]")
+
+b4 = func1(B[Union[int, str]], 3)
+reveal_type(b4, expected_text="B[int | str]")
+
+b5 = func1(B[Union[int, str]], "3")
+reveal_type(b5, expected_text="B[int | str]")
+
+
+class C(Generic[_T1]):
+    def __init__(self: "C[_T1]", x: _T1) -> None:
+        ...
+
+
+c1 = func1(C[float], 3.4)
+reveal_type(c1, expected_text="C[float]")
+
+# This should generate an error.
+c2 = func1(C[int], 3.4)
+
+c3 = func1(C[int], 3)
+reveal_type(c3, expected_text="C[int]")
+
+
+class D(Generic[_T1]):
+    @overload
+    def __init__(self: "D[None]", x: int, y: Literal[True]) -> None:
+        ...
+
+    @overload
+    def __init__(self: "D[_T1]", x: _T1, y: bool = ...) -> None:
+        ...
+
+    def __init__(self, x: Any, y: bool = False) -> None:
+        ...
+
+
+d1 = func1(D[int], 3)
+reveal_type(d1, expected_text="D[int]")
+
+# This should generate an error.
+d2 = func1(D[None], 3.5)
+
+d3 = func1(D[float], 3.5)
+reveal_type(d3, expected_text="D[float]")
+
+d4 = func1(D[Union[int, str]], 3)
+reveal_type(d4, expected_text="D[int | str]")
+
+d5 = func1(D[Union[int, str]], "3")
+reveal_type(d5, expected_text="D[int | str]")

package/src/tests/samples/constructor9.py

@@ -0,0 +1,19 @@
+# This sample validates that type(self) can be instantiated without
+# error even if the class is abstract.
+
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+_ASub = TypeVar("_ASub", bound="A")
+
+
+class A(ABC):
+    @abstractmethod
+    def some_method(self) -> str:
+        ...
+
+    def some_factory_method_1(self):
+        return type(self)()
+
+    def some_factory_method_2(self: _ASub) -> _ASub:
+        return type(self)()

package/src/tests/samples/coroutines1.py

@@ -0,0 +1,60 @@
+# This same tests the type checker's ability to validate
+# types related to coroutines (and async/await) statements.
+
+from typing import Generator, Any, Optional
+from asyncio import coroutine
+
+
+async def coroutine1():
+    return 1
+
+
+a = coroutine1()
+
+# This should generate an error because 'await'
+# can't be used outside of an async function.
+await a
+
+
+def needs_int(val: int):
+    pass
+
+
+async def consumer1():
+    # This should generate an error because
+    # a is not an int
+    needs_int(a)
+
+    needs_int(await a)
+
+    needs_int(await coroutine1())
+
+
+class ScopedClass1:
+    def __aenter__(self):
+        return self
+
+    @coroutine
+    def __await__(self) -> Generator[Any, None, int]:
+        yield 3
+        return 3
+
+    def __aexit__(
+        self,
+        t: Optional[type] = None,
+        exc: Optional[BaseException] = None,
+        tb: Optional[Any] = None,
+    ) -> bool:
+        return True
+
+
+async def consumer2():
+    a = ScopedClass1()
+
+    # This should generate two errors because
+    # there is no __enter__ or __exit__ method on ScopedClass1.
+    with a as b:
+        needs_int(b)
+
+    async with a as b:
+        needs_int(b)

package/src/tests/samples/coroutines2.py

@@ -0,0 +1,20 @@
+# This sample verifies that the inferred return type
+# of an async function is wrapped in a Coroutine.
+
+import asyncio
+from typing import Any, Coroutine
+
+
+async def inspector(coro: Coroutine[Any, Any, Any]):
+    print(coro.cr_frame.f_locals)
+    return await coro
+
+
+async def inner(sleep: int, message: str) -> str:
+    await asyncio.sleep(sleep)
+    print(message)
+    return message
+
+
+async def outer():
+    await inspector(inner(1, "test"))

package/src/tests/samples/coroutines3.py

@@ -0,0 +1,37 @@
+# This sample tests old-style (pre-await) awaitable generators.
+
+import asyncio
+from typing import Any, AwaitableGenerator
+
+
+@asyncio.coroutine
+def old_style_coroutine1():
+    yield from asyncio.sleep(1)
+
+
+async def func1() -> None:
+    x = await old_style_coroutine1()
+    reveal_type(x, expected_text="None")
+    return x
+
+
+reveal_type(
+    old_style_coroutine1,
+    expected_text="() -> AwaitableGenerator[Any, None, None, None]",
+)
+
+
+@asyncio.coroutine
+def old_style_coroutine2() -> AwaitableGenerator[Any, None, None, None]:
+    yield from asyncio.sleep(1)
+
+
+async def func2() -> None:
+    x = await old_style_coroutine2()
+    return x
+
+
+reveal_type(
+    old_style_coroutine2,
+    expected_text="() -> AwaitableGenerator[Any, None, None, None]",
+)

package/src/tests/samples/dataclass1.py

@@ -0,0 +1,44 @@
+# This sample validates the Python 3.7 data class feature.
+
+from typing import ClassVar, Final, Hashable, NamedTuple, Optional
+
+
+class Other:
+    pass
+
+
+class DataTuple(NamedTuple):
+    def _m(self):
+        pass
+
+    # ClassVar variables should not be included.
+    class_var: ClassVar[int] = 4
+
+    id: int
+    aid: Other
+    value: str = ""
+
+    # Unannotated variables should not be included.
+    not_annotated = 5
+
+    name: Optional[str] = None
+
+    name2: Final[Optional[str]] = None
+
+
+d1 = DataTuple(id=1, aid=Other(), name2="hi")
+d2 = DataTuple(id=1, aid=Other(), value="v")
+d3 = DataTuple(id=1, aid=Other(), name="hello")
+d4 = DataTuple(id=1, aid=Other(), name=None)
+id = d1.id
+
+h4: Hashable = d4
+v = d3 == d4
+
+# This should generate an error because the name argument
+# is the incorrect type.
+d5 = DataTuple(id=1, aid=Other(), name=3)
+
+# This should generate an error because aid is a required
+# parameter and is missing an argument here.
+d6 = DataTuple(id=1, name=None)

package/src/tests/samples/dataclass10.py

@@ -0,0 +1,45 @@
+# This sample tests the case where a dataclass entry is
+# initialized with a "field" that uses "init=False". This
+# case needs to be handled specially because it means
+# that the synthesized __init__ method shouldn't include
+# this field in its parameter list.
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Parent:
+    prop_1: str = field(init=False)
+    prop_2: str = field(default="hello")
+    prop_3: str = field(default_factory=lambda: "hello")
+
+    # This should generate an error because it appears after
+    # a property with a default value.
+    prop_4: str = field()
+
+    def __post_init__(self):
+        self.prop_1 = "test"
+
+
+@dataclass
+class Child(Parent):
+    prop_2: str
+
+
+test = Child(prop_2="test", prop_4="hi")
+
+assert test.prop_1 == "test"
+assert test.prop_2 == "test"
+
+
+@dataclass
+class HandshakeMessage:
+    reset_reason_hex: str
+    reset_data_hex: str
+    device_id: str = field(default="")
+    reset_reason: str = field(init=False)
+    reset_data: str = field(init=False)
+
+    def __post_init__(self):
+        reset_reason = "calculated value"
+        reset_data = "calculated value"

package/src/tests/samples/dataclass11.py

@@ -0,0 +1,53 @@
+# This sample tests the synthesized comparison operators for dataclasses.
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True)
+class DC1:
+    a: str
+    b: int
+
+
+@dataclass(order=True)
+class DC2:
+    a: str
+    b: int
+
+
+dc1_1 = DC1("hi", 2)
+dc1_2 = DC1("hi", 2)
+
+if dc1_1 < dc1_2:
+    print("")
+
+if dc1_1 <= dc1_2:
+    print("")
+
+if dc1_1 > dc1_2:
+    print("")
+
+if dc1_1 >= dc1_2:
+    print("")
+
+if dc1_1 == dc1_2:
+    print("")
+
+if dc1_1 != dc1_2:
+    print("")
+
+if dc1_1 == None:
+    print("")
+
+if dc1_1 != None:
+    print("")
+
+dc2_1 = DC2("hi", 2)
+
+# This should generate an error because the types are
+# incompatible.
+if dc1_1 < dc2_1:
+    print("")
+
+if dc1_1 != dc2_1:
+    print("")

package/src/tests/samples/dataclass12.py

@@ -0,0 +1,32 @@
+# This sample tests the case where an inheritance chain of
+# dataclasses use generic types.
+
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+Key0 = TypeVar("Key0")
+Key1 = TypeVar("Key1")
+Key2 = TypeVar("Key2")
+Value = TypeVar("Value")
+
+
+@dataclass
+class MapTreeLeaf(Generic[Key0, Value]):
+    key: Key0
+    value: Value
+
+
+@dataclass
+class MapTreeNode(MapTreeLeaf[Key1, Value]):
+    pass
+
+
+class Foo(Generic[Key2, Value]):
+    def add(self, key: Key2, value: Value):
+        return MapTreeNode(key=key, value=value)
+
+    def test1(self, a: Key2, b: Value):
+        v1 = self.add(a, b)
+        reveal_type(v1, expected_text="MapTreeNode[Key2@Foo, Value@Foo]")
+        reveal_type(v1.key, expected_text="Key2@Foo")
+        reveal_type(v1.value, expected_text="Value@Foo")

package/src/tests/samples/dataclass13.py

@@ -0,0 +1,42 @@
+# This sample tests the handling of frozen dataclass types.
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+@dataclass(frozen=False)
+class DC1:
+    val1: int = 6
+
+
+@dataclass(frozen=True)
+class DC2:
+    val2: int = 4
+
+
+# This should generate an error because a frozen dataclass
+# cannot inherit from a non-frozen dataclass.
+@dataclass(frozen=True)
+class DC3(DC1):
+    val3: int = 4
+
+
+@dataclass(frozen=True)
+class DC4(DC2):
+    val4: int = 4
+
+    val5: ClassVar[int]
+
+
+a = DC1(val1=3)
+a.val1 = 3
+
+b = DC4(val2=3, val4=5)
+
+DC4.val5 = 3
+
+# This should generate an error because the dataclass is frozen.
+b.val2 = 3
+
+# This should generate an error because the dataclass is frozen.
+b.val4 = 3

package/src/tests/samples/dataclass14.py

@@ -0,0 +1,38 @@
+# This sample tests the case where a dataclass declares an instance
+# variable and a subclass redeclares it as a class variable.
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+@dataclass
+class Base:
+    x: int
+    y: int
+
+
+@dataclass
+class Special(Base):
+    x: ClassVar[int] = 1
+    z: int
+
+
+@dataclass
+class VerySpecial(Special):
+    y: ClassVar[int] = 2
+
+
+Base(x=1, y=2)
+Special(y=2, z=3)
+Special(2, 3)
+
+# This should generate an error
+Special(x=1, y=2, z=3)
+
+# This should generate an error
+Special(1, 2, 3)
+
+VerySpecial(z=3)
+
+# This should generate an error
+VerySpecial(x=1, z=3)

package/src/tests/samples/dataclass15.py

@@ -0,0 +1,58 @@
+# This sample tests the Python 3.10 additions to dataclass.
+
+from dataclasses import dataclass, KW_ONLY, field
+
+
+@dataclass
+class DC1:
+    a: str
+    _: KW_ONLY
+    b: int = 0
+
+
+DC1("hi")
+DC1(a="hi")
+DC1(a="hi", b=1)
+DC1("hi", b=1)
+
+# This should generate an error because "b" is keyword-only.
+DC1("hi", 1)
+
+
+@dataclass
+class DC2:
+    b: int = field(kw_only=True, default=3)
+    a: str
+
+
+DC2("hi")
+DC2(a="hi")
+DC2(a="hi", b=1)
+DC2("hi", b=1)
+
+# This should generate an error because "b" is keyword-only.
+DC2("hi", 1)
+
+
+@dataclass(kw_only=True)
+class DC3:
+    a: str = field(kw_only=False)
+    b: int = 0
+
+
+DC3("hi")
+DC3(a="hi")
+DC3(a="hi", b=1)
+DC3("hi", b=1)
+
+# This should generate an error because "b" is keyword-only.
+DC3("hi", 1)
+
+
+@dataclass
+class DC4(DC3):
+    c: float
+
+
+DC4("", 0.2, b=3)
+DC4(a="", b=3, c=0.2)

package/src/tests/samples/dataclass16.py

@@ -0,0 +1,21 @@
+# This sample verifies that a generic dataclass works.
+
+from dataclasses import dataclass
+from typing import Generic, TypeVar, Union
+
+T = TypeVar("T")
+
+
+@dataclass
+class Foo(Generic[T]):
+    value: Union[str, T]
+
+
+reveal_type(Foo(""), expected_text="Foo[Unknown]")
+
+
+class Bar(Foo[int]):
+    pass
+
+
+reveal_type(Bar(123), expected_text="Bar")

package/src/tests/samples/dataclass17.py

@@ -0,0 +1,46 @@
+# This sample tests the "slots" parameter for dataclasses introduced
+# in Python 3.10.
+
+from dataclasses import dataclass
+
+
+# This should generate an error because __slots__ is already defined.
+@dataclass(slots=True)
+class A:
+    x: int
+
+    __slots__ = ()
+
+
+@dataclass(slots=True)
+class B:
+    x: int
+
+    def __init__(self):
+        self.x = 3
+
+        # This should generate an error because "y" is not in slots.
+        self.y = 3
+
+
+@dataclass(slots=False)
+class C:
+    x: int
+
+    __slots__ = ("x",)
+
+    def __init__(self):
+        self.x = 3
+
+        # This should generate an error because "y" is not in slots.
+        self.y = 3
+
+
+@dataclass
+class D:
+    __slots__ = ("y", "x")
+    x: int
+    y: str
+
+
+D(1, "bar")

package/src/tests/samples/dataclass18.py

@@ -0,0 +1,57 @@
+# This sample tests the synthesis of the __hash__ method for dataclasses.
+
+from dataclasses import dataclass
+from typing import Hashable
+
+
+@dataclass
+class DC1:
+    a: int
+
+
+# This should generate an error.
+v1: Hashable = DC1(0)
+
+
+@dataclass(eq=True, frozen=True)
+class DC2:
+    a: int
+
+
+v2: Hashable = DC2(0)
+
+
+@dataclass(eq=True)
+class DC3:
+    a: int
+
+
+# This should generate an error.
+v3: Hashable = DC3(0)
+
+
+@dataclass(frozen=True)
+class DC4:
+    a: int
+
+
+v4: Hashable = DC4(0)
+
+
+@dataclass(eq=True, unsafe_hash=True)
+class DC5:
+    a: int
+
+
+v5: Hashable = DC5(0)
+
+
+@dataclass(eq=True)
+class DC6:
+    a: int
+
+    def __hash__(self) -> int:
+        return 0
+
+
+v6: Hashable = DC6(0)