if variance == COVARIANT:

return is_subtype(lefta, righta)

elif variance == CONTRAVARIANT:

return is_subtype(righta, lefta)

else:

*,

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False,

ignore_declared_variance: bool = False,

ignore_promotions: bool = False) -> bool:

"""Is 'left' subtype of 'right'?

if TypeState.is_assumed_subtype(left, right):

return True

if (isinstance(left, TypeAliasType) and isinstance(right, TypeAliasType) and

left.is_recursive and right.is_recursive):

# This case requires special care because it may cause infinite recursion.

# Our view on recursive types is known under a fancy name of equirecursive mu-types.

# Roughly this means that a recursive type is defined as an alias where right hand side

# can refer to the type as a whole, for example:

# A = Union[int, Tuple[A, ...]]

# and an alias unrolled once represents the *same type*, in our case all these represent

# the same type:

# A

# Union[int, Tuple[A, ...]]

# Union[int, Tuple[Union[int, Tuple[A, ...]], ...]]

# The algorithm for subtyping is then essentially under the assumption that left <: right,

# check that get_proper_type(left) <: get_proper_type(right). On the example above,

# If we start with:

# A = Union[int, Tuple[A, ...]]

# B = Union[int, Tuple[B, ...]]

# When checking if A <: B we push pair (A, B) onto 'assuming' stack, then when after few

# steps we come back to initial call is_subtype(A, B) and immediately return True.

with pop_on_exit(TypeState._assuming, left, right):

return _is_subtype(left, right,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

ignore_promotions=ignore_promotions)

return _is_subtype(left, right,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

*,

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False,

ignore_declared_variance: bool = False,

ignore_promotions: bool = False) -> bool:

orig_right = right

orig_left = left

left = get_proper_type(left)

right = get_proper_type(right)

if (isinstance(right, AnyType) or isinstance(right, UnboundType)

or isinstance(right, ErasedType)):

return True

elif isinstance(right, UnionType) and not isinstance(left, UnionType):

# Normally, when 'left' is not itself a union, the only way

# 'left' can be a subtype of the union 'right' is if it is a

# subtype of one of the items making up the union.

is_subtype_of_item = any(is_subtype(orig_left, item,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

ignore_promotions=ignore_promotions)

for item in right.items)

# Recombine rhs literal types, to make an enum type a subtype

# of a union of all enum items as literal types. Only do it if

# the previous check didn't succeed, since recombining can be

# expensive.

# `bool` is a special case, because `bool` is `Literal[True, False]`.

if (not is_subtype_of_item

and isinstance(left, Instance)

and (left.type.is_enum or left.type.fullname == 'builtins.bool')):

right = UnionType(mypy.typeops.try_contracting_literals_in_union(right.items))

is_subtype_of_item = any(is_subtype(orig_left, item,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

ignore_promotions=ignore_promotions)

for item in right.items)

# However, if 'left' is a type variable T, T might also have

# an upper bound which is itself a union. This case will be

# handled below by the SubtypeVisitor. We have to check both

# possibilities, to handle both cases like T <: Union[T, U]

# and cases like T <: B where B is the upper bound of T and is

# a union. (See #2314.)

if not isinstance(left, TypeVarType):

return is_subtype_of_item

elif is_subtype_of_item:

return True

# otherwise, fall through

return left.accept(SubtypeVisitor(orig_right,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

*,

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False

) -> bool:

return (

is_subtype(a, b, ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names)

and is_subtype(b, a, ignore_type_params=ignore_type_params,

def __init__(self, right: Type,

*,

ignore_type_params: bool,

ignore_pos_arg_names: bool = False,

ignore_declared_variance: bool = False,

ignore_promotions: bool = False) -> None:

self.right = get_proper_type(right)

self.orig_right = right

self.ignore_type_params = ignore_type_params

self.ignore_pos_arg_names = ignore_pos_arg_names

self.ignore_declared_variance = ignore_declared_variance

self.ignore_promotions = ignore_promotions

self.check_type_parameter = (ignore_type_parameter if ignore_type_params else

check_type_parameter)

self._subtype_kind = SubtypeVisitor.build_subtype_kind(

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

ignore_promotions=ignore_promotions)

@staticmethod

def build_subtype_kind(*,

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False,

ignore_declared_variance: bool = False,

ignore_promotions: bool = False) -> SubtypeKind:

return (False, # is proper subtype?

ignore_type_params,

ignore_pos_arg_names,

ignore_declared_variance,

ignore_promotions)

def _is_subtype(self, left: Type, right: Type) -> bool:

return is_subtype(left, right,

ignore_type_params=self.ignore_type_params,

ignore_pos_arg_names=self.ignore_pos_arg_names,

ignore_declared_variance=self.ignore_declared_variance,

ignore_promotions=self.ignore_promotions)

# visit_x(left) means: is left (which is an instance of X) a subtype of

# right?

def visit_unbound_type(self, left: UnboundType) -> bool:

return True

def visit_any(self, left: AnyType) -> bool:

return True

def visit_none_type(self, left: NoneType) -> bool:

if state.strict_optional:

if isinstance(self.right, NoneType) or is_named_instance(self.right,

'builtins.object'):

return True

if isinstance(self.right, Instance) and self.right.type.is_protocol:

members = self.right.type.protocol_members

# None is compatible with Hashable (and other similar protocols). This is

# slightly sloppy since we don't check the signature of "__hash__".

return not members or members == ["__hash__"]

return False

else:

return True

def visit_uninhabited_type(self, left: UninhabitedType) -> bool:

return True

def visit_erased_type(self, left: ErasedType) -> bool:

return True

def visit_deleted_type(self, left: DeletedType) -> bool:

return True

def visit_instance(self, left: Instance) -> bool:

if left.type.fallback_to_any:

if isinstance(self.right, NoneType):

# NOTE: `None` is a *non-subclassable* singleton, therefore no class

# can by a subtype of it, even with an `Any` fallback.

# This special case is needed to treat descriptors in classes with

# dynamic base classes correctly, see #5456.

return False

return True

right = self.right

if isinstance(right, TupleType) and mypy.typeops.tuple_fallback(right).type.is_enum:

return self._is_subtype(left, mypy.typeops.tuple_fallback(right))

if isinstance(right, Instance):

if TypeState.is_cached_subtype_check(self._subtype_kind, left, right):

return True

if not self.ignore_promotions:

for base in left.type.mro:

if base._promote and self._is_subtype(base._promote, self.right):

TypeState.record_subtype_cache_entry(self._subtype_kind, left, right)

return True

rname = right.type.fullname

# Always try a nominal check if possible,

# there might be errors that a user wants to silence *once*.

# NamedTuples are a special case, because `NamedTuple` is not listed

# in `TypeInfo.mro`, so when `(a: NamedTuple) -> None` is used,

# we need to check for `is_named_tuple` property

if ((left.type.has_base(rname) or rname == 'builtins.object'

or (rname == 'typing.NamedTuple'

and any(l.is_named_tuple for l in left.type.mro)))

and not self.ignore_declared_variance):

# Map left type to corresponding right instances.

t = map_instance_to_supertype(left, right.type)

nominal = True

for lefta, righta, tvar in zip(t.args, right.args, right.type.defn.type_vars):

if isinstance(tvar, TypeVarType):

if not self.check_type_parameter(lefta, righta, tvar.variance):

nominal = False

else:

if not is_equivalent(lefta, righta):

nominal = False

if nominal:

TypeState.record_subtype_cache_entry(self._subtype_kind, left, right)

return nominal

if right.type.is_protocol and is_protocol_implementation(left, right):

return True

return False

if isinstance(right, TypeType):

item = right.item

if isinstance(item, TupleType):

item = mypy.typeops.tuple_fallback(item)

if is_named_instance(left, 'builtins.type'):

return self._is_subtype(TypeType(AnyType(TypeOfAny.special_form)), right)

if left.type.is_metaclass():

if isinstance(item, AnyType):

return True

if isinstance(item, Instance):

return is_named_instance(item, 'builtins.object')

if isinstance(right, LiteralType) and left.last_known_value is not None:

return self._is_subtype(left.last_known_value, right)

if isinstance(right, CallableType):

# Special case: Instance can be a subtype of Callable.

call = find_member('__call__', left, left, is_operator=True)

if call:

return self._is_subtype(call, right)

return False

else:

return False

def visit_type_var(self, left: TypeVarType) -> bool:

right = self.right

if isinstance(right, TypeVarType) and left.id == right.id:

return True

if left.values and self._is_subtype(

mypy.typeops.make_simplified_union(left.values), right):

return True

return self._is_subtype(left.upper_bound, self.right)

def visit_param_spec(self, left: ParamSpecType) -> bool:

right = self.right

if (

isinstance(right, ParamSpecType)

and right.id == left.id

and right.flavor == left.flavor

):

return True

return self._is_subtype(left.upper_bound, self.right)

def visit_unpack_type(self, left: UnpackType) -> bool:

raise NotImplementedError

def visit_callable_type(self, left: CallableType) -> bool:

right = self.right

if isinstance(right, CallableType):

if left.type_guard is not None and right.type_guard is not None:

if not self._is_subtype(left.type_guard, right.type_guard):

return False

elif right.type_guard is not None and left.type_guard is None:

# This means that one function has `TypeGuard` and other does not.

# They are not compatible. See https://github.com/python/mypy/issues/11307

return False

return is_callable_compatible(

left, right,

is_compat=self._is_subtype,

ignore_pos_arg_names=self.ignore_pos_arg_names)

elif isinstance(right, Overloaded):

return all(self._is_subtype(left, item) for item in right.items)

elif isinstance(right, Instance):

if right.type.is_protocol and right.type.protocol_members == ['__call__']:

# OK, a callable can implement a protocol with a single `__call__` member.

# TODO: we should probably explicitly exclude self-types in this case.

call = find_member('__call__', right, left, is_operator=True)

assert call is not None

if self._is_subtype(left, call):

return True

return self._is_subtype(left.fallback, right)

elif isinstance(right, TypeType):

# This is unsound, we don't check the __init__ signature.

return left.is_type_obj() and self._is_subtype(left.ret_type, right.item)

else:

return False

def visit_tuple_type(self, left: TupleType) -> bool:

right = self.right

if isinstance(right, Instance):

if is_named_instance(right, 'typing.Sized'):

return True

elif is_named_instance(right, TUPLE_LIKE_INSTANCE_NAMES):

if right.args:

iter_type = right.args[0]

else:

iter_type = AnyType(TypeOfAny.special_form)

return all(self._is_subtype(li, iter_type) for li in left.items)

elif self._is_subtype(mypy.typeops.tuple_fallback(left), right):

return True

return False

elif isinstance(right, TupleType):

if len(left.items) != len(right.items):

return False

for l, r in zip(left.items, right.items):

if not self._is_subtype(l, r):

return False

rfallback = mypy.typeops.tuple_fallback(right)

if is_named_instance(rfallback, 'builtins.tuple'):

# No need to verify fallback. This is useful since the calculated fallback

# may be inconsistent due to how we calculate joins between unions vs.

# non-unions. For example, join(int, str) == object, whereas

# join(Union[int, C], Union[str, C]) == Union[int, str, C].

return True

lfallback = mypy.typeops.tuple_fallback(left)

if not self._is_subtype(lfallback, rfallback):

return False

return True

else:

return False

def visit_typeddict_type(self, left: TypedDictType) -> bool:

right = self.right

if isinstance(right, Instance):

return self._is_subtype(left.fallback, right)

elif isinstance(right, TypedDictType):

if not left.names_are_wider_than(right):

return False

for name, l, r in left.zip(right):

if not is_equivalent(l, r,

ignore_type_params=self.ignore_type_params):

return False

# Non-required key is not compatible with a required key since

# indexing may fail unexpectedly if a required key is missing.

# Required key is not compatible with a non-required key since

# the prior doesn't support 'del' but the latter should support

# it.

#

# NOTE: 'del' support is currently not implemented (#3550). We

# don't want to have to change subtyping after 'del' support

# lands so here we are anticipating that change.

if (name in left.required_keys) != (name in right.required_keys):

return False

# (NOTE: Fallbacks don't matter.)

return True

else:

return False

def visit_literal_type(self, left: LiteralType) -> bool:

if isinstance(self.right, LiteralType):

return left == self.right

else:

return self._is_subtype(left.fallback, self.right)

def visit_overloaded(self, left: Overloaded) -> bool:

right = self.right

if isinstance(right, Instance):

if right.type.is_protocol and right.type.protocol_members == ['__call__']:

# same as for CallableType

call = find_member('__call__', right, left, is_operator=True)

assert call is not None

if self._is_subtype(left, call):

return True

return self._is_subtype(left.fallback, right)

elif isinstance(right, CallableType):

for item in left.items:

if self._is_subtype(item, right):

return True

return False

elif isinstance(right, Overloaded):

if left == self.right:

# When it is the same overload, then the types are equal.

return True

# Ensure each overload in the right side (the supertype) is accounted for.

previous_match_left_index = -1

matched_overloads = set()

possible_invalid_overloads = set()

for right_index, right_item in enumerate(right.items):

found_match = False

for left_index, left_item in enumerate(left.items):

subtype_match = self._is_subtype(left_item, right_item)

# Order matters: we need to make sure that the index of

# this item is at least the index of the previous one.

if subtype_match and previous_match_left_index <= left_index:

if not found_match:

# Update the index of the previous match.

previous_match_left_index = left_index

found_match = True

matched_overloads.add(left_item)

possible_invalid_overloads.discard(left_item)

else:

# If this one overlaps with the supertype in any way, but it wasn't

# an exact match, then it's a potential error.

if (is_callable_compatible(left_item, right_item,

is_compat=self._is_subtype, ignore_return=True,

ignore_pos_arg_names=self.ignore_pos_arg_names) or

is_callable_compatible(right_item, left_item,

is_compat=self._is_subtype, ignore_return=True,

ignore_pos_arg_names=self.ignore_pos_arg_names)):

# If this is an overload that's already been matched, there's no

# problem.

if left_item not in matched_overloads:

possible_invalid_overloads.add(left_item)

if not found_match:

return False

if possible_invalid_overloads:

# There were potentially invalid overloads that were never matched to the

# supertype.

return False

return True

elif isinstance(right, UnboundType):

return True

elif isinstance(right, TypeType):

# All the items must have the same type object status, so

# it's sufficient to query only (any) one of them.

# This is unsound, we don't check all the __init__ signatures.

return left.is_type_obj() and self._is_subtype(left.items[0], right)

else:

return False

def visit_union_type(self, left: UnionType) -> bool:

return all(self._is_subtype(item, self.orig_right) for item in left.items)

def visit_partial_type(self, left: PartialType) -> bool:

# This is indeterminate as we don't really know the complete type yet.

if left.type is None:

# Special case, partial `None`. This might happen when defining

# class-level attributes with explicit `None`.

# We can still recover from this.

# https://github.com/python/mypy/issues/11105

return self.visit_none_type(NoneType())

raise RuntimeError(f'Partial type "{left}" cannot be checked with "issubtype()"')

def visit_type_type(self, left: TypeType) -> bool:

right = self.right

if isinstance(right, TypeType):

return self._is_subtype(left.item, right.item)

if isinstance(right, CallableType):

# This is unsound, we don't check the __init__ signature.

return self._is_subtype(left.item, right.ret_type)

if isinstance(right, Instance):

if right.type.fullname in ['builtins.object', 'builtins.type']:

return True

item = left.item

if isinstance(item, TypeVarType):

item = get_proper_type(item.upper_bound)

if isinstance(item, Instance):

metaclass = item.type.metaclass_type

return metaclass is not None and self._is_subtype(metaclass, right)

return False

def visit_type_alias_type(self, left: TypeAliasType) -> bool:

left: T, right: T) -> Iterator[None]:

stack.append((left, right))

yield

proper_subtype: bool = False) -> bool:

"""Check whether 'left' implements the protocol 'right'.

