@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/src/tests/samples/staticExpressions1.py

@@ -1,52 +0,0 @@
-# This sample tests static expression forms that are supported
-# in the binder.
-
-import sys
-import os
-
-x: int
-
-if sys.platform == "linux":
-    x = 1
-else:
-    x = "error!"
-
-if sys.version_info >= (3, 9):
-    x = 1
-else:
-    x = "error!"
-
-if os.name == "posix":
-    x = 1
-else:
-    x = "error!"
-
-if True:
-    x = 1
-else:
-    x = "error!"
-
-if not False:
-    x = 1
-else:
-    x = "error!"
-
-DEFINED_TRUE = True
-DEFINED_FALSE = False
-
-if DEFINED_TRUE:
-    x = 1
-else:
-    x = "error!"
-
-if not DEFINED_FALSE:
-    x = 1
-else:
-    x = "error!"
-
-DEFINED_STR = "hi!"
-
-if DEFINED_STR == "hi!":
-    x = 1
-else:
-    x = "error!"

package/src/tests/samples/strings1.py

@@ -1,22 +0,0 @@
-# This sample tests the reportImplicitStringConcatenation diagnostic check.
-
-
-def func1(val: str):
-    pass
-
-
-func1("first argument" "second argument")
-
-func1(
-    "This is the first argument, which contains "
-    "especially long text that could not fit into "
-    "one single line thus should be spread."
-)
-
-func1(
-    (
-        "This is the first argument, which contains "
-        "especially long text that could not fit into "
-        "one single line thus should be spread."
-    )
-)

package/src/tests/samples/subscript1.py

@@ -1,74 +0,0 @@
-# This sample tests the reporting of builtin types that
-# will generate exceptions when subscripted in older
-# versions of Python.
-
-from queue import Queue
-from collections import OrderedDict, deque
-from asyncio import Future, Task
-
-# These should generate errors for Python 3.8 and older.
-def func1(
-    a1: Queue[int],
-    b1: OrderedDict[str, str],
-    c1: Future[int],
-    d1: list[int],
-    e1: dict[str, int],
-    f1: set[int],
-    g1: deque[int],
-    h1: frozenset[int],
-    i1: Task[None],
-) -> None:
-    pass
-
-
-def func2(
-    a1: "Queue[int]",
-    b1: "OrderedDict[str, str]",
-    c1: "Future[int]",
-    d1: "list[int]",
-    e1: "dict[str, int]",
-    f1: "set[int]",
-    g1: "deque[int]",
-    h1: "frozenset[int]",
-    i1: "Task[None]",
-) -> None:
-    pass
-
-
-# These should generate errors because they are used
-# in variable types, but they appear outside of a function.
-class A:
-    a1: Queue[int] = Queue()
-    b1: OrderedDict[str, str] = OrderedDict()
-    c1: Future[int] = Future()
-    d1: list[int] = []
-    e1: dict[str, int] = {}
-    f1: set[int] = set()
-    g1: deque[int] = deque()
-    h1: frozenset[int] = frozenset()
-    i1: Task[None]
-
-
-class B:
-    a2: "Queue[int]" = Queue()
-    b2: "OrderedDict[str, str]" = OrderedDict()
-    c2: "Future[int]" = Future()
-    d2: "list[int]" = []
-    e2: "dict[str, int]" = {}
-    f2: "set[int]" = set()
-    g2: "deque[int]" = deque()
-    h2: "frozenset[int]" = frozenset()
-    i1: "Task[None]"
-
-
-def func3():
-    # These should not generate errors.
-    a1: Queue[int] = Queue()
-    b1: OrderedDict[str, str] = OrderedDict()
-    c1: Future[int] = Future()
-    d1: list[int] = []
-    e1: dict[str, int] = {}
-    f1: set[int] = set()
-    g1: deque[int] = deque()
-    h1: frozenset[int] = frozenset()
-    i1: Task[None]

package/src/tests/samples/subscript2.py

