-- Test cases for the type checker related to functions, function types and

-- calls.

-- See also check-varargs.test.

-- Callable type basics

-- --------------------

[case testCallingVariableWithFunctionType]

from typing import Callable

f: Callable[[A], B]

a: A

b: B

if int():

a = f(a) # E: Incompatible types in assignment (expression has type "B", variable has type "A")

if int():

b = f(b) # E: Argument 1 has incompatible type "B"; expected "A"

if int():

b = f() # E: Too few arguments

if int():

b = f(a, a) # E: Too many arguments

if int():

b = f(a)

class A: pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testKeywordOnlyArgumentOrderInsensitivity]

import typing

class A(object):

def f(self, *, a: int, b: str) -> None: pass

class B(A):

def f(self, *, b: str, a: int) -> None: pass

class C(A):

def f(self, *, b: int, a: str) -> None: pass # Fail

[out]

main:10: error: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "str"

main:10: note: This violates the Liskov substitution principle

main:10: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

main:10: error: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int"

[case testPositionalOverridingArgumentNameInsensitivity]

import typing

class A(object):

def f(self, a: int, b: str) -> None: pass

class B(A):

def f(self, b: str, a: int) -> None: pass # E: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int" \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides \

# E: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "str"

class C(A):

def f(self, foo: int, bar: str) -> None: pass

[case testPositionalOverridingArgumentNamesCheckedWhenMismatchingPos]

import typing

class A(object):

def f(self, a: int, b: str) -> None: pass

class B(A):

def f(self, b: int, a: str) -> None: pass # Fail

[out]

main:7: error: Signature of "f" incompatible with supertype "A"

main:7: note: Superclass:

main:7: note: def f(self, a: int, b: str) -> None

main:7: note: Subclass:

main:7: note: def f(self, b: int, a: str) -> None

[case testSubtypingFunctionTypes]

from typing import Callable

class A: pass

class B(A): pass

f: Callable[[B], A]

g: Callable[[A], A] # subtype of f

h: Callable[[B], B] # subtype of f

if int():

g = h # E: Incompatible types in assignment (expression has type "Callable[[B], B]", variable has type "Callable[[A], A]")

if int():

h = f # E: Incompatible types in assignment (expression has type "Callable[[B], A]", variable has type "Callable[[B], B]")

if int():

h = g # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[B], B]")

if int():

g = f # E: Incompatible types in assignment (expression has type "Callable[[B], A]", variable has type "Callable[[A], A]")

if int():

f = g

if int():

f = h

if int():

f = f

if int():

g = g

if int():

h = h

[case testSubtypingFunctionsDoubleCorrespondence]

def l(x) -> None: ...

def r(__x, *, x) -> None: ...

r = l # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "def r(Any, /, *, x: Any) -> None")

[case testSubtypingFunctionsDoubleCorrespondenceNamedOptional]

def l(x) -> None: ...

def r(__x, *, x = 1) -> None: ...

r = l # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "def r(Any, /, *, x: Any = ...) -> None")

[case testSubtypingFunctionsDoubleCorrespondenceBothNamedOptional]

def l(x = 1) -> None: ...

def r(__x, *, x = 1) -> None: ...

r = l # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "def r(Any, /, *, x: Any = ...) -> None")

[case testSubtypingFunctionsTrivialSuffixRequired]

def l(__x) -> None: ...

def r(x, *args, **kwargs) -> None: ...

r = l # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "def r(x: Any, *args: Any, **kwargs: Any) -> None")

[builtins fixtures/dict.pyi]

[case testSubtypingFunctionsTrivialSuffixOptional]

def l(__x = 1) -> None: ...

def r(x = 1, *args, **kwargs) -> None: ...

r = l # E: Incompatible types in assignment (expression has type "def l(Any = ..., /) -> None", variable has type "def r(x: Any = ..., *args: Any, **kwargs: Any) -> None")

[builtins fixtures/dict.pyi]

[case testSubtypingFunctionsRequiredLeftArgNotPresent]

def l(x, y) -> None: ...

def r(x) -> None: ...

r = l # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")

[case testSubtypingFunctionsImplicitNames]

from typing import Any

def f(a, b): pass

def g(c: Any, d: Any) -> Any: pass

ff = f

gg = g

gg = f

ff = g

[case testSubtypingFunctionsDefaultsNames]

from typing import Callable

def f(a: int, b: str) -> None: pass