assert right.type.is_protocol

# We need to record this check to generate protocol fine-grained dependencies.

TypeState.record_protocol_subtype_check(left.type, right.type)

# nominal subtyping currently ignores '__init__' and '__new__' signatures

members_not_to_check = {'__init__', '__new__'}

# Trivial check that circumvents the bug described in issue 9771:

if left.type.is_protocol:

members_right = set(right.type.protocol_members) - members_not_to_check

members_left = set(left.type.protocol_members) - members_not_to_check

if not members_right.issubset(members_left):

return False

assuming = right.type.assuming_proper if proper_subtype else right.type.assuming

for (l, r) in reversed(assuming):

if l == left and r == right:

return True

with pop_on_exit(assuming, left, right):

for member in right.type.protocol_members:

if member in members_not_to_check:

continue

ignore_names = member != '__call__' # __call__ can be passed kwargs

# The third argument below indicates to what self type is bound.

# We always bind self to the subtype. (Similarly to nominal types).

supertype = get_proper_type(find_member(member, right, left))

assert supertype is not None

subtype = get_proper_type(find_member(member, left, left))

# Useful for debugging:

# print(member, 'of', left, 'has type', subtype)

# print(member, 'of', right, 'has type', supertype)

if not subtype:

return False

if isinstance(subtype, PartialType):