@@ -1,55 +0,0 @@
-# This sample tests various forms of subscript expressions for
-# syntax and semantic (type) errors.
-
-from typing import List, TypeVar
-
-
-_T = TypeVar("_T", list, tuple)
-
-def func1(p1: List[int], p2: _T):
-    a1 = p1[0]
-    reveal_type(a1, expected_text="int")
-
-    a2 = p1[:]
-    reveal_type(a2, expected_text="list[int]")
-
-    a3 = p1[1:]
-    reveal_type(a3, expected_text="list[int]")
-
-    a4 = p1[1:2]
-    reveal_type(a4, expected_text="list[int]")
-
-    a5 = p1[0:1:3]
-    reveal_type(a5, expected_text="list[int]")
-
-    a6 = p1[:3]
-    reveal_type(a6, expected_text="list[int]")
-
-    a7 = p1[::]
-    reveal_type(a7, expected_text="list[int]")
-
-    a8 = p1[::2]
-    reveal_type(a8, expected_text="list[int]")
-
-    # This should generate a syntax error.
-    b1 = p1[0:1:3:4]
-
-    # This should generate a syntax error.
-    b2 = p1[0:::]
-
-    # This should generate a type error.
-    c1 = p1[:,]
-    reveal_type(c1, expected_text="Unknown")
-
-    # This should generate a type error.
-    c2 = p1[:,:]
-    reveal_type(c2, expected_text="Unknown")
-
-    # This should generate a type error.
-    c3 = p1[1,]
-    reveal_type(c3, expected_text="Unknown")
-
-    d1 = p2[0]
-    reveal_type(d1, expected_text="Unknown")
-
-

package/src/tests/samples/subscript3.py

@@ -1,135 +0,0 @@
-# This sample tests subscript forms specified in PEP 637 -
-# keyword and unpacked args.
-
-from typing import Any, Tuple, Union, overload
-
-
-class ClassA:
-    @overload
-    def __getitem__(self, index: int) -> int:
-        ...
-
-    @overload
-    def __getitem__(self, index: Tuple[int, ...]) -> float:
-        ...
-
-    @overload
-    def __getitem__(self, index: Any, *, v1: int) -> str:
-        ...
-
-    def __getitem__(self, index: Any, *, v1: int = 3) -> Union[str, float]:
-        ...
-
-    @overload
-    def __setitem__(self, index: int, value: int) -> None:
-        ...
-
-    @overload
-    def __setitem__(self, index: Tuple[int, ...], value: float) -> None:
-        ...
-
-    @overload
-    def __setitem__(self, index: Any, value: str, *, v1: int) -> None:
-        ...
-
-    def __setitem__(self, index: Any, value: Union[str, float], *, v1: int = 3) -> None:
-        ...
-
-
-val_list = [1, 2, 3]
-val_dict = {"a": 2, "b": 2}
-
-a_obj = ClassA()
-
-x1 = a_obj[1]
-reveal_type(x1, expected_text="int")
-
-a_obj[1] = 3
-
-# This should generate an error because float isn't assignable.
-a_obj[1] = 3.5
-
-x2 = a_obj[1,]
-reveal_type(x2, expected_text="float")
-
-a_obj[1,] = 3.4
-
-# This should generate an error because complex isn't assignable.
-a_obj[1,] = 3.5j
-
-x3 = a_obj[1,2]
-reveal_type(x3, expected_text="float")
-
-a_obj[1,2] = 4.5
-
-# This should generate an error because complex isn't assignable.
-a_obj[1,2] = 3.5j
-
-x4 = a_obj[(1,)]
-reveal_type(x4, expected_text="float")
-
-a_obj[(1,)] = 3
-
-# This should generate an error because complex isn't assignable.
-a_obj[(1,)] = 3.5j
-
-x6 = a_obj[1, v1=3]
-reveal_type(x6, expected_text="str")
-
-a_obj[1, v1=3] = "hi"
-
-# This should generate an error because complex isn't assignable.
-a_obj[1,v1=3] = 3.5j
-
-
-x8 = a_obj[1, *val_list]
-reveal_type(x8, expected_text="float")
-
-a_obj[1, *val_list] = 4.3
-
-# This should generate an error because complex isn't assignable.
-a_obj[1, *val_list] = 4.3j
-
-
-
-class ClassB:
-    def __getitem__(self, value: Tuple[()], *, v1: int) -> str:
-        ...
-
-b_obj = ClassB()
-
-# This should generate an error because positional args are not allowed.
-y1 = b_obj[1]
-
-y2 = b_obj[v1=3]
-reveal_type(y2, expected_text="str")
-
-# This should generate an error because v2 is not a named arg.
-y3 = b_obj[v2=3]
-
-
-class ClassC:
-    def __getitem__(self, index: Any, **kwargs: int) -> complex:
-        ...
-    
-    def __setitem__(self, index: Any, value: float, **kwargs: int) -> None:
-        ...
-    
-c_obj = ClassC()
-
-z1 = c_obj[1, *val_list, **val_dict]
-reveal_type(z1, expected_text="complex")
-
-c_obj[1, *val_list, **val_dict] = 4.3
-
-# This should generate an error because complex isn't assignable.
-c_obj[1, *val_list] = 4.3j
-
-
-z2 = c_obj[1, v1=3, v2=4]
-reveal_type(z2, expected_text="complex")
-
-c_obj[1, v1=3, v2=4] = 4.3
-
-# This should generate an error because complex isn't assignable.
-c_obj[1, v1=3, v2=4] = 4.3j

