from __future__ import annotations

from collections.abc import Callable, Iterable, Iterator, Sequence

from contextlib import contextmanager

from typing import Any, Final, TypeAlias as _TypeAlias, TypeVar, cast

import mypy.applytype

import mypy.constraints

import mypy.typeops

from mypy.checker_state import checker_state

from mypy.erasetype import erase_type

from mypy.expandtype import (

expand_self_type,

expand_type,

expand_type_by_instance,

freshen_function_type_vars,

)

from mypy.maptype import map_instance_to_supertype

# Circular import; done in the function instead.

# import mypy.solve

from mypy.nodes import (

ARG_POS,

ARG_STAR,

ARG_STAR2,

CONTRAVARIANT,

COVARIANT,

INVARIANT,

VARIANCE_NOT_READY,

Context,

Decorator,

FuncBase,

FuncDef,

OverloadedFuncDef,

TypeInfo,

Var,

)

from mypy.options import Options

from mypy.state import state

from mypy.type_visitor import ANY_STRATEGY, BoolTypeQuery

from mypy.types import (

MAX_PROTOCOL_DEPTH,

MYPYC_NATIVE_INT_NAMES,

TUPLE_LIKE_INSTANCE_NAMES,

TYPED_NAMEDTUPLE_NAMES,

AnyType,

CallableType,

DeletedType,

ErasedType,

FormalArgument,

FunctionLike,

Instance,

LiteralType,

NoneType,

NormalizedCallableType,

Overloaded,

Parameters,

ParamSpecType,

PartialType,

ProperType,

TupleType,

Type,

TypeAliasType,

TypedDictType,

TypeOfAny,

TypeType,

TypeVarLikeType,

TypeVarTupleType,

TypeVarType,

TypeVisitor,

UnboundType,

UninhabitedType,

UnionType,

UnpackType,

extend_args_for_prefix_and_suffix,

find_unpack_in_list,

flatten_nested_unions,

get_proper_type,

get_variadic_item,

is_named_instance,

split_with_prefix_and_suffix,

)

from mypy.types_utils import flatten_types

from mypy.typestate import SubtypeKind, type_state

from mypy.typevars import fill_typevars, fill_typevars_with_any

# Flags for detected protocol members

IS_SETTABLE: Final = 1

IS_CLASSVAR: Final = 2

IS_CLASS_OR_STATIC: Final = 3

IS_VAR: Final = 4

IS_EXPLICIT_SETTER: Final = 5

TypeParameterChecker: _TypeAlias = Callable[[Type, Type, int, bool, "SubtypeContext"], bool]

class SubtypeContext:

def __init__(

self,

*,

# Non-proper subtype flags

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False,

ignore_declared_variance: bool = False,

# Supported for both proper and non-proper

always_covariant: bool = False,

ignore_promotions: bool = False,

# Proper subtype flags

erase_instances: bool = False,

keep_erased_types: bool = False,

options: Options | None = None,

) -> None:

self.ignore_type_params = ignore_type_params

self.ignore_pos_arg_names = ignore_pos_arg_names

self.ignore_declared_variance = ignore_declared_variance

self.always_covariant = always_covariant

self.ignore_promotions = ignore_promotions

self.erase_instances = erase_instances

self.keep_erased_types = keep_erased_types

self.options = options

def check_context(self, proper_subtype: bool) -> None:

# Historically proper and non-proper subtypes were defined using different helpers

# and different visitors. Check if flag values are such that we definitely support.

if proper_subtype:

assert not self.ignore_pos_arg_names and not self.ignore_declared_variance

else:

assert not self.erase_instances and not self.keep_erased_types

def is_subtype(

left: Type,

right: Type,

*,

subtype_context: SubtypeContext | None = None,

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False,

ignore_declared_variance: bool = False,

always_covariant: bool = False,

ignore_promotions: bool = False,

options: Options | None = None,

) -> bool:

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

Also consider Any to be a subtype of any type, and vice versa. This

recursively applies to components of composite types (List[int] is subtype

of List[Any], for example).