f_nonames: Callable[[int, str], None]

def g(a: int, b: str = "") -> None: pass

def h(aa: int, b: str = "") -> None: pass

ff_nonames = f_nonames

ff = f

gg = g

hh = h

if int():

ff = gg

if int():

ff_nonames = ff

if int():

ff_nonames = f_nonames # reset

if int():

ff = ff_nonames # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "def f(a: int, b: str) -> None")

if int():

ff = f # reset

if int():

gg = ff # E: Incompatible types in assignment (expression has type "def f(a: int, b: str) -> None", variable has type "def g(a: int, b: str = ...) -> None")

if int():

gg = hh # E: Incompatible types in assignment (expression has type "def h(aa: int, b: str = ...) -> None", variable has type "def g(a: int, b: str = ...) -> None")

[case testSubtypingFunctionsArgsKwargs]

from typing import Any, Callable

def everything(*args: Any, **kwargs: Any) -> None: pass

everywhere: Callable[..., None]

def specific_1(a: int, b: str) -> None: pass

def specific_2(a: int, *, b: str) -> None: pass

ss_1 = specific_1

ss_2 = specific_2

ee_def = everything

ee_var = everywhere

if int():

ss_1 = ee_def

if int():

ss_1 = specific_1

if int():

ss_2 = ee_def

if int():

ss_2 = specific_2

if int():

ee_def = everywhere

if int():

ee_def = everything

if int():

ee_var = everything

if int():

ee_var = everywhere

if int():

ee_var = specific_1

if int():

ee_def = specific_1

[builtins fixtures/dict.pyi]

[case testSubtypingFunctionsDecorated]

from typing import Any

# untyped decorator

def deco(f): pass

class A:

@deco

def f(self) -> Any:

pass

class B(A):

@deco

def f(self) -> Any:

pass

[builtins fixtures/list.pyi]

[case testLackOfNames]

def f(__a: int, __b: str) -> None: pass

def g(a: int, b: str) -> None: pass

ff = f

gg = g

if int():

ff = g

if int():

gg = f # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "def g(a: int, b: str) -> None")

[case testLackOfNamesFastparse]

def f(__a: int, __b: str) -> None: pass

def g(a: int, b: str) -> None: pass

ff = f

gg = g

if int():

ff = g

if int():

gg = f # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "def g(a: int, b: str) -> None")

[case testFunctionTypeCompatibilityWithOtherTypes]

# flags: --no-strict-optional

from typing import Callable

f = None # type: Callable[[], None]

a, o = None, None # type: (A, object)

if int():

a = f # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "A")

if int():

f = a # E: Incompatible types in assignment (expression has type "A", variable has type "Callable[[], None]")

if int():

f = o # E: Incompatible types in assignment (expression has type "object", variable has type "Callable[[], None]")

if int():

f = f() # E: Function does not return a value (it only ever returns None)

if int():

f = f

if int():

f = None

if int():

o = f

class A: pass

[builtins fixtures/tuple.pyi]

[case testReturnEmptyTuple]

from typing import Tuple

def f(x): # type: (int) -> () # E: Syntax error in type annotation \

# N: Suggestion: Use Tuple[()] instead of () for an empty tuple, or None for a function without a return value

pass

def g(x: int) -> Tuple[()]:

pass

[builtins fixtures/tuple.pyi]

[case testFunctionSubtypingWithVoid]

from typing import Callable

f: Callable[[], None]

g: Callable[[], object]

if int():

f = g # E: Incompatible types in assignment (expression has type "Callable[[], object]", variable has type "Callable[[], None]")

if int():

g = f # OK

if int():

f = f

if int():

g = g

[case testFunctionSubtypingWithMultipleArgs]

from typing import Callable

f: Callable[[A, A], None]

g: Callable[[A, B], None]

h: Callable[[B, B], None]

if int():

f = g # E: Incompatible types in assignment (expression has type "Callable[[A, B], None]", variable has type "Callable[[A, A], None]")

if int():

f = h # E: Incompatible types in assignment (expression has type "Callable[[B, B], None]", variable has type "Callable[[A, A], None]")

if int():

g = h # E: Incompatible types in assignment (expression has type "Callable[[B, B], None]", variable has type "Callable[[A, B], None]")

if int():

g = f

if int():

h = f

if int():

h = g

if int():

f = f

if int():

g = g

if int():

h = h

class A: pass

class B(A): pass

[case testFunctionTypesWithDifferentArgumentCounts]

