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

package/src/tests/samples/abstractClass7.py

@@ -1,22 +0,0 @@
-# This sample verifies that Protocol classes are treated as
-# abstract even though they don't derive from ABCMeta.
-
-from typing import Protocol, Tuple
-from abc import abstractmethod
-
-
-class RGB(Protocol):
-    rgb: Tuple[int, int, int]
-
-    @abstractmethod
-    def intensity(self) -> int:
-        return 0
-
-
-class Point(RGB):
-    def __init__(self, red: int, green: int, blue: int) -> None:
-        self.rgb = red, green, blue
-
-
-# This should generate an error because "intensity" is not implemented.
-p = Point(1, 2, 3)

package/src/tests/samples/abstractClass8.py

@@ -1,27 +0,0 @@
-# This sample tests the check for abstract methods on a final class.
-
-from typing import final
-from abc import ABC, abstractmethod
-
-
-class Foo(ABC):
-    @abstractmethod
-    def foo(self):
-        pass
-
-
-class Bar(Foo):
-    @abstractmethod
-    def bar(self):
-        pass
-
-    @abstractmethod
-    def bar2(self):
-        pass
-
-
-@final
-# This should generate an error because Foo.foo, Bar.bar, and Bar.bar1
-# are abstract.
-class Baz(Bar):
-    ...

package/src/tests/samples/annotated1.py

@@ -1,72 +0,0 @@
-# This sample tests handling of the Python 3.9 "Annotated" feature
-# described in PEP 593.
-
-from typing import Annotated, TypeVar, ClassVar, Final
-from dataclasses import InitVar, dataclass
-
-
-class struct2:
-    @staticmethod
-    def ctype(a: str):
-        pass
-
-    class Packed:
-        pass
-
-
-UnsignedShort = Annotated[int, struct2.ctype("H")]
-SignedChar = Annotated[int, struct2.ctype("b")]
-
-
-class Student(struct2.Packed):
-    name: Annotated[str, struct2.ctype("<10s")]
-    serial_num: UnsignedShort
-    school: SignedChar
-
-
-def ValueRange(a: int, b: int):
-    pass
-
-
-T1 = Annotated[int, ValueRange(-10, 5)]
-T2 = Annotated[T1, ValueRange(-20, 3)]
-
-a: Annotated[Annotated[int, "hi"], "hi"] = 3
-b: T2 = 5
-
-TypeWithStringArg = Annotated["int", "this string should not be parsed"]
-
-
-def func2(a: TypeWithStringArg):
-    return 3
-
-
-# This should generate an error because the first type argument
-# is not a valid type.
-c: Annotated["this", "should generate an error"]
-
-# This should generate an error because all Annotated types should
-# include at least two type arguments.
-d: Annotated[int]
-
-# Verify that generic type aliases can be defined using Annotated.
-_T = TypeVar("_T")
-Param = Annotated[_T, "x"]
-
-x: Param[int] = 3
-
-
-class A:
-    classvar: Annotated[ClassVar[int], (2, 5)] = 4
-    const: Annotated[Final[int], "metadata"] = 4
-
-
-@dataclass
-class B:
-    x: Annotated[InitVar[int], "metadata"]
-
-
-d1 = B(x=4)
-
-# This should generate an error because x is not an actual member.
-d1.x

package/src/tests/samples/annotatedVar1.py

@@ -1,22 +0,0 @@
-# This sample tests type annotations on variables.
-
-array1 = [1, 2, 3]
-
-# This should generate an error because the LHS can't
-# have a declared type.
-array1[2] = 4  # type: int
-
-dict1 = {}
-
-# This should generate an error because the LHS can't
-# have a declared type.
-dict1["hello"] = 4  # type: int
-
-
-def foo():
-    a: int = 3
-    b: float = 4.5
-    c: str = ""
-    d: int = yield 42
-
-

package/src/tests/samples/annotatedVar2.py

@@ -1,28 +0,0 @@
-# This sample tests annotated types on global variables.
-
-# This should generate an error because the declared
-# type below does not match the assigned type.
-glob_var1 = 4
-
-# This should generate an error because the declared
-# type doesn't match the later declared type.
-glob_var1 = Exception()  # type: str
-
-glob_var1 = Exception()  # type: Exception
-
-# This should generate an error because the assigned
-# type doesn't match the declared type.
-glob_var1 = "hello"  # type: Exception
-
-# This should generate an error.
-glob_var2 = 5
-
-
-def func1():
-    global glob_var1
-    global glob_var2
-
-    # This should generate an error.
-    glob_var1 = 3
-
-    glob_var2 = "hello"  # type: str