type_parameter_checker is used to check the type parameters (for example,

A with B in is_subtype(C[A], C[B]). The default checks for subtype relation

between the type arguments (e.g., A and B), taking the variance of the

type var into account.

"""

if left == right:

return True

if subtype_context is None:

subtype_context = SubtypeContext(

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

ignore_declared_variance=ignore_declared_variance,

always_covariant=always_covariant,

ignore_promotions=ignore_promotions,

options=options,

)

else:

assert (

not ignore_type_params

and not ignore_pos_arg_names

and not ignore_declared_variance

and not always_covariant

and not ignore_promotions

and options is None

), "Don't pass both context and individual flags"

if type_state.is_assumed_subtype(left, right):

return True

if mypy.typeops.is_recursive_pair(left, right):

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

# Our view on recursive types is known under a fancy name of iso-recursive 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(type_state.get_assumptions(is_proper=False), left, right):

return _is_subtype(left, right, subtype_context, proper_subtype=False)

return _is_subtype(left, right, subtype_context, proper_subtype=False)

def is_proper_subtype(

left: Type,

right: Type,

*,

subtype_context: SubtypeContext | None = None,

ignore_promotions: bool = False,

erase_instances: bool = False,

keep_erased_types: bool = False,

) -> bool:

"""Is left a proper subtype of right?

For proper subtypes, there's no need to rely on compatibility due to

Any types. Every usable type is a proper subtype of itself.

If erase_instances is True, erase left instance *after* mapping it to supertype

(this is useful for runtime isinstance() checks). If keep_erased_types is True,

do not consider ErasedType a subtype of all types (used by type inference against unions).

"""

if left == right:

return True

if subtype_context is None:

subtype_context = SubtypeContext(

ignore_promotions=ignore_promotions,

erase_instances=erase_instances,

keep_erased_types=keep_erased_types,

)

else:

assert (

not ignore_promotions and not erase_instances and not keep_erased_types

), "Don't pass both context and individual flags"

if type_state.is_assumed_proper_subtype(left, right):

return True

if mypy.typeops.is_recursive_pair(left, right):

# Same as for non-proper subtype, see detailed comment there for explanation.

with pop_on_exit(type_state.get_assumptions(is_proper=True), left, right):

return _is_subtype(left, right, subtype_context, proper_subtype=True)

return _is_subtype(left, right, subtype_context, proper_subtype=True)

def is_equivalent(

a: Type,

b: Type,

*,

ignore_type_params: bool = False,

ignore_pos_arg_names: bool = False,

options: Options | None = None,

subtype_context: SubtypeContext | None = None,

) -> bool:

return is_subtype(

a,

b,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

options=options,

subtype_context=subtype_context,

) and is_subtype(

b,

a,

ignore_type_params=ignore_type_params,

ignore_pos_arg_names=ignore_pos_arg_names,

options=options,

subtype_context=subtype_context,

)

def is_same_type(

a: Type, b: Type, ignore_promotions: bool = True, subtype_context: SubtypeContext | None = None

) -> bool:

"""Are these types proper subtypes of each other?

This means types may have different representation (e.g. an alias, or

a non-simplified union) but are semantically exchangeable in all contexts.

"""

# First, use fast path for some common types. This is performance-critical.

if (

type(a) is Instance

and type(b) is Instance

and a.type == b.type

and len(a.args) == len(b.args)

and a.last_known_value is b.last_known_value

):

return all(is_same_type(x, y) for x, y in zip(a.args, b.args))

elif (

isinstance(a, TypeVarType)

and isinstance(b, TypeVarType)

and a.id == b.id

and a.upper_bound == b.upper_bound

):

return True

# Note that using ignore_promotions=True (default) makes types like int and int64

# considered not the same type (which is the case at runtime).

# Also Union[bool, int] (if it wasn't simplified before) will be different

# from plain int, etc.

return is_proper_subtype(

a, b, ignore_promotions=ignore_promotions, subtype_context=subtype_context

) and is_proper_subtype(

b, a, ignore_promotions=ignore_promotions, subtype_context=subtype_context

)

# This is a common entry point for subtyping checks (both proper and non-proper).

# Never call this private function directly, use the public versions.

def _is_subtype(

left: Type, right: Type, subtype_context: SubtypeContext, proper_subtype: bool

) -> bool:

subtype_context.check_context(proper_subtype)

orig_right = right

orig_left = left

left = get_proper_type(left)

right = get_proper_type(right)

# Note: Unpack type should not be a subtype of Any, since it may represent

# multiple types. This should always go through the visitor, to check arity.

if (

not proper_subtype

and isinstance(right, (AnyType, UnboundType, ErasedType))

and not isinstance(left, UnpackType)

):

# TODO: should we consider all types proper subtypes of UnboundType and/or

# ErasedType as we do for non-proper subtyping.

return True

# Cases specific w.r.t. right type are easier to handle before entering the SubtypeVisitor.

# Currently, these include Union types and TypeVarType with values.

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

if proper_subtype:

is_subtype_of_item = any(

is_proper_subtype(orig_left, item, subtype_context=subtype_context)

for item in right.items

)

else:

is_subtype_of_item = any(

is_subtype(orig_left, item, subtype_context=subtype_context)

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(flatten_nested_unions(right.items))

)

if proper_subtype:

is_subtype_of_item = any(

is_proper_subtype(orig_left, item, subtype_context=subtype_context)

for item in right.items

)

else:

is_subtype_of_item = any(

is_subtype(orig_left, item, subtype_context=subtype_context)

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

if isinstance(right, TypeVarType) and right.values and not isinstance(left, TypeVarType):

if proper_subtype:

if all(

is_proper_subtype(orig_left, v, subtype_context=subtype_context)

for v in right.values

):

return True

elif all(is_subtype(orig_left, v, subtype_context=subtype_context) for v in right.values):

return True

return left.accept(SubtypeVisitor(orig_right, subtype_context, proper_subtype))

def check_type_parameter(

left: Type, right: Type, variance: int, proper_subtype: bool, subtype_context: SubtypeContext

) -> bool:

# It is safe to consider empty collection literals and similar as covariant, since

# such type can't be stored in a variable, see checker.is_valid_inferred_type().

if variance == INVARIANT:

p_left = get_proper_type(left)

if isinstance(p_left, UninhabitedType) and p_left.ambiguous:

variance = COVARIANT

# If variance hasn't been inferred yet, we are lenient and default to

# covariance. This shouldn't happen often, but it's very difficult to

# avoid these cases altogether.

if variance == COVARIANT or variance == VARIANCE_NOT_READY:

if proper_subtype:

return is_proper_subtype(left, right, subtype_context=subtype_context)

else:

return is_subtype(left, right, subtype_context=subtype_context)

elif variance == CONTRAVARIANT:

if proper_subtype:

return is_proper_subtype(right, left, subtype_context=subtype_context)

else:

return is_subtype(right, left, subtype_context=subtype_context)

else:

if proper_subtype:

# We pass ignore_promotions=False because it is a default for subtype checks.

# The actual value will be taken from the subtype_context, and it is whatever

# the original caller passed.

return is_same_type(

left, right, ignore_promotions=False, subtype_context=subtype_context

)

else:

return is_equivalent(left, right, subtype_context=subtype_context)

class SubtypeVisitor(TypeVisitor[bool]):

__slots__ = (

"right",

"orig_right",

"proper_subtype",

"subtype_context",

"options",

"_subtype_kind",

)

def __init__(self, right: Type, subtype_context: SubtypeContext, proper_subtype: bool) -> None:

self.right = get_proper_type(right)

self.orig_right = right

self.proper_subtype = proper_subtype

self.subtype_context = subtype_context

self.options = subtype_context.options

self._subtype_kind = SubtypeVisitor.build_subtype_kind(subtype_context, proper_subtype)

@staticmethod

def build_subtype_kind(subtype_context: SubtypeContext, proper_subtype: bool) -> SubtypeKind:

return (

state.strict_optional,

proper_subtype,

subtype_context.ignore_type_params,

subtype_context.ignore_pos_arg_names,

subtype_context.ignore_declared_variance,

subtype_context.always_covariant,

subtype_context.ignore_promotions,

subtype_context.erase_instances,

subtype_context.keep_erased_types,

)

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

if self.proper_subtype:

return is_proper_subtype(left, right, subtype_context=self.subtype_context)

return is_subtype(left, right, subtype_context=self.subtype_context)

def _all_subtypes(self, lefts: Iterable[Type], rights: Iterable[Type]) -> bool:

return all(self._is_subtype(li, ri) for (li, ri) in zip(lefts, rights))

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

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

# This can be called if there is a bad type annotation. The result probably

# doesn't matter much but by returning True we simplify these bad types away

# from unions, which could filter out some bogus messages.

return True

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

return isinstance(self.right, AnyType) if self.proper_subtype else 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__".

# None is also compatible with `SupportsStr` protocol.

return not members or all(member in ("__hash__", "__str__") for member in members)

return False

else:

return True

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

return True

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

# This may be encountered during type inference. The result probably doesn't

# matter much.

# TODO: it actually does matter, figure out more principled logic about this.

return not self.subtype_context.keep_erased_types

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

return True

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

if left.type.fallback_to_any and not self.proper_subtype:

# 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 not isinstance(self.right, NoneType)

right = self.right

if isinstance(right, TupleType) and right.partial_fallback.type.is_enum:

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

if isinstance(right, TupleType):

if len(right.items) == 1:

# Non-normalized Tuple type (may be left after semantic analysis

# because semanal_typearg visitor is not a type translator).

item = right.items[0]

if isinstance(item, UnpackType):

unpacked = get_proper_type(item.type)

if isinstance(unpacked, Instance):

return self._is_subtype(left, unpacked)

if left.type.has_base(right.partial_fallback.type.fullname):

mapped = map_instance_to_supertype(left, right.partial_fallback.type)

# Special cases to consider:

# * tuple[Any, ...] instance is a (non-proper) subtype of all tuple types.

# * Foo[*tuple[X, ...]] (normalized) instance is a subtype of all

# tuples with appropriate fallback (e.g. for variadic NamedTuples).

if not self.proper_subtype:

if is_erased_instance(mapped) and mapped.type.fullname == "builtins.tuple":

return True

if is_normalized_instance(mapped):

if self._is_subtype(mapped, right.partial_fallback):

return True

return False

if isinstance(right, TypeVarTupleType):

# tuple[Any, ...] is like Any in the world of tuples (see special case above).

if left.type.has_base("builtins.tuple"):

mapped = map_instance_to_supertype(left, right.tuple_fallback.type)

if isinstance(get_proper_type(mapped.args[0]), AnyType):

return not self.proper_subtype

if isinstance(right, Instance):

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

return True

if type_state.is_cached_negative_subtype_check(self._subtype_kind, left, right):

return False

if not self.subtype_context.ignore_promotions and not right.type.is_protocol:

for base in left.type.mro:

if base._promote and any(

self._is_subtype(p, self.right) for p in base._promote

):

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

return True

# Special case: Low-level integer types are compatible with 'int'. We can't

# use promotions, since 'int' is already promoted to low-level integer types,

# and we can't have circular promotions.

if left.type.alt_promote and left.type.alt_promote.type is right.type:

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

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

)

) and not self.subtype_context.ignore_declared_variance:

# Map left type to corresponding right instances.

t = map_instance_to_supertype(left, right.type)

if self.subtype_context.erase_instances:

erased = erase_type(t)

assert isinstance(erased, Instance)

t = erased

nominal = True

if right.type.has_type_var_tuple_type:

# For variadic instances we simply find the correct type argument mappings,

# all the heavy lifting is done by the tuple subtyping.

assert right.type.type_var_tuple_prefix is not None

assert right.type.type_var_tuple_suffix is not None

prefix = right.type.type_var_tuple_prefix

suffix = right.type.type_var_tuple_suffix

tvt = right.type.defn.type_vars[prefix]

assert isinstance(tvt, TypeVarTupleType)

fallback = tvt.tuple_fallback

left_prefix, left_middle, left_suffix = split_with_prefix_and_suffix(

t.args, prefix, suffix

)

right_prefix, right_middle, right_suffix = split_with_prefix_and_suffix(

right.args, prefix, suffix

)

left_args = (

left_prefix + (TupleType(list(left_middle), fallback),) + left_suffix

)

right_args = (

right_prefix + (TupleType(list(right_middle), fallback),) + right_suffix

)

if not self.proper_subtype and is_erased_instance(t):

return True

if len(left_args) != len(right_args):

return False

type_params = zip(left_args, right_args, right.type.defn.type_vars)

else:

type_params = zip(t.args, right.args, right.type.defn.type_vars)

if not self.subtype_context.ignore_type_params:

tried_infer = False

for lefta, righta, tvar in type_params:

if isinstance(tvar, TypeVarType):

if tvar.variance == VARIANCE_NOT_READY and not tried_infer:

infer_class_variances(right.type)

tried_infer = True

if (

self.subtype_context.always_covariant

and tvar.variance == INVARIANT

):

variance = COVARIANT

else:

variance = tvar.variance

if not check_type_parameter(

lefta, righta, variance, self.proper_subtype, self.subtype_context

):

nominal = False

else:

# TODO: everywhere else ParamSpecs are handled as invariant.

if not check_type_parameter(

lefta, righta, COVARIANT, self.proper_subtype, self.subtype_context

):

nominal = False

if nominal:

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

else:

type_state.record_negative_subtype_cache_entry(self._subtype_kind, left, right)

return nominal

if right.type.is_protocol and is_protocol_implementation(

left, right, proper_subtype=self.proper_subtype, options=self.options

):

return True

# We record negative cache entry here, and not in the protocol check like we do for

# positive cache, to avoid accidentally adding a type that is not a structural

# subtype, but is a nominal subtype (involving type: ignore override).

type_state.record_negative_subtype_cache_entry(self._subtype_kind, left, right)

return False

if isinstance(right, TypeType):

item = right.item

if isinstance(item, TupleType):

item = mypy.typeops.tuple_fallback(item)

# TODO: this is a bit arbitrary, we should only skip Any-related cases.

if not self.proper_subtype:

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, FunctionLike):

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

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:

# Fast path for most common case.

if left.upper_bound == right.upper_bound:

return True

# Corner case for self-types in classes generic in type vars

# with value restrictions.

if left.id.is_self():

return True

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

if left.values and self._is_subtype(UnionType.make_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 self._is_subtype(left.prefix, right.prefix)

if isinstance(right, Parameters) and are_trivial_parameters(right):

return True

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

def visit_type_var_tuple(self, left: TypeVarTupleType) -> bool:

right = self.right

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

return left.min_len >= right.min_len

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

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

# TODO: Ideally we should not need this (since it is not a real type).

# Instead callers (upper level types) should handle it when it appears in type list.

if isinstance(self.right, UnpackType):

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

if isinstance(self.right, Instance) and self.right.type.fullname == "builtins.object":

return True

return False

def visit_parameters(self, left: Parameters) -> bool:

if isinstance(self.right, Parameters):

return are_parameters_compatible(

left,

self.right,

is_compat=self._is_subtype,

# TODO: this should pass the current value, but then couple tests fail.

is_proper_subtype=False,

ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,

)

elif isinstance(self.right, Instance):

return self.right.type.fullname == "builtins.object"

else:

return False

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 left.type_is is not None and right.type_is is not None:

# For TypeIs we have to check both ways; it is unsafe to pass

# a TypeIs[Child] when a TypeIs[Parent] is expected, because

# if the narrower returns False, we assume that the narrowed value is

# *not* a Parent.

if not self._is_subtype(left.type_is, right.type_is) or not self._is_subtype(

right.type_is, left.type_is

):

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

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

# Similarly, if one function has `TypeIs` and the other does not,

# they are not compatible.

return False

strict_concatenate = False

if options := self.options:

strict_concatenate = options.extra_checks or options.strict_concatenate

return is_callable_compatible(

left,

right,

is_compat=self._is_subtype,

is_proper_subtype=self.proper_subtype,

ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,

strict_concatenate=strict_concatenate,

)

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 "__call__" in right.type.protocol_members:

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

call = find_member("__call__", right, right, is_operator=True)

assert call is not None

if self._is_subtype(left, call):

if len(right.type.protocol_members) == 1:

return True

if is_protocol_implementation(left.fallback, right, skip=["__call__"]):

return True

if right.type.is_protocol and left.is_type_obj():

instance_type = left.get_instance_type(force_fallback=True)

if isinstance(instance_type, Instance) and is_protocol_implementation(

instance_type, right, proper_subtype=self.proper_subtype, class_obj=True

):

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.get_instance_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:

if self.proper_subtype:

return False

iter_type = AnyType(TypeOfAny.special_form)

if is_named_instance(right, "builtins.tuple") and isinstance(

get_proper_type(iter_type), AnyType

):

# TODO: We shouldn't need this special case. This is currently needed

# for isinstance(x, tuple), though it's unclear why.

return True

for li in left.items:

if isinstance(li, UnpackType):

unpack = get_proper_type(li.type)

if isinstance(unpack, TypeVarTupleType):

unpack = get_proper_type(unpack.upper_bound)

assert (

isinstance(unpack, Instance)

and unpack.type.fullname == "builtins.tuple"

)

li = unpack.args[0]

if not self._is_subtype(li, iter_type):

return False

return True

elif self._is_subtype(left.partial_fallback, right) and self._is_subtype(

mypy.typeops.tuple_fallback(left), right

):

return True

elif right.type.is_protocol and is_protocol_implementation(

left, right, proper_subtype=self.proper_subtype

):

# Special-case protocols to get precise binding of self type for

# custom tuple types like NamedTuples.

return True

return False

elif isinstance(right, TupleType):

# If right has a variadic unpack this needs special handling. If there is a TypeVarTuple

# unpack, item count must coincide. If the left has variadic unpack but right

# doesn't have one, we will fall through.

if self.variadic_tuple_subtype(left, right):

return True

# The only case where variadic can be subtype of fixed is when left variadic item is Any.

# Otherwise, the original left will be returned, causing fall through to False.

left = self.adjust_left_if_possible(left, right)

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

return False

if any(not self._is_subtype(l, r) for l, r in zip(left.items, right.items)):

return False

if is_named_instance(right.partial_fallback, "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

if is_named_instance(left.partial_fallback, "builtins.tuple"):

# Again, no need to verify. At this point we know the right fallback

# is a subclass of tuple, so if left is plain tuple, it cannot be a subtype.

return False

# At this point we know both fallbacks are non-tuple.

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

else:

return False

def adjust_left_if_possible(self, left: TupleType, right: TupleType) -> TupleType:

"""Adjust shape of left containing *tuple[Any, ...] to match right.

Note: this only works if right is fixed size (including *Ts), the variadic

right are handled by the caller, currently with variadic_tuple_subtype().

"""

left_variadic = get_variadic_item(left)

if left_variadic is None:

return left

left_unpack_index, left_item = left_variadic

if not isinstance(get_proper_type(left_item), AnyType):

return left

right_unpack_index = find_unpack_in_list(right.items)

if right_unpack_index is None:

if len(left.items) > len(right.items) + 1:

return left

num_anys = len(right.items) - len(left.items) + 1

return left.copy_modified(

items=left.items[:left_unpack_index]

+ [left_item] * num_anys

+ left.items[left_unpack_index + 1 :]

)

right_unpack = right.items[right_unpack_index]

assert isinstance(right_unpack, UnpackType)

right_unpacked = get_proper_type(right_unpack.type)

if isinstance(right_unpacked, Instance):

return left

right_prefix = right_unpack_index

right_suffix = len(right.items) - right_prefix - 1

left_prefix = left_unpack_index

left_suffix = len(left.items) - left_prefix - 1

if left_prefix > right_prefix or left_suffix > right_suffix:

return left

new_items = extend_args_for_prefix_and_suffix(

tuple(left.items), right_prefix, right_suffix

)

return left.copy_modified(items=list(new_items))

def variadic_tuple_subtype(self, left: TupleType, right: TupleType) -> bool:

"""Check subtyping between two potentially variadic tuples.

Most non-trivial cases here are due to variadic unpacks like *tuple[X, ...],

we handle such unpacks as infinite unions Tuple[()] | Tuple[X] | Tuple[X, X] | ...

Note: the cases where right is fixed or has *Ts unpack should be handled

by the caller.

"""

right_variadic = get_variadic_item(right)

if right_variadic is None:

# This case should be handled by the caller.

return False

right_unpack_index, right_item = right_variadic

right_prefix = right_unpack_index

right_suffix = len(right.items) - right_prefix - 1

left_unpack_index = find_unpack_in_list(left.items)

if left_unpack_index is None:

# Simple case: left is fixed, simply find correct mapping to the right

# (effectively selecting item with matching length from an infinite union).

if len(left.items) < right_prefix + right_suffix:

return False

prefix, middle, suffix = split_with_prefix_and_suffix(

tuple(left.items), right_prefix, right_suffix

)

if not all(

self._is_subtype(li, ri) for li, ri in zip(prefix, right.items[:right_prefix])

):

return False

if right_suffix and not all(

self._is_subtype(li, ri) for li, ri in zip(suffix, right.items[-right_suffix:])

):

return False

return all(self._is_subtype(li, right_item) for li in middle)

else:

left_prefix = left_unpack_index

left_suffix = len(left.items) - left_prefix - 1

left_unpack = left.items[left_unpack_index]

assert isinstance(left_unpack, UnpackType)

left_unpacked = get_proper_type(left_unpack.type)

if not isinstance(left_unpacked, Instance):

if len(left.items) < len(right.items):

# There are some items on the left that will never have a matching length

# on the right.

return False

# *Ts unpack can't be split, except if it is all mapped to Anys or objects.

if self.is_top_type(right_item):

right_prefix_types, middle, right_suffix_types = split_with_prefix_and_suffix(

tuple(right.items), left_prefix, left_suffix

)

if not all(

self.is_top_type(ri) or isinstance(ri, UnpackType) for ri in middle

):

return False

# Also check the tails match as well.

return self._all_subtypes(

left.items[:left_prefix], right_prefix_types

) and self._all_subtypes(left.items[-left_suffix:], right_suffix_types)

return False

assert left_unpacked.type.fullname == "builtins.tuple"

left_item = left_unpacked.args[0]

# The most tricky case with two variadic unpacks we handle similar to union

# subtyping: *each* item on the left, must be a subtype of *some* item on the right.

# For this we first check the "asymptotic case", i.e. that both unpacks a subtypes,

# and then check subtyping for all finite overlaps.

# Note: if the left item is Any we use any() semantics instead of all().

use_any = isinstance(get_proper_type(left_item), AnyType)

if not use_any and len(left.items) < len(right.items):

# There are some items on the left that will never have a matching length

# on the right.

return False

if not self._is_subtype(left_item, right_item):

return False

max_overlap = max(0, right_prefix - left_prefix, right_suffix - left_suffix)

# We need to also handle the case where overlap is positive on both sides.

max_overlap = max(max_overlap, right_prefix - left_prefix + right_suffix - left_suffix)

for overlap in range(max_overlap + 1):

repr_items = left.items[:left_prefix] + [left_item] * overlap

if left_suffix:

repr_items += left.items[-left_suffix:]

left_repr = left.copy_modified(items=repr_items)

if not self._is_subtype(left_repr, right):

if not use_any:

return False

elif use_any:

return True

return not use_any

def is_top_type(self, typ: Type) -> bool:

if not self.proper_subtype and isinstance(get_proper_type(typ), AnyType):

return True

return is_named_instance(typ, "builtins.object")

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 left == right:

return True # Fast path

# A closed type must remain closed

if right.is_closed and not left.is_closed:

return False

# Perform fast key-based checks before recursing into value types

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

# Required keys must remain required

if r.required and not l.required:

return False