package/src/tests/samples/suiteExpectedColon1.py

@@ -1,4 +0,0 @@
-if True True
-    pass
-
-pass

package/src/tests/samples/suiteExpectedColon2.py

@@ -1,2 +0,0 @@
-# Error recovery should consume to colon inclusive
-if True True: pass

package/src/tests/samples/suiteExpectedColon3.py

@@ -1,2 +0,0 @@
-# Error recovery should consume the whole line
-if True pass

package/src/tests/samples/super1.py

@@ -1,57 +0,0 @@
-# This sample tests the type analyzer's handling of the super() call.
-
-
-class FooBase:
-    @staticmethod
-    def ccc():
-        pass
-
-
-class Foo1(FooBase):
-    def __init__(self):
-        pass
-
-    def hello1(self):
-        pass
-
-
-class Foo2(FooBase):
-    def __init__(self):
-        pass
-
-    def hello2(self):
-        return self.__class__()
-
-    @staticmethod
-    def aaa():
-        pass
-
-
-class Bar(Foo1, Foo2):
-    def __init__(self):
-        super().hello1()
-        super().hello2()
-
-        # This should generate an error
-        super().goodbye()
-
-
-super(Bar).aaa()
-
-# This should generate an error
-super(Bar).bbb()
-
-
-super(Foo1, Bar).ccc()
-
-# This should generate an error because Foo2
-# is not a subclass of Foo1.
-super(Foo1, Foo2).ccc()
-
-bar = Bar()
-super(Foo1, bar).ccc()
-
-foo2 = Foo2()
-# This should generate an error because Foo2
-# is not a subclass of Foo1.
-super(Foo1, foo2).ccc()

package/src/tests/samples/super2.py

@@ -1,29 +0,0 @@
-# This sample tests the handling of the "super" call when
-# used with a two-argument form that specifies the "bind to" type.
-
-from typing import Type, TypeVar
-
-
-T = TypeVar("T", bound="A")
-
-
-class A:
-    @classmethod
-    def factory(cls: Type[T]) -> T:
-        return cls()
-
-
-class B(A):
-    @classmethod
-    def factoryB(cls):
-        return super(B, cls).factory()
-
-
-a1 = A.factory()
-reveal_type(a1, expected_text="A")
-
-b1 = B.factory()
-reveal_type(b1, expected_text="B")
-
-b2 = B.factoryB()
-reveal_type(b2, expected_text="B")

package/src/tests/samples/super3.py

@@ -1,10 +0,0 @@
-# This sample tests the case where super() is used for a class
-# whose base classes are of unknown types.
-
-from some_module import ClassUnknown  # type: ignore
-
-
-class Class1(ClassUnknown):
-    def __init__(self, x: int):
-        # This should not generate an error.
-        super(Class1, self).__init__(x, 1, 2, 3)

package/src/tests/samples/super4.py

@@ -1,24 +0,0 @@
-# This sample tests the handling of super() with no parameters
-# and a base class with an annotated cls or self parameter that
-# relies on the subclass being passed as a parameter.
-
-
-from __future__ import annotations
-import typing
-
-T = typing.TypeVar("T")
-
-
-class Base(typing.Generic[T]):
-    @classmethod
-    def construct(cls: typing.Type[T]) -> T:
-        return cls()
-
-
-class Derived(Base["Derived"]):
-    @classmethod
-    def construct(cls) -> Derived:
-        return super().construct()
-
-
-d: Derived = Derived.construct()

package/src/tests/samples/super5.py

@@ -1,28 +0,0 @@
-# This sample tests the case where super() is called from a class or
-# instance method where the cls or self parameter is explicitly
-# annotated.
-
-from typing import TypeVar, Type
-
-A_T = TypeVar("A_T", bound="A")
-
-
-class A:
-    @classmethod
-    def construct(cls: Type[A_T]) -> A_T:
-        return cls()
-
-    def construct2(self: A_T) -> A_T:
-        return type(self)()
-
-
-B_T = TypeVar("B_T", bound="B")
-
-
-class B(A):
-    @classmethod
-    def construct(cls: Type[B_T]) -> B_T:
-        return super().construct()
-
-    def construct2(self: B_T) -> B_T:
-        return super().construct2()