from typing import Callable

f: Callable[[], None]

g: Callable[[A], None]

h: Callable[[A, A], None]

if int():

f = g # E: Incompatible types in assignment (expression has type "Callable[[A], None]", variable has type "Callable[[], None]")

if int():

f = h # E: Incompatible types in assignment (expression has type "Callable[[A, A], None]", variable has type "Callable[[], None]")

if int():

h = f # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "Callable[[A, A], None]")

if int():

h = g # E: Incompatible types in assignment (expression has type "Callable[[A], None]", variable has type "Callable[[A, A], None]")

if int():

f = f

if int():

g = g

if int():

h = h

class A: pass

[out]

[case testCompatibilityOfSimpleTypeObjectWithStdType]

class A:

def __init__(self, a: 'A') -> None: pass

def f() -> None: pass

t: type

a: A

if int():

a = A # E: Incompatible types in assignment (expression has type "type[A]", variable has type "A")

if int():

t = f # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "type")

if int():

t = A

[case testFunctionTypesWithOverloads]

from foo import *

[file foo.pyi]

from typing import Callable, overload

f: Callable[[AA], A]

g: Callable[[B], B]

h: Callable[[A], AA]

if int():

h = i # E: Incompatible types in assignment (expression has type overloaded function, variable has type "Callable[[A], AA]")

if int():

f = j

if int():

f = i

if int():

g = i

if int():

g = j

class A: pass

class AA(A): pass

class B: pass

@overload

def i(x: AA) -> A:

pass

@overload

def i(x: B) -> B:

pass

@overload

def j(x: B) -> B:

pass

@overload

def j(x: A) -> AA:

pass

[case testOverloadWithThreeItems]

from foo import *

[file foo.pyi]

from typing import Callable, overload

g1: Callable[[A], A]

g2: Callable[[B], B]

g3: Callable[[C], C]

g4: Callable[[A], B]

a: A

b: B

c: C

if int():

b = f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")

if int():

a = f(b) # E: Incompatible types in assignment (expression has type "B", variable has type "A")

if int():

b = f(c) # E: Incompatible types in assignment (expression has type "C", variable has type "B")

if int():

g4 = f # E: Incompatible types in assignment (expression has type overloaded function, variable has type "Callable[[A], B]")

if int():

g1 = f

if int():

g2 = f

if int():

g3 = f

if int():

a = f(a)

if int():

b = f(b)

if int():

c = f(c)

class A: pass

class B: pass

class C: pass

@overload

def f(x: A) -> A: pass

@overload

def f(x: B) -> B: pass

@overload

def f(x: C) -> C: pass

[builtins fixtures/tuple.pyi]

[case testInferConstraintsUnequalLengths]

from typing import Any, Callable, List

def f(fields: List[Callable[[Any], Any]]): pass

class C: pass

f([C]) # E: List item 0 has incompatible type "type[C]"; expected "Callable[[Any], Any]"

class D:

def __init__(self, a, b): pass

f([D]) # E: List item 0 has incompatible type "type[D]"; expected "Callable[[Any], Any]"

[builtins fixtures/list.pyi]

[case testSubtypingTypeTypeAsCallable]

from typing import Callable, Type

class A: pass

x: Callable[..., A]

y: Type[A]

x = y

[case testSubtypingCallableAsTypeType]

from typing import Callable, Type

class A: pass

x: Callable[..., A]

y: Type[A]

if int():

y = x # E: Incompatible types in assignment (expression has type "Callable[..., A]", variable has type "type[A]")

-- Default argument values

-- -----------------------

[case testCallingFunctionsWithDefaultArgumentValues]

# flags: --implicit-optional --no-strict-optional

class A: pass

class AA(A): pass

class B: pass

def f(x: 'A' = None) -> 'B': pass

a, b = None, None # type: (A, B)

if int():

a = f() # E: Incompatible types in assignment (expression has type "B", variable has type "A")

if int():

b = f(b) # E: Argument 1 to "f" has incompatible type "B"; expected "A | None"

if int():

b = f(a, a) # E: Too many arguments for "f"

if int():

b = f()

if int():

b = f(a)

if int():

b = f(AA())

[builtins fixtures/tuple.pyi]

[case testDefaultParameterExpressions]

import typing

class B: pass

class A: pass

def f(x: 'A' = A()) -> None:

b = x # type: B # E: Incompatible types in assignment (expression has type "A", variable has type "B")