subtype = NoneType() if subtype.type is None else Instance(

subtype.type, [AnyType(TypeOfAny.unannotated)] * len(subtype.type.type_vars)

)

if not proper_subtype:

# Nominal check currently ignores arg names

# NOTE: If we ever change this, be sure to also change the call to

# SubtypeVisitor.build_subtype_kind(...) down below.

is_compat = is_subtype(subtype, supertype, ignore_pos_arg_names=ignore_names)

else:

is_compat = is_proper_subtype(subtype, supertype)

if not is_compat:

return False

if isinstance(subtype, NoneType) and isinstance(supertype, CallableType):

# We want __hash__ = None idiom to work even without --strict-optional

return False

subflags = get_member_flags(member, left.type)

superflags = get_member_flags(member, right.type)

if IS_SETTABLE in superflags:

# Check opposite direction for settable attributes.

if not is_subtype(supertype, subtype):

return False

if (IS_CLASSVAR in subflags) != (IS_CLASSVAR in superflags):

return False

if IS_SETTABLE in superflags and IS_SETTABLE not in subflags:

return False

# This rule is copied from nominal check in checker.py

if IS_CLASS_OR_STATIC in superflags and IS_CLASS_OR_STATIC not in subflags:

return False

if not proper_subtype:

# Nominal check currently ignores arg names, but __call__ is special for protocols