package/src/tests/samples/super6.py

@@ -1,17 +0,0 @@
-# This sample tests the case where super().__new__(cls) is called
-# and there is an inferred return type based on the cls type.
-
-from typing import NamedTuple
-
-FooBase = NamedTuple("FooBase", [("x", int)])
-
-
-class Foo(FooBase):
-    def __new__(cls):
-        obj = super().__new__(cls, x=1)
-        reveal_type(obj, expected_text="Self@Foo")
-        return obj
-
-
-f = Foo()
-reveal_type(f, expected_text="Foo")

package/src/tests/samples/super7.py

@@ -1,52 +0,0 @@
-# This sample tests the use of super() with two arguments where the second
-# argument is an instance.
-
-
-class BaseClass:
-    def my_method(self, value: int) -> int:
-        ...
-
-
-class SubClass(BaseClass):
-    def method_plain_super(self, value: int) -> int:
-        reveal_type(super(), expected_text="BaseClass")
-        return super().my_method(value)
-
-    def method_super(self, value: int) -> int:
-        reveal_type(super(__class__, self), expected_text="BaseClass")
-        return super(__class__, self).my_method(value)
-
-    def method_super_extra_arg(self, value: int) -> int:
-        reveal_type(super(__class__, self), expected_text="BaseClass")
-
-        # This should generate an error because the method is already bound.
-        return super(__class__, self).my_method(self, value)
-
-    @classmethod
-    def classmethod_super(cls, value: int) -> int:
-        self = cls()
-        reveal_type(super(__class__, self), expected_text="BaseClass")
-        return super(__class__, self).my_method(value)
-
-    @classmethod
-    def classmethod_super_extra_arg(cls, value: int) -> int:
-        self = cls()
-        reveal_type(super(__class__, self), expected_text="BaseClass")
-
-        # This should generate an errorr.
-        return super(__class__, self).my_method(self, value)
-
-    @staticmethod
-    def staticmethod_super(value: int) -> int:
-        self = SubClass()
-        reveal_type(super(__class__, self), expected_text="BaseClass")
-
-        return super(__class__, self).my_method(value)
-
-    @staticmethod
-    def staticmethod_super_extra_arg(value: int) -> int:
-        self = SubClass()
-        reveal_type(super(__class__, self), expected_text="BaseClass")
-
-        # This should generate an error.
-        return super(__class__, self).my_method(self, value)

package/src/tests/samples/super8.py

@@ -1,7 +0,0 @@
-# This sample tests the case where super() is used within a metaclass
-# __init__ method.
-
-
-class Metaclass(type):
-    def __init__(self, name, bases, attrs):
-        super().__init__(name, bases, attrs)

package/src/tests/samples/super9.py

@@ -1,36 +0,0 @@
-# This sample tests the case where a super() call is used with a class
-# whose constructor uses a default argument value with a parameter
-# whose type is a specialized TypeVar.
-
-from typing import Generic, TypeVar
-
-_T = TypeVar("_T")
-
-
-class Foo(Generic[_T]):
-    def __init__(self, x: _T = 1) -> None:
-        ...
-
-
-class Bar(Foo[int]):
-    ...
-
-
-class Baz(Bar):
-    def __init__(self) -> None:
-        super().__init__()
-
-
-class Baz2(Bar):
-    def __init__(self) -> None:
-        super().__init__(x=1)
-
-
-class Bar2(Foo[int]):
-    def __init__(self) -> None:
-        super().__init__()
-
-
-class Bar3(Foo[int]):
-    def __init__(self) -> None:
-        super().__init__(x=1)

package/src/tests/samples/threePartVersion1.py

@@ -1,33 +0,0 @@
-import sys
-
-from datetime import datetime, timezone, timedelta
-from typing import overload, Optional
-
-# Overload was broken before 3.5.2.
-# This sort of hack is seen in some type-annotated code to prevent crashes.
-if sys.version_info < (3, 5, 2):
-
-    def overload(f):
-        return f
-
-
-@overload
-def from_json_timestamp(ts: int) -> datetime:
-    ...
-
-
-@overload
-def from_json_timestamp(ts: None) -> None:
-    ...
-
-
-def from_json_timestamp(ts: Optional[int]) -> Optional[datetime]:
-    return (
-        None
-        if ts is None
-        else (datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(milliseconds=ts))
-    )
-
-
-result1: datetime = from_json_timestamp(2418049)
-result3: None = from_json_timestamp(None)