a = x # type: A

[out]

[case testDefaultParameterExpressions2]

import typing

class B: pass

class A: pass

def f(x: 'A' = B()) -> None: # E: Incompatible default for parameter "x" (default has type "B", parameter has type "A")

b = x # type: B # E: Incompatible types in assignment (expression has type "A", variable has type "B")

a = x # type: A

[case testDefaultParameterExpressionsGeneric]

from typing import TypeVar

T = TypeVar('T', bound='A')

class B: pass

class A: pass

def f(x: T = B()) -> None: # E: Incompatible default for parameter "x" (default has type "B", parameter has type "T")

b = x # type: B # E: Incompatible types in assignment (expression has type "T", variable has type "B")

a = x # type: A

[case testDefaultParametersWithSubtypes]

import typing

class A: pass

class B(A): pass

def f(x: 'B' = A()) -> None: # E: Incompatible default for parameter "x" (default has type "A", parameter has type "B")

pass

def g(x: 'A' = B()) -> None:

pass

[out]

[case testMultipleDefaultParameterExpressions]

import typing

class A: pass

class B: pass

def f(x: 'A' = B(), y: 'B' = B()) -> None: # E: Incompatible default for parameter "x" (default has type "B", parameter has type "A")

pass

def h(x: 'A' = A(), y: 'B' = B()) -> None:

pass

[out]

[case testMultipleDefaultParameterExpressions2]

import typing

class A: pass

class B: pass

def g(x: 'A' = A(), y: 'B' = A()) -> None: # E: Incompatible default for parameter "y" (default has type "A", parameter has type "B")

pass

[out]

[case testDefaultArgumentsAndSignatureAsComment]

import typing

def f(x = 1): # type: (int) -> str

pass

f()

f(1)

f('') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

[case testMethodDefaultArgumentsAndSignatureAsComment]

import typing

class A:

def f(self, x = 1): # type: (int) -> str

pass

A().f()

A().f(1)

A().f('') # E: Argument 1 to "f" of "A" has incompatible type "str"; expected "int"

-- Access to method defined as a data attribute

-- --------------------------------------------

[case testMethodAsDataAttribute]

from typing import Any, Callable, ClassVar

class B: pass

x: Any

class A:

f = x # type: ClassVar[Callable[[A], None]]

g = x # type: ClassVar[Callable[[A, B], None]]

a: A

a.f()

a.g(B())

a.f(a) # E: Too many arguments

a.g() # E: Too few arguments

[case testMethodWithInvalidMethodAsDataAttribute]

from typing import Any, Callable, ClassVar

class B: pass

x: Any

class A:

f = x # type: ClassVar[Callable[[], None]]

g = x # type: ClassVar[Callable[[B], None]]

a: A

a.f() # E: Attribute function "f" with type "Callable[[], None]" does not accept self argument

a.g() # E: Invalid self argument "A" to attribute function "g" with type "Callable[[B], None]"

[case testMethodWithDynamicallyTypedMethodAsDataAttribute]

from typing import Any, Callable, ClassVar

class B: pass

x: Any

class A:

f = x # type: ClassVar[Callable[[Any], Any]]

a: A

a.f()

a.f(a) # E: Too many arguments

[case testMethodWithInferredMethodAsDataAttribute]

from typing import Any

def m(self: "A") -> int: ...

class A:

n = m

a = A()

reveal_type(a.n()) # N: Revealed type is "builtins.int"

reveal_type(A.n(a)) # N: Revealed type is "builtins.int"

A.n() # E: Too few arguments

[case testOverloadedMethodAsDataAttribute]

from foo import *

[file foo.pyi]

from typing import overload

class B: pass

class A:

@overload

def f(self) -> None: pass

@overload

def f(self, b: B) -> None: pass

g = f

a: A

a.g()

a.g(B())

a.g(a) # E: No overload variant matches argument type "A" \

# N: Possible overload variants: \

# N: def f(self) -> None \

# N: def f(self, b: B) -> None

[case testMethodAsDataAttributeInferredFromDynamicallyTypedMethod]

class A:

def f(self, x): pass

g = f

a: A

a.g(object())

a.g(a, a) # E: Too many arguments

a.g() # E: Too few arguments

[case testMethodAsDataAttributeInGenericClass]

from typing import TypeVar, Generic

t = TypeVar('t')

class B: pass

class A(Generic[t]):

def f(self, x: t) -> None: pass