package/src/tests/samples/annotatedVar3.py

@@ -1,54 +0,0 @@
-# This sample tests annotated types on local variables.
-
-from typing import Any, Optional, Union
-
-
-class ClassB(object):
-    def __enter__(self) -> bytes:
-        return b"hello"
-
-    def __exit__(
-        self,
-        t: Optional[type] = None,
-        exc: Optional[BaseException] = None,
-        tb: Optional[Any] = None,
-    ) -> bool:
-        return True
-
-
-def func2():
-    local_var = 3  # type: Union[int, str]
-    local_var = "hello"
-
-    # This should generate an error because the assigned
-    # type doesn't match the declared type.
-    local_var = b"hello"
-
-    local_var2 = 3  # type: int
-
-    if local_var:
-        # This should generate an error because the
-        # assigned type doesn't match.
-        local_var = 3.4
-    else:
-        # This should generate an error because the assigned
-        # type doesn't match the declared type.
-        local_var2 = b"hello"
-
-    # This should generate an error because the declared type
-    # of local_var is not compatible.
-    with ClassB() as local_var:
-        pass
-
-    bytes_list = [b"hello"]
-
-    # This should generate an error because the declared type
-    # of local_var is not compatible.
-    for local_var in bytes_list:
-        pass
-
-    # This should generate an error.
-    (local_var, local_var2) = (b"hello", 3)
-
-    # This should generate an error.
-    (local_var, local_var2) = ("hello", b"h")

package/src/tests/samples/annotatedVar4.py

@@ -1,24 +0,0 @@
-# This sample tests annotated types for class variables.
-
-
-class ClassA(object):
-    # This should generate an error because the declared
-    # type doesn't match the latter declared type.
-    class_var1 = 4  # type: str
-
-    # This should generate an error because the assigned
-    # value doesn't match the declared type.
-    class_var1 = "hello"  # type: int
-
-    class_var1 = 3  # type: int
-
-    # This should generate an error because the declared
-    # type doesn't match the latter declared type.
-    class_var2 = 3  # type: int
-
-    def __init__(self):
-        # This should generate an error because the assigned
-        # type doesn't match the declared type.
-        self.class_var2 = 3  # type: str
-
-        self.class_var2 = "hello"

package/src/tests/samples/annotatedVar5.py

@@ -1,37 +0,0 @@
-# This sample tests type annotations for instance variables.
-
-
-class ClassC(object):
-    def __init__(self):
-        self.inst_var1 = 3
-
-    @property
-    def prop1(self):
-        return 1
-
-    @prop1.setter
-    def prop1(self, val):
-        pass
-
-    def foo(self):
-        # This should generate an error because the assigned
-        # type doesn't match the declared type.
-        self.inst_var1 = 3  # type: str
-
-        self.inst_var1: str = "hello"
-
-        # This should generate an error because the declared
-        # type doesn't match the previously declared type.
-        self.inst_var1: int = "hello"
-
-        # This should generate an error because the assigned
-        # type doesn't match the declared type.
-        self.inst_var1 = "hello"  # type: int
-
-        self.prop1 = 3
-
-
-class ClassE(ClassC):
-    def __init__(self):
-        # This should generate an error.
-        self.inst_var1 = 3

package/src/tests/samples/annotatedVar6.py

@@ -1,22 +0,0 @@
-# This sample tests that class-scoped variables with a declared type
-# but without a ClassVar designation are treated as instance variables.
-# Notably, Callable variables should be assumed to be pre-bound to
-# the object.
-
-from typing import Callable
-
-
-def add1(n: int):
-    return n + 1
-
-
-class Foo:
-    f: Callable[[int], int]
-
-    def m(self):
-        print(self.f(1))
-
-
-foo = Foo()
-foo.f = add1
-foo.m()

package/src/tests/samples/annotatedVar7.py

@@ -1,13 +0,0 @@
-# This sample tests the reportTypeCommentUsage diagnostic check.
-
-# This should generate an error if reportTypeCommentUsage is enabled.
-x = 3  # type: int
-
-
-class Foo:
-    # This should generate an error if reportTypeCommentUsage is enabled.
-    y = 0  # type: int
-
-    def __init__(self):
-        # This should generate an error if reportTypeCommentUsage is enabled.
-        self.x = 2  # type: int

