tp.fallback,

name="tuple",

definition=tp.definition,

is_bound=tp.is_bound,

)

self.msg.incompatible_type_application(

min_arg_count, len(type_vars), len(args), ctx

bound_items = []

for ct in call_type.items if isinstance(call_type, UnionType) else [call_type]:

p_ct = get_proper_type(ct)

if isinstance(p_ct, FunctionLike) and (not p_ct.bound() or var.is_property):

item = expand_and_bind_callable(p_ct, var, itype, name, mx, is_trivial_self)

else:

item = expand_without_binding(ct, var, itype, original_itype, mx)

arg_types=func.arg_types[1:],

arg_kinds=func.arg_kinds[1:],

arg_names=func.arg_names[1:],

is_bound=True,

)

return cast(F, res)

ct.ret_type.accept(self)

for v in ct.variables:

v.accept(self)

if ct.type_guard is not None:

ct.type_guard.accept(self)

if ct.type_is is not None:

callee_name = callable_name(callee)

if callee_name is not None:

name = callee_name

if object_type is not None:

base = format_type(object_type, self.options)

else:

base = extract_type(name)

typ.is_type_obj(),

typ.is_ellipsis_args,

snapshot_types(typ.variables),

typ.is_bound,

)

def normalize_callable_variables(self, typ: CallableType) -> CallableType:

arg_kinds=[ARG_STAR, ARG_STAR2],

arg_names=["_args", "_kwds"],

ret_type=any_type,

is_bound=True,

fallback=named_type("builtins.function"),

)

return class_callable(sig, info, fallback, None, is_new=False)

arg_kinds=func.arg_kinds[1:],

arg_names=func.arg_names[1:],

variables=variables,

is_bound=True,

)

return cast(F, res)

def get_name(self) -> str | None:

pass

def bound(self) -> bool:

return bool(self.items) and self.items[0].is_bound

class FormalArgument(NamedTuple):

name: str | None

# 'dict' and 'partial' for a `functools.partial` evaluation)

"from_type_type", # Was this callable generated by analyzing Type[...]

# instantiation?

"is_bound", # Is this a bound method?

"def_extras", # Information about original definition we want to serialize.

# This is used for more detailed error messages.

"type_guard", # T, if -> TypeGuard[T] (ret_type is bool in this case).

implicit: bool = False,

special_sig: str | None = None,

from_type_type: bool = False,

is_bound: bool = False,

def_extras: dict[str, Any] | None = None,

type_guard: Type | None = None,

type_is: Type | None = None,

self.from_type_type = from_type_type

self.from_concatenate = from_concatenate

self.imprecise_arg_kinds = imprecise_arg_kinds

self.is_bound = is_bound

if def_extras:

self.def_extras = def_extras

elif isinstance(definition, FuncDef):

implicit: Bogus[bool] = _dummy,

special_sig: Bogus[str | None] = _dummy,

from_type_type: Bogus[bool] = _dummy,

is_bound: Bogus[bool] = _dummy,

def_extras: Bogus[dict[str, Any]] = _dummy,

type_guard: Bogus[Type | None] = _dummy,

type_is: Bogus[Type | None] = _dummy,

implicit=implicit if implicit is not _dummy else self.implicit,

special_sig=special_sig if special_sig is not _dummy else self.special_sig,

from_type_type=from_type_type if from_type_type is not _dummy else self.from_type_type,

is_bound=is_bound if is_bound is not _dummy else self.is_bound,

def_extras=def_extras if def_extras is not _dummy else dict(self.def_extras),

type_guard=type_guard if type_guard is not _dummy else self.type_guard,

type_is=type_is if type_is is not _dummy else self.type_is,

"variables": [v.serialize() for v in self.variables],

"is_ellipsis_args": self.is_ellipsis_args,

"implicit": self.implicit,

"is_bound": self.is_bound,

"def_extras": dict(self.def_extras),

"type_guard": self.type_guard.serialize() if self.type_guard is not None else None,

"type_is": (self.type_is.serialize() if self.type_is is not None else None),

variables=[cast(TypeVarLikeType, deserialize_type(v)) for v in data["variables"]],

is_ellipsis_args=data["is_ellipsis_args"],

implicit=data["implicit"],

is_bound=data["is_bound"],

def_extras=data["def_extras"],

type_guard=(

deserialize_type(data["type_guard"]) if data["type_guard"] is not None else None

[builtins fixtures/args.pyi]

[out]

main:33: error: Too few arguments for "__eq__" of "int"

main:33: error: Unsupported operand types for == ("type[int]" and "type[int]")

[case testDupBaseClasses]

class A:

def foo(self, value: Union[int, str]) -> Union[int, str]:

return super().foo(value) # E: Call to abstract method "foo" of "Foo" with trivial body via super() is unsafe

[case testBoundMethodsAssignedInClassBody]

from typing import Callable

class A:

def f(self, x: int) -> str:

pass

@classmethod

def g(cls, x: int) -> str:

pass

@staticmethod

def h(x: int) -> str:

pass

attr: Callable[[int], str]

class C:

x1 = A.f

x2 = A.g

x3 = A().f

x4 = A().g

x5 = A.h

x6 = A().h

x7 = A().attr

reveal_type(C.x1) # N: Revealed type is "def (self: __main__.A, x: builtins.int) -> builtins.str"

reveal_type(C.x2) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C.x3) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C.x4) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C.x5) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C.x6) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C.x7) # N: Revealed type is "def (builtins.int) -> builtins.str"

reveal_type(C().x1) # E: Invalid self argument "C" to attribute function "x1" with type "Callable[[A, int], str]" \

# N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C().x2) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C().x3) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C().x4) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C().x5) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C().x6) # N: Revealed type is "def (x: builtins.int) -> builtins.str"

reveal_type(C().x7) # E: Invalid self argument "C" to attribute function "x7" with type "Callable[[int], str]" \

# N: Revealed type is "def () -> builtins.str"

[builtins fixtures/classmethod.pyi]