g = f

a: A[B]

a.g(B())

a.g(a) # E: Argument 1 has incompatible type "A[B]"; expected "B"

[case testInvalidMethodAsDataAttributeInGenericClass]

from typing import Any, TypeVar, Generic, Callable, ClassVar

t = TypeVar('t')

class B: pass

class C: pass

x: Any

class A(Generic[t]):

f = x # type: ClassVar[Callable[[A[B]], None]]

ab: A[B]

ac: A[C]

ab.f()

ac.f() # E: Invalid self argument "A[C]" to attribute function "f" with type "Callable[[A[B]], None]"

[case testPartiallyTypedSelfInMethodDataAttribute]

from typing import Any, TypeVar, Generic, Callable, ClassVar

t = TypeVar('t')

class B: pass

class C: pass

x: Any

class A(Generic[t]):

f = x # type: ClassVar[Callable[[A], None]]

ab: A[B]

ac: A[C]

ab.f()

ac.f()

[case testCallableDataAttribute]

from typing import Callable, ClassVar

class A:

g: ClassVar[Callable[[A], None]]

def __init__(self, f: Callable[[], None]) -> None:

self.f = f

a = A(lambda: None)

a.f()

a.g()

a.f(a) # E: Too many arguments

a.g(a) # E: Too many arguments

-- Nested functions

-- ----------------

[case testSimpleNestedFunction]

import typing

def f(a: 'A') -> None:

def g(b: 'B') -> None:

if int():

b = a \

# E: Incompatible types in assignment (expression has type "A", variable has type "B")

aa = a # type: A # ok

b = B()

g(a) # E: Argument 1 to "g" has incompatible type "A"; expected "B"

g(B())

class A: pass

class B: pass

[case testReturnAndNestedFunction]

import typing

def f() -> 'A':

def g() -> 'B':

return A() # fail

return B()

return B() # fail

return A()

class A: pass

class B: pass

[out]

main:4: error: Incompatible return value type (got "A", expected "B")

main:6: error: Incompatible return value type (got "B", expected "A")

[case testDynamicallyTypedNestedFunction]

import typing

def f(x: object) -> None:

def g(y):

pass

g() # E: Missing positional argument "y" in call to "g"

g(x)

[out]

[case testNestedFunctionInMethod]

import typing

class A:

def f(self) -> None:

def g(x: int) -> None:

y = x # type: int

a = x # type: A # fail

g(2)

g(A()) # fail

[out]

main:6: error: Incompatible types in assignment (expression has type "int", variable has type "A")

main:8: error: Argument 1 to "g" has incompatible type "A"; expected "int"

[case testNestedFunctionInMethodWithTooFewArgumentsInTypeComment_no_native_parse]

class A:

def f(self):

# type: () -> None

def g(x): # E: Type signature has too few parameters

# type: () -> None

pass

[case testNestedFunctionInMethodCannotAccessEnclosingClassAttributes]

class A:

var: int

import mod

class B: ...

def method(self) -> None:

def f1(arg: object) -> None:

arg.var # E: "object" has no attribute "var"

arg.mod # E: "object" has no attribute "mod"

arg.B # E: "object" has no attribute "B"

[file mod.py]

[case testDeepNestedFunctionWithTooFewArgumentsInTypeComment_no_native_parse]

class A:

def f(self):

# type: () -> None

class B:

def g(self):

# type: () -> None

def h(x): # E: Type signature has too few parameters

# type: () -> None

pass

[case testDeepNestedMethodInTypeComment]

class A:

def f(self):

# type: () -> None

class B:

class C:

def g(self):

# type: () -> None

pass

[case testMutuallyRecursiveNestedFunctions]

def f() -> None:

def g() -> None:

h(1)

h('') # E

def h(x: int) -> None:

g()

g(1) # E

[out]

main:4: error: Argument 1 to "h" has incompatible type "str"; expected "int"

main:7: error: Too many arguments for "g"

[case testMutuallyRecursiveDecoratedFunctions]

from typing import Callable, Any

def dec(f) -> Callable[..., Any]: pass

def f() -> None:

@dec

def g() -> None:

h()

h.x # E

@dec

def h(x: int) -> None:

g(1)

g.x # E

[out]

main:7: error: "Callable[..., Any]" has no attribute "x"

main:11: error: "Callable[..., Any]" has no attribute "x"

[case testNestedGenericFunctions]

from typing import TypeVar