package/src/tests/samples/annotatedVar8.py

@@ -1,29 +0,0 @@
-# This sample tests that incompatible types implicitly assigned
-# to an annotated variable via an import statement are flagged
-# as an error.
-
-from typing import Callable, Final
-
-# This should generate an error because random is already declared.
-import random
-
-random: int = 3
-
-# This should generate an error because os is Final
-import os.path
-
-os: Final = 3
-
-
-# This should generate an error because x is already declared.
-from math import pow as x
-
-x: Callable[[], None]
-
-# This should generate an error because pow is already declared.
-from math import pow
-
-pow: int = 3
-
-y: Callable[[float, float], float]
-from math import pow as y

package/src/tests/samples/annotations1.py

@@ -1,98 +0,0 @@
-# This sample tests the handling of type annotations within a
-# python source file (as opposed to a stub file).
-
-from typing import Optional, Union
-import uuid
-
-
-class ClassA:
-    # This should generate an error because ClassA
-    # is not yet defined at the time it's used.
-    def func0(self) -> Optional[ClassA]:
-        return None
-
-
-class ClassB(ClassA):
-    def func1(self) -> ClassA:
-        return ClassA()
-
-    # This should generate an error because ClassC
-    # is a forward reference, which is not allowed
-    # in a python source file.
-    def func2(self) -> Optional[ClassC]:
-        return None
-
-    def func3(self) -> "Optional[ClassC]":
-        return None
-
-    def func4(self) -> Optional["ClassC"]:
-        return None
-
-    # This should generate an error for Python versions 3.9
-    # and earlier.
-    def func5(self) -> "Optional"[int]:
-        return None
-
-
-class ClassC:
-    pass
-
-
-def func10():
-    pass
-
-
-# This should generate an error because function calls
-# are not allowed within a type annotation.
-x: func10()
-
-y: """
-    Union[
-        int,
-        str
-    ]
-"""
-
-
-class ClassD:
-    ClassA: "ClassA"
-
-    # This should generate an error because ClassF refers
-    # to itself, and there is no ClassF declared at the module
-    # level.
-    ClassF: "ClassF"
-
-    str: "str"
-
-    def int(self):
-        ...
-
-    foo: "int"
-
-    # This should generate an error because it refers to the local
-    # "int" symbol rather than the builtins "int".
-    bar: int
-
-
-# This should generate an error because modules are not allowed in
-# type annotations.
-z: typing
-
-
-class ClassG:
-    uuid = uuid.uuid4()
-
-
-class ClassH:
-    # This should generate an error because uuid refers to the local
-    # symbol in this case.
-    uuid: uuid.UUID = uuid.uuid4()
-
-
-def func11():
-    for t in [str, float]:
-        # This should generate an error because t is not a valid annotation.
-        def f(x: str) -> t:
-            return t(x) + 1
-
-        f("")

package/src/tests/samples/annotations2.py

@@ -1,33 +0,0 @@
-# This sample tests the parser and type checker's ability to use
-# type annotations in comments following assignment expressions.
-# These are used in some older typestub files because they're
-# compatible with versions of Python before 3.6.
-
-from typing import List, Optional, Tuple
-
-a = 3  # type: int
-
-b = "3"  # type: str
-
-c = [1, 2, 3]  # type: Optional[List[int]]
-
-
-# A type on the next line shouldn't be honored
-d = "hello"
-# type: int
-
-# A type comment with a space between the type and
-# the colon is also not honored.
-e = "hello"  # type : int
-
-# Neither is a capital "Type"
-f = "hello"  # Type: int
-
-
-# This should generate an error because the type doesn't match
-g = "hello"  # type: int
-
-
-# This should generate an error because the last entry
-# of the tuple is the wrong type.
-h = (1, "hello", (5,))  # type: Tuple[int, str, Tuple[str]]

package/src/tests/samples/annotations3.py