ignore_names = right.type.protocol_members != ['__call__']

subtype_kind = SubtypeVisitor.build_subtype_kind(ignore_pos_arg_names=ignore_names)

else:

subtype_kind = ProperSubtypeVisitor.build_subtype_kind()

TypeState.record_subtype_cache_entry(subtype_kind, left, right)

itype: Instance,

subtype: Type,

is_operator: bool = False) -> Optional[Type]:

"""Find the type of member by 'name' in 'itype's TypeInfo.

# TODO: this code shares some logic with checkmember.analyze_member_access,

# consider refactoring.

info = itype.type

method = info.get_method(name)

if method:

if isinstance(method, Decorator):

return find_node_type(method.var, itype, subtype)

if method.is_property:

assert isinstance(method, OverloadedFuncDef)

dec = method.items[0]

assert isinstance(dec, Decorator)

return find_node_type(dec.var, itype, subtype)

return find_node_type(method, itype, subtype)

else:

# don't have such method, maybe variable or decorator?

node = info.get(name)

v = node.node if node else None

if isinstance(v, Var):

return find_node_type(v, itype, subtype)

if (not v and name not in ['__getattr__', '__setattr__', '__getattribute__'] and

not is_operator):

for method_name in ('__getattribute__', '__getattr__'):

# Normally, mypy assumes that instances that define __getattr__ have all

# attributes with the corresponding return type. If this will produce

# many false negatives, then this could be prohibited for

# structural subtyping.

method = info.get_method(method_name)

if method and method.info.fullname != 'builtins.object':

if isinstance(method, Decorator):

getattr_type = get_proper_type(find_node_type(method.var, itype, subtype))

else:

getattr_type = get_proper_type(find_node_type(method, itype, subtype))

if isinstance(getattr_type, CallableType):

return getattr_type.ret_type

return getattr_type

if itype.type.fallback_to_any:

return AnyType(TypeOfAny.special_form)

"""Detect whether a member 'name' is settable, whether it is an