T = TypeVar('T')

U = TypeVar('U')

def outer(x: T) -> T:

def inner(y: U) -> T: ...

return inner(1)

-- Casts

-- -----

[case testCastsToAndFromFunctionTypes]

from typing import TypeVar, Callable, Any, cast

t = TypeVar('t')

def f(x: t,

f1: Callable[[], None],

f2: Callable[[Any], None], o: object) -> None:

x = cast(t, f1)

f1 = cast(Callable[[], None], x)

f1 = cast(Callable[[], None], f2)

f1 = cast(Callable[[], None], o)

-- Function decorators

-- -------------------

[case testTrivialStaticallyTypedFunctionDecorator]

from typing import TypeVar

t = TypeVar('t')

def dec(f: t) -> t:

return f

@dec

def f(x: int) -> None: pass

f(1)

f('x') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

[case testTrivialStaticallyTypedMethodDecorator]

from typing import TypeVar

t = TypeVar('t')

def dec(f: t) -> t:

return f

class A:

@dec

def f(self, x: int) -> None: pass

A().f(1)

A().f('') # E: Argument 1 to "f" of "A" has incompatible type "str"; expected "int"

class B: pass

[case testTrivialDecoratedNestedFunction]

from typing import TypeVar

t = TypeVar('t')

def dec(f: t) -> t:

return f

def g() -> None:

@dec

def f(x: int) -> None: pass

f(1)

f('') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

[out]

[case testCheckingDecoratedFunction]

import typing

def dec(f): pass

@dec

def f(x: 'A') -> None:

a = x # type: A

if int():

x = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")

class A: pass

[out]

[case testDecoratorThatSwitchesType]

from typing import Callable

def dec(x) -> Callable[[], None]: pass

@dec

def f(y): pass

f()

f(None) # E: Too many arguments for "f"

[case testDecoratorThatSwitchesTypeWithMethod]

from typing import Any, Callable

def dec(x) -> Callable[[Any], None]: pass

class A:

@dec

def f(self, a, b, c): pass

a: A

a.f()

a.f(None) # E: Too many arguments for "f" of "A"

[case testNestedDecorators]

from typing import Any, Callable

def dec1(f: Callable[[Any], None]) -> Callable[[], None]: pass

def dec2(f: Callable[[Any, Any], None]) -> Callable[[Any], None]: pass

@dec1

@dec2

def f(x, y): pass

f()

f(None) # E: Too many arguments for "f"

[case testInvalidDecorator1]

from typing import Any, Callable

def dec1(f: Callable[[Any], None]) -> Callable[[], None]: pass

def dec2(f: Callable[[Any, Any], None]) -> Callable[[Any], None]: pass

@dec1

@dec2 # E: Argument 1 to "dec2" has incompatible type "Callable[[Any], Any]"; expected "Callable[[Any, Any], None]"

def f(x): pass

def faulty(c: Callable[[int], None]) -> Callable[[tuple[int, int]], None]:

return lambda x: None

@faulty # E: Argument 1 to "faulty" has incompatible type "Callable[[tuple[int, int]], None]"; expected "Callable[[int], None]"

@faulty # E: Argument 1 to "faulty" has incompatible type "Callable[[str], None]"; expected "Callable[[int], None]"

def g(x: str) -> None:

return None

[builtins fixtures/tuple.pyi]

[case testInvalidDecorator2]

from typing import Any, Callable

def dec1(f: Callable[[Any, Any], None]) -> Callable[[], None]: pass

def dec2(f: Callable[[Any, Any], None]) -> Callable[[Any], None]: pass

@dec1 # E: Argument 1 to "dec1" has incompatible type "Callable[[Any], None]"; expected "Callable[[Any, Any], None]"

@dec2

def f(x, y): pass

[case testNoTypeCheckDecoratorOnMethod1]

from typing import no_type_check

@no_type_check

def foo(x: 'bar', y: {'x': 4}) -> 42:

1 + 'x'

[typing fixtures/typing-medium.pyi]

[case testNoTypeCheckDecoratorOnMethod2]

import typing

@typing.no_type_check

def foo(x: 's', y: {'x': 4}) -> 42:

1 + 'x'

@typing.no_type_check

def bar() -> None:

1 + 'x'

[typing fixtures/typing-medium.pyi]

[case testCallingNoTypeCheckFunction]

import typing

@typing.no_type_check

def foo(x: {1:2}) -> [1]:

1 + 'x'