blob: ee3519478c458fd4c09532ffce59ba7588631d46 [file] [log] [blame] [edit]
-- Test cases for taking a diff of two module ASTs/symbol tables.
-- The diffs are used for fined-grained incremental checking.
[case testChangeTypeOfModuleAttribute]
x = 1
y = 1
[file next.py]
x = ''
y = 1
[out]
__main__.x
[case testChangeSignatureOfModuleFunction]
def f(x: int) -> None:
pass
def g(y: str) -> None:
pass
[file next.py]
def f(x: str) -> None:
x = ''
def g(y: str) -> None:
y = ''
[out]
__main__.f
[case testAddModuleAttribute]
x = 1
[file next.py]
x = 1
y = 1
[out]
__main__.y
[case testRemoveModuleAttribute]
x = 1
y = 1
[file next.py]
x = 1
[out]
__main__.y
--
-- Classes
--
[case testChangeMethodSignature]
class A:
def f(self) -> None: pass
def g(self) -> None: pass
[file next.py]
class A:
def f(self, x: int) -> None: pass
def g(self) -> None: pass
[out]
__main__.A.f
[case testChangeAttributeType]
class A:
def f(self) -> None:
self.x = 1
self.y = 1
[file next.py]
class A:
def f(self) -> None:
self.x = 1
self.y = ''
[out]
__main__.A.y
[case testAddAttribute]
class A: pass
[file next.py]
class A:
def f(self) -> None:
self.x = 1
[out]
__main__.A.f
__main__.A.x
[case testAddAttribute2]
class A:
def f(self) -> None: pass
[file next.py]
class A:
def f(self) -> None:
self.x = 1
[out]
__main__.A.x
[case testRemoveAttribute]
class A:
def f(self) -> None:
self.x = 1
[file next.py]
class A: pass
[out]
__main__.A.f
__main__.A.x
[case testAddMethod]
class A:
def f(self) -> None: pass
[file next.py]
class A:
def f(self) -> None: pass
def g(self) -> None: pass
[out]
__main__.A.g
[case testRemoveMethod]
class A:
def f(self) -> None: pass
def g(self) -> None: pass
[file next.py]
class A:
def f(self) -> None: pass
[out]
__main__.A.g
[case testAddImport]
import nn
[file next.py]
import n
import nn
[file n.py]
x = 1
[file nn.py]
y = 1
[out]
__main__.n
[case testRemoveImport]
import n
[file next.py]
[file n.py]
x = 1
[out]
__main__.n
[case testChangeClassIntoFunction]
class A: pass
[file next.py]
def A() -> None: pass
[out]
__main__.A
[case testDeleteClass]
class A: pass
[file next.py]
[out]
__main__.A
[case testAddBaseClass]
class A: pass
[file next.py]
class B: pass
class A(B): pass
[out]
__main__.A
__main__.B
[case testChangeBaseClass]
class A: pass
class B: pass
class C(A): pass
[file next.py]
class A: pass
class B: pass
class C(B): pass
[out]
__main__.C
[case testRemoveBaseClass]
class A: pass
class B(A): pass
[file next.py]
class A: pass
class B: pass
[out]
__main__.B
[case testRemoveClassFromMiddleOfMro]
class A: pass
class B(A): pass
class C(B): pass
[file next.py]
class A: pass
class B: pass
class C(B): pass
[out]
__main__.B
__main__.C
[case testDifferenceInConstructor]
class A:
def __init__(self) -> None: pass
[file next.py]
class A:
def __init__(self, x: int) -> None: pass
[out]
__main__.A.__init__
[case testChangeSignatureOfMethodInNestedClass]
class A:
class B:
def f(self) -> int: pass
[file next.py]
class A:
class B:
def f(self) -> str: pass
[out]
__main__.A.B.f
[case testChangeTypeOfAttributeInNestedClass]
class A:
class B:
def f(self) -> None:
self.x = 1
[file next.py]
class A:
class B:
def f(self) -> None:
self.x = ''
[out]
__main__.A.B.x
[case testAddMethodToNestedClass]
class A:
class B: pass
[file next.py]
class A:
class B:
def f(self) -> str: pass
[out]
__main__.A.B.f
[case testAddNestedClass]
class A: pass
[file next.py]
class A:
class B:
def f(self) -> None: pass
[out]
__main__.A.B
[case testRemoveNestedClass]
class A:
class B:
def f(self) -> None: pass
[file next.py]
class A: pass
[out]
__main__.A.B
[case testChangeNestedClassToMethod]
class A:
class B: pass
[file next.py]
class A:
def B(self) -> None: pass
[out]
__main__.A.B
[case testChangeNamedTupleAttribute]
from typing import NamedTuple
class A:
x: str
N = NamedTuple('N', [('x', int), ('y', str)])
M = NamedTuple('M', [('x', int), ('y', str)])
[file next.py]
from typing import NamedTuple
N = NamedTuple('N', [('x', int), ('y', int)])
M = NamedTuple('M', [('x', int), ('y', str)])
[builtins fixtures/tuple.pyi]
[out]
__main__.A
__main__.N
__main__.N._NT
__main__.N.__new__
__main__.N._asdict
__main__.N._make
__main__.N._replace
__main__.N.y
[case testSimpleDecoratedFunction]
from a import dec
@dec
def f() -> None: pass
@dec
def g() -> None: pass
[file next.py]
from a import dec
@dec
def f(x: int) -> None: pass
@dec
def g() -> None: pass
[file a.py]
from typing import TypeVar
T = TypeVar('T')
def dec(f: T) -> T:
return f
[out]
__main__.f
[case testSimpleDecoratedMethod]
from a import dec
class A:
@dec
def f(self) -> None:
self.g()
@dec
def g(self) -> None: pass
[file next.py]
from a import dec
class A:
@dec
def f(self, x: int) -> None:
self.g()
@dec
def g(self) -> None: pass
[file a.py]
from typing import TypeVar
T = TypeVar('T')
def dec(f: T) -> T:
return f
[out]
__main__.A.f
[case testTypeVarBound]
from typing import TypeVar
T = TypeVar('T')
S = TypeVar('S')
[file next.py]
from typing import TypeVar
T = TypeVar('T', bound=int)
S = TypeVar('S')
[out]
__main__.T
[case testTypeVarVariance]
from typing import TypeVar
A = TypeVar('A', covariant=True)
B = TypeVar('B', covariant=True)
C = TypeVar('C', covariant=True)
[file next.py]
from typing import TypeVar
A = TypeVar('A', covariant=True)
B = TypeVar('B', contravariant=True)
C = TypeVar('C')
[out]
__main__.B
__main__.C
[case testTypeVarValues]
from typing import TypeVar
A = TypeVar('A', int, str)
B = TypeVar('B', int, str)
C = TypeVar('C', int, str)
[file next.py]
from typing import TypeVar
A = TypeVar('A', int, str)
B = TypeVar('B', int, str, object)
C = TypeVar('C')
[out]
__main__.B
__main__.C
[case testGenericFunction]
from typing import TypeVar
T = TypeVar('T')
S = TypeVar('S')
def f(x: T) -> T: pass
def g(x: S) -> S: pass
[file next.py]
from typing import TypeVar
T = TypeVar('T', int, str)
S = TypeVar('S')
def f(x: T) -> T: pass
def g(x: S) -> S: pass
[out]
__main__.T
__main__.f
[case testGenericTypes]
from typing import List
x: List[int]
y: List[int]
[file next.py]
from typing import List
x: List[int]
y: List[str]
[builtins fixtures/list.pyi]
[out]
__main__.y
[case testTypeAliasOfList]
from typing import List
X = List[int]
Y = List[int]
[file next.py]
from typing import List
X = List[str]
Y = List[int]
[builtins fixtures/list.pyi]
[out]
__main__.X
[case testTypeAliasOfCallable]
from typing import Callable
A = Callable[[int], str]
B = Callable[[int], str]
C = Callable[[int], str]
[file next.py]
from typing import Callable
A = Callable[[int], str]
B = Callable[[], str]
C = Callable[[int], int]
[out]
__main__.B
__main__.C
[case testGenericTypeAlias]
from typing import Callable, TypeVar
T = TypeVar('T')
A = Callable[[T], T]
B = Callable[[T], T]
[file next.py]
from typing import Callable, TypeVar
T = TypeVar('T')
S = TypeVar('S')
A = Callable[[T], T]
B = Callable[[T], S]
[out]
__main__.B
__main__.S
[case testDifferentListTypes]
from typing import List
A = List
B = list
C = List
[file next.py]
from typing import List
A = List
B = list
C = list
[builtins fixtures/list.pyi]
[out]
__main__.C
[case testDecoratorChangesSignature]
from contextlib import contextmanager
from typing import Iterator, List, Tuple
@contextmanager
def f(x: List[Tuple[int]]) -> Iterator[None]:
yield
@contextmanager
def g(x: str) -> Iterator[None]:
yield
[file next.py]
from contextlib import contextmanager
from typing import Iterator, List, Tuple
@contextmanager
def f(x: List[Tuple[int]]) -> Iterator[None]:
yield
@contextmanager
def g(x: object) -> Iterator[None]:
yield
[typing fixtures/typing-medium.pyi]
[builtins fixtures/list.pyi]
[out]
__main__.g
[case testOverloadedMethod]
from typing import overload
class A:
@overload
def f(self, x: int) -> int: pass
@overload
def f(self, x: str) -> str: pass
def f(self, x): pass
@overload
def g(self, x: int) -> int: pass
@overload
def g(self, x: str) -> str: pass
def g(self, x): pass
[file next.py]
from typing import overload
class A:
@overload
def f(self, x: int) -> int: pass
@overload
def f(self, x: str) -> str: pass
def f(self, x): pass
@overload
def g(self, x: int) -> int: pass
@overload
def g(self, x: object) -> object: pass
def g(self, x): pass
[out]
__main__.A.g
[case testPropertyWithSetter]
class A:
@property
def x(self) -> int:
pass
@x.setter
def x(self, o: int) -> None:
pass
class B:
@property
def x(self) -> int:
pass
@x.setter
def x(self, o: int) -> None:
pass
[file next.py]
class A:
@property
def x(self) -> int:
pass
@x.setter
def x(self, o: int) -> None:
pass
class B:
@property
def x(self) -> str:
pass
@x.setter
def x(self, o: str) -> None:
pass
[builtins fixtures/property.pyi]
[out]
__main__.B.x
[case testFunctionalEnum]
from enum import Enum, IntEnum
A = Enum('A', 'x')
B = Enum('B', 'x')
C = Enum('C', 'x')
D = IntEnum('D', 'x')
[file next.py]
from enum import Enum, IntEnum
A = Enum('A', 'x')
B = Enum('B', 'y')
C = IntEnum('C', 'x')
D = IntEnum('D', 'x y')
[out]
__main__.B.x
__main__.B.y
__main__.C
__main__.D.y
[case testClassBasedEnum]
from enum import Enum
class A(Enum):
X = 0
Y = 1
class B(Enum):
X = 0
Y = 1
class C(Enum):
X = 0
Y = 1
class D(Enum):
X = 0
Y = 1
class E(Enum):
X = 0
[file next.py]
from enum import Enum
class A(Enum):
X = 0
Y = 1
class B(Enum):
X = 0
Z = 1
class C(Enum):
X = 0
Y = 1
Z = 2
class D(Enum):
X = 'a'
Y = 'b'
class F(Enum):
X = 0
[out]
__main__.B.Y
__main__.B.Z
__main__.C.Z
__main__.D.X
__main__.D.Y
__main__.E
__main__.F
[case testTypedDict]
from mypy_extensions import TypedDict
Point = TypedDict('Point', {'x': int, 'y': int})
p = Point(dict(x=42, y=1337))
[file next.py]
from mypy_extensions import TypedDict
Point = TypedDict('Point', {'x': int, 'y': str})
p = Point(dict(x=42, y='lurr'))
[builtins fixtures/dict.pyi]
[out]
__main__.Point
__main__.p
[case testTypedDict2]
from mypy_extensions import TypedDict
class Point(TypedDict):
x: int
y: int
p = Point(dict(x=42, y=1337))
[file next.py]
from mypy_extensions import TypedDict
class Point(TypedDict):
x: int
y: str
p = Point(dict(x=42, y='lurr'))
[builtins fixtures/dict.pyi]
[out]
__main__.Point
__main__.p
[case testTypedDict3]
from mypy_extensions import TypedDict
Point = TypedDict('Point', {'x': int, 'y': int})
p = Point(dict(x=42, y=1337))
[file next.py]
from mypy_extensions import TypedDict
Point = TypedDict('Point', {'x': int})
p = Point(dict(x=42))
[builtins fixtures/dict.pyi]
[out]
__main__.Point
__main__.p
[case testTypedDict4]
from mypy_extensions import TypedDict
Point = TypedDict('Point', {'x': int, 'y': int})
p = Point(dict(x=42, y=1337))
[file next.py]
from mypy_extensions import TypedDict
Point = TypedDict('Point', {'x': int, 'y': int}, total=False)
p = Point(dict(x=42, y=1337))
[builtins fixtures/dict.pyi]
[out]
__main__.Point
__main__.p
[case testTypeAliasSimple]
A = int
B = int
[file next.py]
A = str
B = int
[out]
__main__.A
[case testTypeAliasGeneric]
from typing import List
A = List[int]
B = List[int]
[file next.py]
from typing import List
A = List[str]
B = List[int]
[builtins fixtures/list.pyi]
[out]
__main__.A
[case testTypeAliasGenToNonGen]
from typing import List
A = List[str]
B = List
[file next.py]
from typing import List
A = List
B = List
[builtins fixtures/list.pyi]
[out]
__main__.A
[case testTypeAliasNonGenToGen]
from typing import List
A = List
B = List
[file next.py]
from typing import List
A = List[str]
B = List
[builtins fixtures/list.pyi]
[out]
__main__.A
[case testTypeAliasGenericTypeVar]
from typing import TypeVar, Dict
T = TypeVar('T')
S = TypeVar('S')
A = Dict[str, T]
B = Dict[str, S]
[file next.py]
from typing import TypeVar, Dict
class T: pass
S = TypeVar('S')
A = Dict[str, T]
B = Dict[str, S]
[builtins fixtures/dict.pyi]
[out]
__main__.A
__main__.T
[case testNewType]
from typing import NewType
class C: pass
class D: pass
N1 = NewType('N1', C)
N2 = NewType('N2', D)
N3 = NewType('N3', C)
class N4(C): pass
[file next.py]
from typing import NewType
class C: pass
class D(C): pass
N1 = NewType('N1', C)
N2 = NewType('N2', D)
class N3(C): pass
N4 = NewType('N4', C)
[out]
__main__.D
__main__.N2
__main__.N3
__main__.N3.__init__
__main__.N4
__main__.N4.__init__
[case testChangeGenericBaseClassOnly]
from typing import List
class C(List[int]): pass
[file next.py]
from typing import List
class C(List[str]): pass
[builtins fixtures/list.pyi]
[out]
__main__.C
[case testOverloads]
from typing import overload
class C: pass
@overload
def a(x: int) -> None: pass
@overload
def a(x: str) -> str: pass
def a(x):
pass
@overload
def b(x: int) -> None: pass
@overload
def b(x: str) -> str: pass
def b(x):
pass
@overload
def c(x: int) -> None: pass
@overload
def c(x: str) -> str: pass
def c(x):
pass
@overload
def d(x: int) -> None: pass
@overload
def d(x: str) -> str: pass
def d(x):
pass
[file next.py]
from typing import overload
class C: pass
@overload
def a(x: int) -> None: pass
@overload
def a(x: str) -> str: pass
def a(x):
pass
@overload
def b(x: str) -> str: pass
@overload
def b(x: int) -> None: pass
def b(x):
pass
@overload
def c(x: int) -> None: pass
@overload
def c(x: str) -> str: pass
@overload
def c(x: C) -> C: pass
def c(x):
pass
def d(x: int) -> None:
pass
@overload
def e(x: int) -> None: pass
@overload
def e(x: str) -> str: pass
def e(x):
pass
[out]
__main__.b
__main__.c
__main__.d
__main__.e
[case testOverloadsExternalOnly]
from typing import overload
class Base: pass
class A(Base): pass
class B(Base): pass
class C(Base): pass
@overload
def f(x: A) -> A: pass
@overload
def f(x: B) -> B: pass
def f(x: Base) -> Base:
pass
@overload
def g(x: A) -> A: pass
@overload
def g(x: B) -> B: pass
def g(x: Base) -> Base:
pass
[file next.py]
from typing import overload
class Base: pass
class A(Base): pass
class B(Base): pass
class C(Base): pass
@overload
def f(x: A) -> A: pass
@overload
def f(x: B) -> B: pass
def f(x: object) -> object:
pass
@overload
def g(x: A) -> A: pass
@overload
def g(x: C) -> C: pass
def g(x: Base) -> Base:
pass
[out]
__main__.g
[case testNestedFunctionDoesntMatter]
class A: pass
class B: pass
def outer() -> None:
def inner(x: A) -> B:
pass
[file next.py]
class A: pass
class B: pass
def outer() -> None:
def inner(y: B) -> A:
pass
[out]
[case testProtocolVsNominal]
from typing import Protocol
class A(Protocol):
x: int
class B(Protocol):
x: int
class C(Protocol):
x: int
class D(Protocol):
x: int
[file next.py]
from typing import Protocol
class A(Protocol):
x: int
class B(Protocol):
x: str
class C(Protocol):
x: int
y: int
class D:
x: int
[out]
__main__.B.x
__main__.C.(abstract)
__main__.C.y
__main__.D
__main__.D.(abstract)
[case testProtocolNormalVsGeneric]
from typing import Protocol, TypeVar
T = TypeVar('T')
class P(Protocol[T]):
x: T
class P2(Protocol[T]):
x: T
y: T
[file next.py]
from typing import Protocol, TypeVar
T = TypeVar('T')
class P(Protocol):
x: int
class P2(Protocol[T]):
x: T
[out]
__main__.P
__main__.P.x
__main__.P2.(abstract)
__main__.P2.y
[case testAddAbstractMethod]
from abc import abstractmethod
class A:
@abstractmethod
def f(self) -> None: pass
[file next.py]
from abc import abstractmethod
class A:
@abstractmethod
def f(self) -> None: pass
@abstractmethod
def g(self) -> None: pass
[out]
__main__.A.(abstract)
__main__.A.g
[case testFinalFlagsTriggerVar]
from typing import Final
v: Final = 1
w: Final = 1
x: Final = 1
y: Final[int] = 1
z: Final[int] = 1
same1: Final = 1
same2: Final[int] = 1
class C:
v: Final = 1
w: Final = 1
x: Final = 1
y: Final[int] = 1
z: Final[int] = 1
same1: Final = 1
same2: Final[int] = 1
def __init__(self) -> None:
self.vi: Final = 1
self.wi: Final = 1
self.xi: Final = 1
self.yi: Final[int] = 1
self.zi: Final[int] = 1
self.same1_instance: Final = 1
self.same2_instance: Final[int] = 1
[file next.py]
from typing import Final
v: Final = 0
w = 1
x: Final[int] = 1
y: int = 1
z: Final = 1
same1: Final = 1
same2: Final[int] = 0
class C:
v: Final = 0
w = 1
x: Final[int] = 1
y: int = 1
z: Final = 1
same1: Final = 1
same2: Final[int] = 0
def __init__(self) -> None:
self.vi: Final = 0
self.wi = 1
self.xi: Final[int] = 1
self.yi: int = 1
self.zi: Final = 1
self.same1_instance: Final = 1
self.same2_instance: Final[int] = 0
[out]
__main__.C.v
__main__.C.vi
__main__.C.w
__main__.C.wi
__main__.C.x
__main__.C.xi
__main__.C.y
__main__.C.yi
__main__.C.z
__main__.C.zi
__main__.v
__main__.w
__main__.x
__main__.y
__main__.z
[case testFinalFlagsTriggerMethod]
from typing import final
class C:
def meth(self) -> int: pass
@final
def same(self) -> int: pass
@classmethod
def cmeth(cls) -> int: pass
[file next.py]
from typing import final
class C:
@final
def meth(self) -> int: pass
@final
def same(self) -> int: pass
@final
@classmethod
def cmeth(cls) -> int: pass
[builtins fixtures/classmethod.pyi]
[out]
__main__.C.cmeth
__main__.C.meth
[case testFinalFlagsTriggerProperty]
from typing import final
class C:
@final
@property
def p(self) -> int: pass
@final
@property
def same(self) -> str: pass
[file next.py]
from typing import final
class C:
@property
def p(self) -> int: pass
@final
@property
def same(self) -> str: pass
[builtins fixtures/property.pyi]
[out]
__main__.C.p
[case testFinalFlagsTriggerMethodOverload]
from typing import final, overload
class C:
@overload
def m(self, x: int) -> int: ...
@overload
def m(self, x: str) -> str: ...
@final
def m(self, x):
pass
@overload
def same(self, x: int) -> int: ...
@overload
def same(self, x: str) -> str: ...
@final
def same(self, x):
pass
[file next.py]
from typing import final, overload
class C:
@overload
def m(self, x: int) -> int: ...
@overload
def m(self, x: str) -> str: ...
def m(self, x):
pass
@overload
def same(self, x: int) -> int: ...
@overload
def same(self, x: str) -> str: ...
@final
def same(self, x):
pass
[out]
__main__.C.m
[case testDynamicBasePluginDiff]
# flags: --config-file tmp/mypy.ini
from mod import declarative_base, Column, Instr
Base = declarative_base()
class Model(Base):
x: Column[int]
class Other:
x: Column[int]
class Diff:
x: Column[int]
[file next.py]
from mod import declarative_base, Column, Instr
Base = declarative_base()
class Model(Base):
x: Column[int]
class Other:
x: Column[int]
class Diff(Base):
x: Column[int]
[file mod.py]
from typing import Generic, TypeVar
def declarative_base(): ...
T = TypeVar('T')
class Column(Generic[T]): ...
class Instr(Generic[T]): ...
[file mypy.ini]
\[mypy]
plugins=<ROOT>/test-data/unit/plugins/dyn_class.py
[out]
__main__.Diff
__main__.Diff.x
[case testLiteralTriggersVar]
from typing_extensions import Literal
x: Literal[1] = 1
y = 1
z: Literal[1] = 1
same: Literal[1] = 1
class C:
x_class: Literal[1] = 1
y_class = 1
z_class: Literal[1] = 1
same_class: Literal[1] = 1
def __init__(self) -> None:
self.x_instance: Literal[1] = 1
self.y_instance = 1
self.z_instance: Literal[1] = 1
self.same_instance: Literal[1] = 1
[file next.py]
from typing_extensions import Literal
x = 1
y: Literal[1] = 1
z: Literal[2] = 2
same: Literal[1] = 1
class C:
x_class = 1
y_class: Literal[1] = 1
z_class: Literal[2] = 2
same_class: Literal[1] = 1
def __init__(self) -> None:
self.x_instance = 1
self.y_instance: Literal[1] = 1
self.z_instance: Literal[2] = 2
self.same_instance: Literal[1] = 1
[builtins fixtures/tuple.pyi]
[out]
__main__.C.x_class
__main__.C.x_instance
__main__.C.y_class
__main__.C.y_instance
__main__.C.z_class
__main__.C.z_instance
__main__.x
__main__.y
__main__.z
[case testLiteralTriggersFunctions]
from typing_extensions import Literal
def function_1() -> int: pass
def function_2() -> Literal[1]: pass
def function_3() -> Literal[1]: pass
def function_4(x: int) -> None: pass
def function_5(x: Literal[1]) -> None: pass
def function_6(x: Literal[1]) -> None: pass
def function_same_1() -> Literal[1]: pass
def function_same_2(x: Literal[1]) -> None: pass
class C:
def method_1(self) -> int: pass
def method_2(self) -> Literal[1]: pass
def method_3(self) -> Literal[1]: pass
def method_4(self, x: int) -> None: pass
def method_5(self, x: Literal[1]) -> None: pass
def method_6(self, x: Literal[1]) -> None: pass
def method_same_1(self) -> Literal[1]: pass
def method_same_2(self, x: Literal[1]) -> None: pass
@classmethod
def classmethod_1(cls) -> int: pass
@classmethod
def classmethod_2(cls) -> Literal[1]: pass
@classmethod
def classmethod_3(cls) -> Literal[1]: pass
@classmethod
def classmethod_4(cls, x: int) -> None: pass
@classmethod
def classmethod_5(cls, x: Literal[1]) -> None: pass
@classmethod
def classmethod_6(cls, x: Literal[1]) -> None: pass
@classmethod
def classmethod_same_1(cls) -> Literal[1]: pass
@classmethod
def classmethod_same_2(cls, x: Literal[1]) -> None: pass
@staticmethod
def staticmethod_1() -> int: pass
@staticmethod
def staticmethod_2() -> Literal[1]: pass
@staticmethod
def staticmethod_3() -> Literal[1]: pass
@staticmethod
def staticmethod_4(x: int) -> None: pass
@staticmethod
def staticmethod_5(x: Literal[1]) -> None: pass
@staticmethod
def staticmethod_6(x: Literal[1]) -> None: pass
@staticmethod
def staticmethod_same_1() -> Literal[1]: pass
@staticmethod
def staticmethod_same_2(x: Literal[1]) -> None: pass
[file next.py]
from typing_extensions import Literal
def function_1() -> Literal[1]: pass
def function_2() -> int: pass
def function_3() -> Literal[2]: pass
def function_4(x: Literal[1]) -> None: pass
def function_5(x: int) -> None: pass
def function_6(x: Literal[2]) -> None: pass
def function_same_1() -> Literal[1]: pass
def function_same_2(x: Literal[1]) -> None: pass
class C:
def method_1(self) -> Literal[1]: pass
def method_2(self) -> int: pass
def method_3(self) -> Literal[2]: pass
def method_4(self, x: Literal[1]) -> None: pass
def method_5(self, x: int) -> None: pass
def method_6(self, x: Literal[2]) -> None: pass
def method_same_1(self) -> Literal[1]: pass
def method_same_2(self, x: Literal[1]) -> None: pass
@classmethod
def classmethod_1(cls) -> Literal[1]: pass
@classmethod
def classmethod_2(cls) -> int: pass
@classmethod
def classmethod_3(cls) -> Literal[2]: pass
@classmethod
def classmethod_4(cls, x: Literal[1]) -> None: pass
@classmethod
def classmethod_5(cls, x: int) -> None: pass
@classmethod
def classmethod_6(cls, x: Literal[2]) -> None: pass
@classmethod
def classmethod_same_1(cls) -> Literal[1]: pass
@classmethod
def classmethod_same_2(cls, x: Literal[1]) -> None: pass
@staticmethod
def staticmethod_1() -> Literal[1]: pass
@staticmethod
def staticmethod_2() -> int: pass
@staticmethod
def staticmethod_3() -> Literal[2]: pass
@staticmethod
def staticmethod_4(x: Literal[1]) -> None: pass
@staticmethod
def staticmethod_5(x: int) -> None: pass
@staticmethod
def staticmethod_6(x: Literal[2]) -> None: pass
@staticmethod
def staticmethod_same_1() -> Literal[1]: pass
@staticmethod
def staticmethod_same_2(x: Literal[1]) -> None: pass
[builtins fixtures/classmethod.pyi]
[out]
__main__.C.classmethod_1
__main__.C.classmethod_2
__main__.C.classmethod_3
__main__.C.classmethod_4
__main__.C.classmethod_5
__main__.C.classmethod_6
__main__.C.method_1
__main__.C.method_2
__main__.C.method_3
__main__.C.method_4
__main__.C.method_5
__main__.C.method_6
__main__.C.staticmethod_1
__main__.C.staticmethod_2
__main__.C.staticmethod_3
__main__.C.staticmethod_4
__main__.C.staticmethod_5
__main__.C.staticmethod_6
__main__.function_1
__main__.function_2
__main__.function_3
__main__.function_4
__main__.function_5
__main__.function_6
[case testLiteralTriggersProperty]
from typing_extensions import Literal
class C:
@property
def p1(self) -> Literal[1]: pass
@property
def p2(self) -> int: pass
@property
def same(self) -> Literal[1]: pass
[file next.py]
from typing_extensions import Literal
class C:
@property
def p1(self) -> int: pass
@property
def p2(self) -> Literal[1]: pass
@property
def same(self) -> Literal[1]: pass
[builtins fixtures/property.pyi]
[out]
__main__.C.p1
__main__.C.p2
[case testLiteralsTriggersOverload]
from typing import overload
from typing_extensions import Literal
@overload
def func(x: str) -> str: ...
@overload
def func(x: Literal[1]) -> int: ...
def func(x):
pass
@overload
def func_same(x: str) -> str: ...
@overload
def func_same(x: Literal[1]) -> int: ...
def func_same(x):
pass
class C:
@overload
def method(self, x: str) -> str: ...
@overload
def method(self, x: Literal[1]) -> int: ...
def method(self, x):
pass
@overload
def method_same(self, x: str) -> str: ...
@overload
def method_same(self, x: Literal[1]) -> int: ...
def method_same(self, x):
pass
[file next.py]
from typing import overload
from typing_extensions import Literal
@overload
def func(x: str) -> str: ...
@overload
def func(x: Literal[2]) -> int: ...
def func(x):
pass
@overload
def func_same(x: str) -> str: ...
@overload
def func_same(x: Literal[1]) -> int: ...
def func_same(x):
pass
class C:
@overload
def method(self, x: str) -> str: ...
@overload
def method(self, x: Literal[2]) -> int: ...
def method(self, x):
pass
@overload
def method_same(self, x: str) -> str: ...
@overload
def method_same(self, x: Literal[1]) -> int: ...
def method_same(self, x):
pass
[builtins fixtures/tuple.pyi]
[out]
__main__.C.method
__main__.func
[case testUnionOfLiterals]
from typing_extensions import Literal
x: Literal[1, '2']
[file next.py]
from typing_extensions import Literal
x: Literal[1, 2]
[builtins fixtures/tuple.pyi]
[out]
__main__.x
[case testUnionOfCallables]
from typing import Callable, Union
from mypy_extensions import Arg
x: Union[Callable[[Arg(int, 'x')], None],
Callable[[int], None]]
[file next.py]
from typing import Callable, Union
from mypy_extensions import Arg
x: Union[Callable[[Arg(int, 'y')], None],
Callable[[int], None]]
[builtins fixtures/tuple.pyi]
[out]
__main__.x