method = info.get_method(name)

setattr_meth = info.get_method('__setattr__')

if method:

if isinstance(method, Decorator):

if method.var.is_staticmethod or method.var.is_classmethod:

return {IS_CLASS_OR_STATIC}

elif method.is_property: # this could be settable property

assert isinstance(method, OverloadedFuncDef)

dec = method.items[0]

assert isinstance(dec, Decorator)

if dec.var.is_settable_property or setattr_meth:

return {IS_SETTABLE}

return set()

node = info.get(name)

if not node:

if setattr_meth:

return {IS_SETTABLE}

return set()

v = node.node

# just a variable

if isinstance(v, Var) and not v.is_property:

flags = {IS_SETTABLE}

if v.is_classvar:

flags.add(IS_CLASSVAR)

return flags

"""Find type of a variable or method 'node' (maybe also a decorated method).

from mypy.typeops import bind_self

if isinstance(node, FuncBase):

typ: Optional[Type] = mypy.typeops.function_type(

node, fallback=Instance(itype.type.mro[-1], [])

)

else:

typ = node.type

typ = get_proper_type(typ)

if typ is None:

return AnyType(TypeOfAny.from_error)

# We don't need to bind 'self' for static methods, since there is no 'self'.

if (isinstance(node, FuncBase)

or (isinstance(typ, FunctionLike)

and node.is_initialized_in_class

and not node.is_staticmethod)):

assert isinstance(typ, FunctionLike)

signature = bind_self(typ, subtype,

is_classmethod=isinstance(node, Var) and node.is_classmethod)

if node.is_property:

assert isinstance(signature, CallableType)

typ = signature.ret_type

else:

typ = signature

itype = map_instance_to_supertype(itype, node.info)

typ = expand_type_by_instance(typ, itype)

"""Find all non-callable members of a protocol."""

assert tp.is_protocol

result: List[str] = []

anytype = AnyType(TypeOfAny.special_form)

instance = Instance(tp, [anytype] * len(tp.defn.type_vars))

for member in tp.protocol_members:

typ = get_proper_type(find_member(member, instance, instance))

if not isinstance(typ, (Overloaded, CallableType)):

result.append(member)

*,

is_compat: Callable[[Type, Type], bool],

is_compat_return: Optional[Callable[[Type, Type], bool]] = None,

ignore_return: bool = False,

ignore_pos_arg_names: bool = False,

check_args_covariantly: bool = False,

allow_partial_overlap: bool = False) -> bool:

"""Is the left compatible with the right, using the provided compatibility check?

