test-data/unit/diff.test

-- 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