@@ -1,43 +0,0 @@
-# This sample tests the handling of type annotations within a
-# python source file with the __future__ annotations symbol present.
-
-from __future__ import annotations
-
-from typing import Optional
-
-
-class ClassA:
-    # This should generate an error because ClassA
-    # is not yet defined at the time it's used.
-    def func0(self) -> Optional[ClassA]:
-        return None
-
-
-class ClassB(ClassA):
-    def func1(self) -> ClassA:
-        return ClassA()
-
-    # This should generate an error because ClassC
-    # is a forward reference, which is not allowed
-    # in a python source file.
-    def func2(self) -> Optional[ClassC]:
-        return None
-
-    def func3(self) -> "Optional[ClassC]":
-        return None
-
-    def func4(self) -> Optional["ClassC"]:
-        return None
-
-    def func5(self, x: ClassA):
-        x.func0()
-
-    class ClassA:
-        ...
-
-    def func6(self, x: ClassC):
-        x.my_int
-
-
-class ClassC:
-    my_int: int

package/src/tests/samples/annotations4.py

@@ -1,54 +0,0 @@
-# This sample tests the type checker's reporting of
-# incompatible declared types.
-
-from typing import List
-
-
-def a():
-    pass
-
-
-# This should generate two errors - one for
-# overriding the function declaration and another
-# for an incompatible assignment.
-a = 1
-
-# This should generate an error for an obscured type.
-def b():
-    pass
-
-
-b: int = 1
-
-# This should generate an error for an obscured type.
-c: int = 1
-c: float = 1.1
-
-# This should generate two errors - one for an
-# obscured type, the second for an incompatible assignment.
-d: int = 2
-
-
-def d():
-    pass
-
-
-class Foo:
-    # This should generate an error because aa is redeclared.
-    aa: int
-
-    def aa(self):
-        return 3
-
-
-# This should generate two errors, one for each param.
-def my_func(param1: int, param2):
-    param1: int = 3
-    param2: int = 4
-
-
-# This should be fine because both declarations of 'e'
-# use the same type.
-e: List[int]
-e = [3]
-e: List[int]

package/src/tests/samples/annotations5.py

@@ -1,9 +0,0 @@
-# This sample tests the handling of tuple expressions within a subscript
-# when used with type annotations.
-
-from typing import Dict, List
-
-
-a: Dict[(str, str)] = {"hi": "there"}
-
-b: List[(int,)] = [3, 4, 5]

package/src/tests/samples/annotations6.py

@@ -1,29 +0,0 @@
-# This sample verifies that the Type[] and type[] annotations work
-# as expected when the type argument is Any.
-
-from typing import Type, Any
-
-
-def is_type1(x: object, y: Type[Any]) -> bool:
-    return isinstance(x, y)
-
-
-is_type1(1, int)
-
-# This should generate an error.
-is_type1(1, 1)
-
-
-def is_type2(x: object, y: type[Any]) -> bool:
-    return isinstance(x, y)
-
-
-is_type2(1, int)
-
-# This should generate an error.
-is_type2(1, 1)
-
-
-def func1(v1: Type[Any], v2: type[Any]):
-    reveal_type(v1, expected_text="type")
-    reveal_type(v2, expected_text="type")

package/src/tests/samples/assert1.py

@@ -1,22 +0,0 @@
-# This sample tests the ability to detect errant assert calls
-# that are always true - the "reportAssertAlwaysTrue" option.
-
-from typing import Any, Tuple
-
-
-# This should generate a warning.
-assert (1 != 2, "Error message")
-
-
-def foo(a: Tuple[int, ...]):
-    assert a
-
-
-b = ()
-assert b
-
-
-c = (2, 3)
-
-# This should generate a warning.
-assert c

package/src/tests/samples/assertType1.py

@@ -1,46 +0,0 @@
-# This sample tests the assert_type call.
-
-from typing import Any, Literal
-from typing_extensions import assert_type
-
-def func1():
-    # This should generate an error.
-    assert_type()
-
-    # This should generate an error.
-    assert_type(1)
-
-    # This should generate an error.
-    assert_type(1, 2, 3)
-
-    # This should generate an error.
-    assert_type(*[])
-
-
-def func2(x: int, y: int | str):
-    assert_type(x, int)
-
-    # This should generate an error.
-    assert_type(x, str)
-
-    # This should generate an error.
-    assert_type(x, Any)
-
-    x = 3
-    assert_type(x, Literal[3])
-
-    # This should generate an error.
-    assert_type(x, int)
-
-    assert_type(y, int | str)
-    assert_type(y, str | int)
-
-    # This should generate an error.
-    assert_type(y, str)
-
-    # This should generate an error.
-    assert_type(y, None)
-
-    # This should generate two errors.
-    assert_type(y, 3)
-