if is_compat_return is None:

is_compat_return = is_compat

# If either function is implicitly typed, ignore positional arg names too

if left.implicit or right.implicit:

ignore_pos_arg_names = True

# Non-type cannot be a subtype of type.

if right.is_type_obj() and not left.is_type_obj():

return False

# A callable L is a subtype of a generic callable R if L is a

# subtype of every type obtained from R by substituting types for

# the variables of R. We can check this by simply leaving the

# generic variables of R as type variables, effectively varying

# over all possible values.

# It's okay even if these variables share ids with generic

# type variables of L, because generating and solving

# constraints for the variables of L to make L a subtype of R

# (below) treats type variables on the two sides as independent.

if left.variables:

# Apply generic type variables away in left via type inference.

unified = unify_generic_callable(left, right, ignore_return=ignore_return)

if unified is None:

return False

else:

left = unified

# If we allow partial overlaps, we don't need to leave R generic:

# if we can find even just a single typevar assignment which

# would make these callables compatible, we should return True.

# So, we repeat the above checks in the opposite direction. This also

# lets us preserve the 'symmetry' property of allow_partial_overlap.

if allow_partial_overlap and right.variables:

unified = unify_generic_callable(right, left, ignore_return=ignore_return)

if unified is not None:

right = unified

# Check return types.

if not ignore_return and not is_compat_return(left.ret_type, right.ret_type):

return False

if check_args_covariantly:

is_compat = flip_compat_check(is_compat)

if right.is_ellipsis_args:

return True

left_star = left.var_arg()

left_star2 = left.kw_arg()

right_star = right.var_arg()

right_star2 = right.kw_arg()

# Match up corresponding arguments and check them for compatibility. In

# every pair (argL, argR) of corresponding arguments from L and R, argL must

# be "more general" than argR if L is to be a subtype of R.

# Arguments are corresponding if they either share a name, share a position,

# or both. If L's corresponding argument is ambiguous, L is not a subtype of R.

# If left has one corresponding argument by name and another by position,

# consider them to be one "merged" argument (and not ambiguous) if they're

# both optional, they're name-only and position-only respectively, and they

# have the same type. This rule allows functions with (*args, **kwargs) to

# properly stand in for the full domain of formal arguments that they're

# used for in practice.

# Every argument in R must have a corresponding argument in L, and every

# required argument in L must have a corresponding argument in R.

# Phase 1: Confirm every argument in R has a corresponding argument in L.

# Phase 1a: If left and right can both accept an infinite number of args,

# their types must be compatible.

#

# Furthermore, if we're checking for compatibility in all cases,

# we confirm that if R accepts an infinite number of arguments,

# L must accept the same.

def _incompatible(left_arg: Optional[FormalArgument],

right_arg: Optional[FormalArgument]) -> bool:

if right_arg is None:

return False

if left_arg is None:

return not allow_partial_overlap

return not is_compat(right_arg.typ, left_arg.typ)

if _incompatible(left_star, right_star) or _incompatible(left_star2, right_star2):

return False

# Phase 1b: Check non-star args: for every arg right can accept, left must

# also accept. The only exception is if we are allowing partial

# partial overlaps: in that case, we ignore optional args on the right.

for right_arg in right.formal_arguments():

left_arg = mypy.typeops.callable_corresponding_argument(left, right_arg)

if left_arg is None:

if allow_partial_overlap and not right_arg.required:

continue

return False

if not are_args_compatible(left_arg, right_arg, ignore_pos_arg_names,

allow_partial_overlap, is_compat):

return False

# Phase 1c: Check var args. Right has an infinite series of optional positional

# arguments. Get all further positional args of left, and make sure

# they're more general then the corresponding member in right.

if right_star is not None:

# Synthesize an anonymous formal argument for the right

right_by_position = right.try_synthesizing_arg_from_vararg(None)

assert right_by_position is not None

i = right_star.pos

assert i is not None

while i < len(left.arg_kinds) and left.arg_kinds[i].is_positional():

if allow_partial_overlap and left.arg_kinds[i].is_optional():

break

left_by_position = left.argument_by_position(i)

assert left_by_position is not None

if not are_args_compatible(left_by_position, right_by_position,

ignore_pos_arg_names, allow_partial_overlap,

is_compat):

return False

i += 1

# Phase 1d: Check kw args. Right has an infinite series of optional named

# arguments. Get all further named args of left, and make sure

# they're more general then the corresponding member in right.

if right_star2 is not None: