def test_is_proper_subtype_and_subtype_literal_types(self) -> None:
fx = self.fx
lit1 = fx.lit1
lit2 = fx.lit2
lit3 = fx.lit3
assert_true(is_proper_subtype(lit1, fx.a))
assert_false(is_proper_subtype(lit1, fx.d))
assert_false(is_proper_subtype(fx.a, lit1))
assert_true(is_proper_subtype(fx.uninhabited, lit1))
assert_false(is_proper_subtype(lit1, fx.uninhabited))
assert_true(is_proper_subtype(lit1, lit1))
assert_false(is_proper_subtype(lit1, lit2))
assert_false(is_proper_subtype(lit2, lit3))
assert_true(is_subtype(lit1, fx.a))
assert_false(is_subtype(lit1, fx.d))
assert_false(is_subtype(fx.a, lit1))
assert_true(is_subtype(fx.uninhabited, lit1))
assert_false(is_subtype(lit1, fx.uninhabited))
assert_true(is_subtype(lit1, lit1))
assert_false(is_subtype(lit1, lit2))
assert_false(is_subtype(lit2, lit3))
assert_false(is_proper_subtype(lit1, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, lit1))
assert_true(is_subtype(lit1, fx.anyt))
assert_true(is_subtype(fx.anyt, lit1))
def join_simple(declaration: Optional[Type], s: Type, t: Type) -> Type:
"""Return a simple least upper bound given the declared type."""
if (s.can_be_true, s.can_be_false) != (t.can_be_true, t.can_be_false):
# if types are restricted in different ways, use the more general versions
s = true_or_false(s)
t = true_or_false(t)
if isinstance(s, AnyType):
return s
if isinstance(s, ErasedType):
return t
if is_proper_subtype(s, t):
return t
if is_proper_subtype(t, s):
return s
if isinstance(declaration, UnionType):
return UnionType.make_simplified_union([s, t])
if isinstance(s, NoneType) and not isinstance(t, NoneType):
s, t = t, s
if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
s, t = t, s
value = t.accept(TypeJoinVisitor(s))
if declaration is None or is_subtype(value, declaration):
return value
return declaration
def test_is_proper_subtype_and_subtype_literal_types(self) -> None:
fx = self.fx
lit1 = LiteralType(1, fx.a)
lit2 = LiteralType("foo", fx.d)
lit3 = LiteralType("bar", fx.d)
assert_true(is_proper_subtype(lit1, fx.a))
assert_false(is_proper_subtype(lit1, fx.d))
assert_false(is_proper_subtype(fx.a, lit1))
assert_true(is_proper_subtype(fx.uninhabited, lit1))
assert_false(is_proper_subtype(lit1, fx.uninhabited))
assert_true(is_proper_subtype(lit1, lit1))
assert_false(is_proper_subtype(lit1, lit2))
assert_false(is_proper_subtype(lit2, lit3))
assert_true(is_subtype(lit1, fx.a))
assert_false(is_subtype(lit1, fx.d))
assert_false(is_subtype(fx.a, lit1))
assert_true(is_subtype(fx.uninhabited, lit1))
assert_false(is_subtype(lit1, fx.uninhabited))
assert_true(is_subtype(lit1, lit1))
assert_false(is_subtype(lit1, lit2))
assert_false(is_subtype(lit2, lit3))
assert_false(is_proper_subtype(lit1, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, lit1))
assert_true(is_subtype(lit1, fx.anyt))
assert_true(is_subtype(fx.anyt, lit1))
def test_is_proper_subtype_and_subtype_literal_types(self) -> None:
fx = self.fx
lit1 = LiteralType(1, fx.a)
lit2 = LiteralType("foo", fx.d)
lit3 = LiteralType("bar", fx.d)
assert_true(is_proper_subtype(lit1, fx.a))
assert_false(is_proper_subtype(lit1, fx.d))
assert_false(is_proper_subtype(fx.a, lit1))
assert_true(is_proper_subtype(fx.uninhabited, lit1))
assert_false(is_proper_subtype(lit1, fx.uninhabited))
assert_true(is_proper_subtype(lit1, lit1))
assert_false(is_proper_subtype(lit1, lit2))
assert_false(is_proper_subtype(lit2, lit3))
assert_true(is_subtype(lit1, fx.a))
assert_false(is_subtype(lit1, fx.d))
assert_false(is_subtype(fx.a, lit1))
assert_true(is_subtype(fx.uninhabited, lit1))
assert_false(is_subtype(lit1, fx.uninhabited))
assert_true(is_subtype(lit1, lit1))
assert_false(is_subtype(lit1, lit2))
assert_false(is_subtype(lit2, lit3))
assert_false(is_proper_subtype(lit1, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, lit1))
assert_true(is_subtype(lit1, fx.anyt))
assert_true(is_subtype(fx.anyt, lit1))
def test_is_proper_subtype_and_subtype_literal_types(self) -> None:
fx = self.fx
lit1 = fx.lit1
lit2 = fx.lit2
lit3 = fx.lit3
assert is_proper_subtype(lit1, fx.a)
assert not is_proper_subtype(lit1, fx.d)
assert not is_proper_subtype(fx.a, lit1)
assert is_proper_subtype(fx.uninhabited, lit1)
assert not is_proper_subtype(lit1, fx.uninhabited)
assert is_proper_subtype(lit1, lit1)
assert not is_proper_subtype(lit1, lit2)
assert not is_proper_subtype(lit2, lit3)
assert is_subtype(lit1, fx.a)
assert not is_subtype(lit1, fx.d)
assert not is_subtype(fx.a, lit1)
assert is_subtype(fx.uninhabited, lit1)
assert not is_subtype(lit1, fx.uninhabited)
assert is_subtype(lit1, lit1)
assert not is_subtype(lit1, lit2)
assert not is_subtype(lit2, lit3)
assert not is_proper_subtype(lit1, fx.anyt)
assert not is_proper_subtype(fx.anyt, lit1)
assert is_subtype(lit1, fx.anyt)
assert is_subtype(fx.anyt, lit1)
def test_is_proper_subtype_covariance(self):
fx_co = self.fx_co
assert_true(is_proper_subtype(fx_co.gsab, fx_co.gb))
assert_true(is_proper_subtype(fx_co.gsab, fx_co.ga))
assert_false(is_proper_subtype(fx_co.gsaa, fx_co.gb))
assert_true(is_proper_subtype(fx_co.gb, fx_co.ga))
assert_false(is_proper_subtype(fx_co.ga, fx_co.gb))
def test_is_proper_subtype_invariance(self):
fx = self.fx
assert_true(is_proper_subtype(fx.gsab, fx.gb))
assert_false(is_proper_subtype(fx.gsab, fx.ga))
assert_false(is_proper_subtype(fx.gsaa, fx.gb))
assert_false(is_proper_subtype(fx.gb, fx.ga))
assert_false(is_proper_subtype(fx.ga, fx.gb))
def test_is_proper_subtype_contravariance(self) -> None:
fx_contra = self.fx_contra
assert_true(is_proper_subtype(fx_contra.gsab, fx_contra.gb))
assert_false(is_proper_subtype(fx_contra.gsab, fx_contra.ga))
assert_true(is_proper_subtype(fx_contra.gsaa, fx_contra.gb))
assert_false(is_proper_subtype(fx_contra.gb, fx_contra.ga))
assert_true(is_proper_subtype(fx_contra.ga, fx_contra.gb))
def test_is_proper_subtype_invariance(self) -> None:
fx = self.fx
assert is_proper_subtype(fx.gsab, fx.gb)
assert not is_proper_subtype(fx.gsab, fx.ga)
assert not is_proper_subtype(fx.gsaa, fx.gb)
assert not is_proper_subtype(fx.gb, fx.ga)
assert not is_proper_subtype(fx.ga, fx.gb)
def test_is_proper_subtype_invariance(self) -> None:
fx = self.fx
assert_true(is_proper_subtype(fx.gsab, fx.gb))
assert_false(is_proper_subtype(fx.gsab, fx.ga))
assert_false(is_proper_subtype(fx.gsaa, fx.gb))
assert_false(is_proper_subtype(fx.gb, fx.ga))
assert_false(is_proper_subtype(fx.ga, fx.gb))
def test_is_proper_subtype_covariance(self) -> None:
fx_co = self.fx_co
assert_true(is_proper_subtype(fx_co.gsab, fx_co.gb))
assert_true(is_proper_subtype(fx_co.gsab, fx_co.ga))
assert_false(is_proper_subtype(fx_co.gsaa, fx_co.gb))
assert_true(is_proper_subtype(fx_co.gb, fx_co.ga))
assert_false(is_proper_subtype(fx_co.ga, fx_co.gb))
def test_is_proper_subtype_contravariance(self) -> None:
fx_contra = self.fx_contra
assert is_proper_subtype(fx_contra.gsab, fx_contra.gb)
assert not is_proper_subtype(fx_contra.gsab, fx_contra.ga)
assert is_proper_subtype(fx_contra.gsaa, fx_contra.gb)
assert not is_proper_subtype(fx_contra.gb, fx_contra.ga)
assert is_proper_subtype(fx_contra.ga, fx_contra.gb)
def test_is_proper_subtype_contravariance(self):
fx_contra = self.fx_contra
assert_true(is_proper_subtype(fx_contra.gsab, fx_contra.gb))
assert_false(is_proper_subtype(fx_contra.gsab, fx_contra.ga))
assert_true(is_proper_subtype(fx_contra.gsaa, fx_contra.gb))
assert_false(is_proper_subtype(fx_contra.gb, fx_contra.ga))
assert_true(is_proper_subtype(fx_contra.ga, fx_contra.gb))
def join_simple(declaration: Optional[Type], s: Type, t: Type) -> Type:
"""Return a simple least upper bound given the declared type."""
if (s.can_be_true, s.can_be_false) != (t.can_be_true, t.can_be_false):
# if types are restricted in different ways, use the more general versions
s = true_or_false(s)
t = true_or_false(t)
if isinstance(s, AnyType):
return s
if isinstance(s, ErasedType):
return t
if is_proper_subtype(s, t):
return t
if is_proper_subtype(t, s):
return s
if isinstance(declaration, UnionType):
return UnionType.make_simplified_union([s, t])
if isinstance(s, NoneTyp) and not isinstance(t, NoneTyp):
s, t = t, s
if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
s, t = t, s
value = t.accept(TypeJoinVisitor(s))
if value is None:
# XXX this code path probably should be avoided.
# It seems to happen when a line (x = y) is a type error, and
# it's not clear that assuming that x is arbitrary afterward
# is a good idea.
return declaration
if declaration is None or is_subtype(value, declaration):
return value
return declaration
def join_simple(declaration: Optional[Type], s: Type, t: Type) -> Type:
"""Return a simple least upper bound given the declared type."""
if (s.can_be_true, s.can_be_false) != (t.can_be_true, t.can_be_false):
# if types are restricted in different ways, use the more general versions
s = true_or_false(s)
t = true_or_false(t)
if isinstance(s, AnyType):
return s
if isinstance(s, ErasedType):
return t
if is_proper_subtype(s, t):
return t
if is_proper_subtype(t, s):
return s
if isinstance(declaration, UnionType):
return UnionType.make_simplified_union([s, t])
if isinstance(s, NoneTyp) and not isinstance(t, NoneTyp):
s, t = t, s
if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
s, t = t, s
value = t.accept(TypeJoinVisitor(s))
if value is None:
# XXX this code path probably should be avoided.
# It seems to happen when a line (x = y) is a type error, and
# it's not clear that assuming that x is arbitrary afterward
# is a good idea.
return declaration
if declaration is None or is_subtype(value, declaration):
return value
return declaration
def make_simplified_union(items: Sequence[Type],
line: int = -1,
column: int = -1,
*,
keep_erased: bool = False) -> ProperType:
"""Build union type with redundant union items removed.
If only a single item remains, this may return a non-union type.
Examples:
* [int, str] -> Union[int, str]
* [int, object] -> object
* [int, int] -> int
* [int, Any] -> Union[int, Any] (Any types are not simplified away!)
* [Any, Any] -> Any
Note: This must NOT be used during semantic analysis, since TypeInfos may not
be fully initialized.
The keep_erased flag is used for type inference against union types
containing type variables. If set to True, keep all ErasedType items.
"""
items = get_proper_types(items)
while any(isinstance(typ, UnionType) for typ in items):
all_items = [] # type: List[ProperType]
for typ in items:
if isinstance(typ, UnionType):
all_items.extend(get_proper_types(typ.items))
else:
all_items.append(typ)
items = all_items
from mypy.subtypes import is_proper_subtype
removed = set() # type: Set[int]
for i, ti in enumerate(items):
if i in removed: continue
# Keep track of the truishness info for deleted subtypes which can be relevant
cbt = cbf = False
for j, tj in enumerate(items):
if i != j and is_proper_subtype(
tj, ti, keep_erased_types=keep_erased):
# We found a redundant item in the union.
removed.add(j)
cbt = cbt or tj.can_be_true
cbf = cbf or tj.can_be_false
# if deleted subtypes had more general truthiness, use that
if not ti.can_be_true and cbt:
items[i] = true_or_false(ti)
elif not ti.can_be_false and cbf:
items[i] = true_or_false(ti)
simplified_set = [items[i] for i in range(len(items)) if i not in removed]
return UnionType.make_union(simplified_set, line, column)
def proper_types_hook(ctx: FunctionContext) -> Type:
"""Check if this get_proper_types() call is not redundant."""
arg_types = ctx.arg_types[0]
if arg_types:
arg_type = arg_types[0]
proper_type = get_proper_type_instance(ctx)
item_type = UnionType.make_union([NoneTyp(), proper_type])
ok_type = ctx.api.named_generic_type('typing.Iterable', [item_type])
if is_proper_subtype(arg_type, ok_type):
ctx.api.fail('Redundant call to get_proper_types()', ctx.context)
return ctx.default_return_type
def proper_type_hook(ctx: FunctionContext) -> Type:
"""Check if this get_proper_type() call is not redundant."""
arg_types = ctx.arg_types[0]
if arg_types:
arg_type = get_proper_type(arg_types[0])
proper_type = get_proper_type_instance(ctx)
if is_proper_subtype(arg_type, UnionType.make_union([NoneTyp(), proper_type])):
# Minimize amount of spurious errors from overload machinery.
# TODO: call the hook on the overload as a whole?
if isinstance(arg_type, (UnionType, Instance)):
ctx.api.fail('Redundant call to get_proper_type()', ctx.context)
return ctx.default_return_type
def visit_tuple_type(self, t: TupleType) -> Type:
if isinstance(self.s, TupleType) and self.s.length() == t.length():
items = [] # type: List[Type]
for i in range(t.length()):
items.append(self.meet(t.items[i], self.s.items[i]))
# TODO: What if the fallbacks are different?
return TupleType(items, tuple_fallback(t))
elif isinstance(self.s, Instance):
# meet(Tuple[t1, t2, <...>], Tuple[s, ...]) == Tuple[meet(t1, s), meet(t2, s), <...>].
if self.s.type.fullname() == 'builtins.tuple' and self.s.args:
return t.copy_modified(items=[meet_types(it, self.s.args[0]) for it in t.items])
elif is_proper_subtype(t, self.s):
# A named tuple that inherits from a normal class
return t
return self.default(self.s)
def visit_tuple_type(self, t: TupleType) -> Type:
if isinstance(self.s, TupleType) and self.s.length() == t.length():
items = [] # type: List[Type]
for i in range(t.length()):
items.append(self.meet(t.items[i], self.s.items[i]))
# TODO: What if the fallbacks are different?
return TupleType(items, t.fallback)
elif isinstance(self.s, Instance):
# meet(Tuple[t1, t2, <...>], Tuple[s, ...]) == Tuple[meet(t1, s), meet(t2, s), <...>].
if self.s.type.fullname() == 'builtins.tuple' and self.s.args:
return t.copy_modified(items=[meet_types(it, self.s.args[0]) for it in t.items])
elif is_proper_subtype(t, self.s):
# A named tuple that inherits from a normal class
return t
return self.default(self.s)
def visit_tuple_type(self, t: TupleType) -> Type:
if isinstance(self.s, TupleType) and self.s.length() == t.length():
items = [] # type: List[Type]
for i in range(t.length()):
items.append(self.meet(t.items[i], self.s.items[i]))
# TODO: What if the fallbacks are different?
return TupleType(items, t.fallback)
# meet(Tuple[t1, t2, <...>], Tuple[s, ...]) == Tuple[meet(t1, s), meet(t2, s), <...>].
elif (isinstance(self.s, Instance) and
(self.s.type.fullname() == 'builtins.tuple' or is_proper_subtype(t, self.s))
and self.s.args):
return t.copy_modified(items=[meet_types(it, self.s.args[0]) for it in t.items])
elif (isinstance(self.s, Instance) and t.fallback.type == self.s.type):
# Uh oh, a broken named tuple type (https://github.com/python/mypy/issues/3016).
# Do something reasonable until that bug is fixed.
return t
else:
return self.default(self.s)
def is_trivial_coercion(target_type, source_type, is_java):
"""Is an implicit coercion from source_type to target_type a no-op?
Note that we omit coercions of form any <= C, unless C is a primitive that
may have a special representation.
"""
# FIX: Replace type vars in source type with any?
if isinstance(source_type, Void) or is_same_type(target_type, source_type):
return True
# Coercions from a primitive type to any other type are non-trivial, since
# we may have to change the representation.
if not is_java and is_special_primitive(source_type):
return False
return (is_proper_subtype(source_type, target_type)
or isinstance(source_type, NoneTyp)
or isinstance(target_type, Any))
def is_trivial_coercion(target_type: Type, source_type: Type,
is_java: bool) -> bool:
"""Is an implicit coercion from source_type to target_type a no-op?
Note that we omit coercions of form any <= C, unless C is a primitive that
may have a special representation.
"""
# FIX: Replace type vars in source type with any?
if isinstance(source_type, Void) or is_same_type(target_type, source_type):
return True
# Coercions from a primitive type to any other type are non-trivial, since
# we may have to change the representation.
if not is_java and is_special_primitive(source_type):
return False
return (is_proper_subtype(source_type, target_type)
or isinstance(source_type, NoneTyp)
or isinstance(target_type, AnyType))
def test_is_proper_subtype(self):
fx = self.fx
assert_true(is_proper_subtype(fx.a, fx.a))
assert_true(is_proper_subtype(fx.b, fx.a))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_false(is_proper_subtype(fx.a, fx.b))
assert_false(is_proper_subtype(fx.o, fx.b))
assert_true(is_proper_subtype(fx.anyt, fx.anyt))
assert_false(is_proper_subtype(fx.a, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, fx.a))
assert_true(is_proper_subtype(fx.ga, fx.ga))
assert_true(is_proper_subtype(fx.gdyn, fx.gdyn))
assert_false(is_proper_subtype(fx.ga, fx.gdyn))
assert_false(is_proper_subtype(fx.gdyn, fx.ga))
assert_true(is_proper_subtype(fx.t, fx.t))
assert_false(is_proper_subtype(fx.t, fx.s))
def make_simplified_union(items: Sequence[Type],
line: int = -1,
column: int = -1,
*,
keep_erased: bool = False,
contract_literals: bool = True) -> ProperType:
"""Build union type with redundant union items removed.
If only a single item remains, this may return a non-union type.
Examples:
* [int, str] -> Union[int, str]
* [int, object] -> object
* [int, int] -> int
* [int, Any] -> Union[int, Any] (Any types are not simplified away!)
* [Any, Any] -> Any
Note: This must NOT be used during semantic analysis, since TypeInfos may not
be fully initialized.
The keep_erased flag is used for type inference against union types
containing type variables. If set to True, keep all ErasedType items.
"""
items = get_proper_types(items)
while any(isinstance(typ, UnionType) for typ in items):
all_items: List[ProperType] = []
for typ in items:
if isinstance(typ, UnionType):
all_items.extend(get_proper_types(typ.items))
else:
all_items.append(typ)
items = all_items
from mypy.subtypes import is_proper_subtype
removed: Set[int] = set()
seen: Set[Tuple[str, str]] = set()
# NB: having a separate fast path for Union of Literal and slow path for other things
# would arguably be cleaner, however it breaks down when simplifying the Union of two
# different enum types as try_expanding_enum_to_union works recursively and will
# trigger intermediate simplifications that would render the fast path useless
for i, item in enumerate(items):
if i in removed:
continue
# Avoid slow nested for loop for Union of Literal of strings/enums (issue #9169)
if is_simple_literal(item):
assert isinstance(item, LiteralType)
assert isinstance(item.value, str)
k = (item.value, item.fallback.type.fullname)
if k in seen:
removed.add(i)
continue
# NB: one would naively expect that it would be safe to skip the slow path
# always for literals. One would be sorely mistaken. Indeed, some simplifications
# such as that of None/Optional when strict optional is false, do require that we
# proceed with the slow path. Thankfully, all literals will have the same subtype
# relationship to non-literal types, so we only need to do that walk for the first
# literal, which keeps the fast path fast even in the presence of a mixture of
# literals and other types.
safe_skip = len(seen) > 0
seen.add(k)
if safe_skip:
continue
# Keep track of the truishness info for deleted subtypes which can be relevant
cbt = cbf = False
for j, tj in enumerate(items):
# NB: we don't need to check literals as the fast path above takes care of that
if (i != j and not is_simple_literal(tj) and is_proper_subtype(
tj, item, keep_erased_types=keep_erased)
and is_redundant_literal_instance(item, tj) # XXX?
):
# We found a redundant item in the union.
removed.add(j)
cbt = cbt or tj.can_be_true
cbf = cbf or tj.can_be_false
# if deleted subtypes had more general truthiness, use that
if not item.can_be_true and cbt:
items[i] = true_or_false(item)
elif not item.can_be_false and cbf:
items[i] = true_or_false(item)
simplified_set = [items[i] for i in range(len(items)) if i not in removed]
# If more than one literal exists in the union, try to simplify
if (contract_literals
and sum(isinstance(item, LiteralType)
for item in simplified_set) > 1):
simplified_set = try_contracting_literals_in_union(simplified_set)
return UnionType.make_union(simplified_set, line, column)
def is_overlapping_types(left: Type,
right: Type,
ignore_promotions: bool = False,
prohibit_none_typevar_overlap: bool = False) -> bool:
"""Can a value of type 'left' also be of type 'right' or vice-versa?
If 'ignore_promotions' is True, we ignore promotions while checking for overlaps.
If 'prohibit_none_typevar_overlap' is True, we disallow None from overlapping with
TypeVars (in both strict-optional and non-strict-optional mode).
"""
left = get_proper_type(left)
right = get_proper_type(right)
def _is_overlapping_types(left: Type, right: Type) -> bool:
'''Encode the kind of overlapping check to perform.
This function mostly exists so we don't have to repeat keyword arguments everywhere.'''
return is_overlapping_types(
left,
right,
ignore_promotions=ignore_promotions,
prohibit_none_typevar_overlap=prohibit_none_typevar_overlap)
# We should never encounter this type.
if isinstance(left, PartialType) or isinstance(right, PartialType):
assert False, "Unexpectedly encountered partial type"
# We should also never encounter these types, but it's possible a few
# have snuck through due to unrelated bugs. For now, we handle these
# in the same way we handle 'Any'.
#
# TODO: Replace these with an 'assert False' once we are more confident.
illegal_types = (UnboundType, ErasedType, DeletedType)
if isinstance(left, illegal_types) or isinstance(right, illegal_types):
return True
# 'Any' may or may not be overlapping with the other type
if isinstance(left, AnyType) or isinstance(right, AnyType):
return True
# When running under non-strict optional mode, simplify away types of
# the form 'Union[A, B, C, None]' into just 'Union[A, B, C]'.
if not state.strict_optional:
if isinstance(left, UnionType):
left = UnionType.make_union(left.relevant_items())
if isinstance(right, UnionType):
right = UnionType.make_union(right.relevant_items())
# We check for complete overlaps next as a general-purpose failsafe.
# If this check fails, we start checking to see if there exists a
# *partial* overlap between types.
#
# These checks will also handle the NoneType and UninhabitedType cases for us.
if (is_proper_subtype(left, right, ignore_promotions=ignore_promotions)
or is_proper_subtype(
right, left, ignore_promotions=ignore_promotions)):
return True
# See the docstring for 'get_possible_variants' for more info on what the
# following lines are doing.
left_possible = get_possible_variants(left)
right_possible = get_possible_variants(right)
# We start by checking multi-variant types like Unions first. We also perform
# the same logic if either type happens to be a TypeVar.
#
# Handling the TypeVars now lets us simulate having them bind to the corresponding
# type -- if we deferred these checks, the "return-early" logic of the other
# checks will prevent us from detecting certain overlaps.
#
# If both types are singleton variants (and are not TypeVars), we've hit the base case:
# we skip these checks to avoid infinitely recursing.
def is_none_typevar_overlap(t1: ProperType, t2: ProperType) -> bool:
return isinstance(t1, NoneType) and isinstance(t2, TypeVarType)
if prohibit_none_typevar_overlap:
if is_none_typevar_overlap(left, right) or is_none_typevar_overlap(
right, left):
return False
if (len(left_possible) > 1 or len(right_possible) > 1
or isinstance(left, TypeVarType)
or isinstance(right, TypeVarType)):
for l in left_possible:
for r in right_possible:
if _is_overlapping_types(l, r):
return True
return False
# Now that we've finished handling TypeVars, we're free to end early
# if one one of the types is None and we're running in strict-optional mode.
# (None only overlaps with None in strict-optional mode).
#
# We must perform this check after the TypeVar checks because
# a TypeVar could be bound to None, for example.
if state.strict_optional and isinstance(left, NoneType) != isinstance(
right, NoneType):
return False
# Next, we handle single-variant types that may be inherently partially overlapping:
#
# - TypedDicts
# - Tuples
#
# If we cannot identify a partial overlap and end early, we degrade these two types
# into their 'Instance' fallbacks.
if isinstance(left, TypedDictType) and isinstance(right, TypedDictType):
return are_typed_dicts_overlapping(left,
right,
ignore_promotions=ignore_promotions)
elif typed_dict_mapping_pair(left, right):
# Overlaps between TypedDicts and Mappings require dedicated logic.
return typed_dict_mapping_overlap(left,
right,
overlapping=_is_overlapping_types)
elif isinstance(left, TypedDictType):
left = left.fallback
elif isinstance(right, TypedDictType):
right = right.fallback
if is_tuple(left) and is_tuple(right):
return are_tuples_overlapping(left,
right,
ignore_promotions=ignore_promotions)
elif isinstance(left, TupleType):
left = tuple_fallback(left)
elif isinstance(right, TupleType):
right = tuple_fallback(right)
# Next, we handle single-variant types that cannot be inherently partially overlapping,
# but do require custom logic to inspect.
#
# As before, we degrade into 'Instance' whenever possible.
if isinstance(left, TypeType) and isinstance(right, TypeType):
return _is_overlapping_types(left.item, right.item)
def _type_object_overlap(left: ProperType, right: ProperType) -> bool:
"""Special cases for type object types overlaps."""
# TODO: these checks are a bit in gray area, adjust if they cause problems.
# 1. Type[C] vs Callable[..., C], where the latter is class object.
if isinstance(left, TypeType) and isinstance(
right, CallableType) and right.is_type_obj():
return _is_overlapping_types(left.item, right.ret_type)
# 2. Type[C] vs Meta, where Meta is a metaclass for C.
if isinstance(left, TypeType) and isinstance(right, Instance):
if isinstance(left.item, Instance):
left_meta = left.item.type.metaclass_type
if left_meta is not None:
return _is_overlapping_types(left_meta, right)
# builtins.type (default metaclass) overlaps with all metaclasses
return right.type.has_base('builtins.type')
elif isinstance(left.item, AnyType):
return right.type.has_base('builtins.type')
# 3. Callable[..., C] vs Meta is considered below, when we switch to fallbacks.
return False
if isinstance(left, TypeType) or isinstance(right, TypeType):
return _type_object_overlap(left, right) or _type_object_overlap(
right, left)
if isinstance(left, CallableType) and isinstance(right, CallableType):
return is_callable_compatible(left,
right,
is_compat=_is_overlapping_types,
ignore_pos_arg_names=True,
allow_partial_overlap=True)
elif isinstance(left, CallableType):
left = left.fallback
elif isinstance(right, CallableType):
right = right.fallback
if isinstance(left, LiteralType) and isinstance(right, LiteralType):
if left.value == right.value:
# If values are the same, we still need to check if fallbacks are overlapping,
# this is done below.
left = left.fallback
right = right.fallback
else:
return False
elif isinstance(left, LiteralType):
left = left.fallback
elif isinstance(right, LiteralType):
right = right.fallback
# Finally, we handle the case where left and right are instances.
if isinstance(left, Instance) and isinstance(right, Instance):
# First we need to handle promotions and structural compatibility for instances
# that came as fallbacks, so simply call is_subtype() to avoid code duplication.
if (is_subtype(left, right, ignore_promotions=ignore_promotions) or
is_subtype(right, left, ignore_promotions=ignore_promotions)):
return True
# Two unrelated types cannot be partially overlapping: they're disjoint.
if left.type.has_base(right.type.fullname()):
left = map_instance_to_supertype(left, right.type)
elif right.type.has_base(left.type.fullname()):
right = map_instance_to_supertype(right, left.type)
else:
return False
if len(left.args) == len(right.args):
# Note: we don't really care about variance here, since the overlapping check
# is symmetric and since we want to return 'True' even for partial overlaps.
#
# For example, suppose we have two types Wrapper[Parent] and Wrapper[Child].
# It doesn't matter whether Wrapper is covariant or contravariant since
# either way, one of the two types will overlap with the other.
#
# Similarly, if Wrapper was invariant, the two types could still be partially
# overlapping -- what if Wrapper[Parent] happened to contain only instances of
# specifically Child?
#
# Or, to use a more concrete example, List[Union[A, B]] and List[Union[B, C]]
# would be considered partially overlapping since it's possible for both lists
# to contain only instances of B at runtime.
for left_arg, right_arg in zip(left.args, right.args):
if _is_overlapping_types(left_arg, right_arg):
return True
return False
# We ought to have handled every case by now: we conclude the
# two types are not overlapping, either completely or partially.
#
# Note: it's unclear however, whether returning False is the right thing
# to do when inferring reachability -- see https://github.com/python/mypy/issues/5529
assert type(left) != type(right)
return False
def test_is_proper_subtype(self) -> None:
fx = self.fx
assert is_proper_subtype(fx.a, fx.a)
assert is_proper_subtype(fx.b, fx.a)
assert is_proper_subtype(fx.b, fx.o)
assert is_proper_subtype(fx.b, fx.o)
assert not is_proper_subtype(fx.a, fx.b)
assert not is_proper_subtype(fx.o, fx.b)
assert is_proper_subtype(fx.anyt, fx.anyt)
assert not is_proper_subtype(fx.a, fx.anyt)
assert not is_proper_subtype(fx.anyt, fx.a)
assert is_proper_subtype(fx.ga, fx.ga)
assert is_proper_subtype(fx.gdyn, fx.gdyn)
assert not is_proper_subtype(fx.ga, fx.gdyn)
assert not is_proper_subtype(fx.gdyn, fx.ga)
assert is_proper_subtype(fx.t, fx.t)
assert not is_proper_subtype(fx.t, fx.s)
assert is_proper_subtype(fx.a, UnionType([fx.a, fx.b]))
assert is_proper_subtype(UnionType([fx.a, fx.b]),
UnionType([fx.a, fx.b, fx.c]))
assert not is_proper_subtype(UnionType([fx.a, fx.b]),
UnionType([fx.b, fx.c]))
def is_overlapping_types(t: Type,
s: Type,
use_promotions: bool = False) -> bool:
"""Can a value of type t be a value of type s, or vice versa?
Note that this effectively checks against erased types, since type
variables are erased at runtime and the overlapping check is based
on runtime behavior. The exception is protocol types, it is not safe,
but convenient and is an opt-in behavior.
If use_promotions is True, also consider type promotions (int and
float would only be overlapping if it's True).
This does not consider multiple inheritance. For example, A and B in
the following example are not considered overlapping, even though
via C they can be overlapping:
class A: ...
class B: ...
class C(A, B): ...
The rationale is that this case is usually very unlikely as multiple
inheritance is rare. Also, we can't reliably determine whether
multiple inheritance actually occurs somewhere in a program, due to
stub files hiding implementation details, dynamic loading etc.
TODO: Don't consider callables always overlapping.
TODO: Don't consider type variables with values always overlapping.
"""
# Any overlaps with everything
if isinstance(t, AnyType) or isinstance(s, AnyType):
return True
# object overlaps with everything
if (isinstance(t, Instance) and t.type.fullname() == 'builtins.object'
or isinstance(s, Instance)
and s.type.fullname() == 'builtins.object'):
return True
if is_proper_subtype(t, s) or is_proper_subtype(s, t):
return True
# Since we are effectively working with the erased types, we only
# need to handle occurrences of TypeVarType at the top level.
if isinstance(t, TypeVarType):
t = t.erase_to_union_or_bound()
if isinstance(s, TypeVarType):
s = s.erase_to_union_or_bound()
if isinstance(t, TypedDictType):
t = t.as_anonymous().fallback
if isinstance(s, TypedDictType):
s = s.as_anonymous().fallback
if isinstance(t, UnionType):
return any(
is_overlapping_types(item, s) for item in t.relevant_items())
if isinstance(s, UnionType):
return any(
is_overlapping_types(t, item) for item in s.relevant_items())
# We must check for TupleTypes before Instances, since Tuple[A, ...]
# is an Instance
tup_overlap = is_overlapping_tuples(t, s, use_promotions)
if tup_overlap is not None:
return tup_overlap
if isinstance(t, Instance):
if isinstance(s, Instance):
# Consider two classes non-disjoint if one is included in the mro
# of another.
if use_promotions:
# Consider cases like int vs float to be overlapping where
# there is only a type promotion relationship but not proper
# subclassing.
if t.type._promote and is_overlapping_types(
t.type._promote, s):
return True
if s.type._promote and is_overlapping_types(
s.type._promote, t):
return True
if t.type in s.type.mro or s.type in t.type.mro:
return True
if t.type.is_protocol and is_protocol_implementation(s, t):
return True
if s.type.is_protocol and is_protocol_implementation(t, s):
return True
return False
if isinstance(t, TypeType) and isinstance(s, TypeType):
# If both types are TypeType, compare their inner types.
return is_overlapping_types(t.item, s.item, use_promotions)
elif isinstance(t, TypeType) or isinstance(s, TypeType):
# If exactly only one of t or s is a TypeType, check if one of them
# is an `object` or a `type` and otherwise assume no overlap.
one = t if isinstance(t, TypeType) else s
other = s if isinstance(t, TypeType) else t
if isinstance(other, Instance):
return other.type.fullname() in {
'builtins.object', 'builtins.type'
}
else:
return isinstance(other, CallableType) and is_subtype(other, one)
if experiments.STRICT_OPTIONAL:
if isinstance(t, NoneTyp) != isinstance(s, NoneTyp):
# NoneTyp does not overlap with other non-Union types under strict Optional checking
return False
# We conservatively assume that non-instance, non-union, non-TupleType and non-TypeType types
# can overlap any other types.
return True
def test_is_proper_subtype(self) -> None:
fx = self.fx
assert_true(is_proper_subtype(fx.a, fx.a))
assert_true(is_proper_subtype(fx.b, fx.a))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_false(is_proper_subtype(fx.a, fx.b))
assert_false(is_proper_subtype(fx.o, fx.b))
assert_true(is_proper_subtype(fx.anyt, fx.anyt))
assert_false(is_proper_subtype(fx.a, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, fx.a))
assert_true(is_proper_subtype(fx.ga, fx.ga))
assert_true(is_proper_subtype(fx.gdyn, fx.gdyn))
assert_false(is_proper_subtype(fx.ga, fx.gdyn))
assert_false(is_proper_subtype(fx.gdyn, fx.ga))
assert_true(is_proper_subtype(fx.t, fx.t))
assert_false(is_proper_subtype(fx.t, fx.s))
assert_true(is_proper_subtype(fx.a, UnionType([fx.a, fx.b])))
assert_true(is_proper_subtype(UnionType([fx.a, fx.b]),
UnionType([fx.a, fx.b, fx.c])))
assert_false(is_proper_subtype(UnionType([fx.a, fx.b]),
UnionType([fx.b, fx.c])))
def make_simplified_union(items: Sequence[Type],
line: int = -1,
column: int = -1,
*,
keep_erased: bool = False,
contract_literals: bool = True) -> ProperType:
"""Build union type with redundant union items removed.
If only a single item remains, this may return a non-union type.
Examples:
* [int, str] -> Union[int, str]
* [int, object] -> object
* [int, int] -> int
* [int, Any] -> Union[int, Any] (Any types are not simplified away!)
* [Any, Any] -> Any
Note: This must NOT be used during semantic analysis, since TypeInfos may not
be fully initialized.
The keep_erased flag is used for type inference against union types
containing type variables. If set to True, keep all ErasedType items.
"""
items = get_proper_types(items)
while any(isinstance(typ, UnionType) for typ in items):
all_items = [] # type: List[ProperType]
for typ in items:
if isinstance(typ, UnionType):
all_items.extend(get_proper_types(typ.items))
else:
all_items.append(typ)
items = all_items
from mypy.subtypes import is_proper_subtype
removed = set() # type: Set[int]
# Avoid slow nested for loop for Union of Literal of strings (issue #9169)
if all((isinstance(item, LiteralType)
and item.fallback.type.fullname == 'builtins.str')
for item in items):
seen = set() # type: Set[str]
for index, item in enumerate(items):
assert isinstance(item, LiteralType)
assert isinstance(item.value, str)
if item.value in seen:
removed.add(index)
seen.add(item.value)
else:
for i, ti in enumerate(items):
if i in removed: continue
# Keep track of the truishness info for deleted subtypes which can be relevant
cbt = cbf = False
for j, tj in enumerate(items):
if i != j and is_proper_subtype(tj, ti, keep_erased_types=keep_erased) and \
is_redundant_literal_instance(ti, tj):
# We found a redundant item in the union.
removed.add(j)
cbt = cbt or tj.can_be_true
cbf = cbf or tj.can_be_false
# if deleted subtypes had more general truthiness, use that
if not ti.can_be_true and cbt:
items[i] = true_or_false(ti)
elif not ti.can_be_false and cbf:
items[i] = true_or_false(ti)
simplified_set = [items[i] for i in range(len(items)) if i not in removed]
# If more than one literal exists in the union, try to simplify
if (contract_literals
and sum(isinstance(item, LiteralType)
for item in simplified_set) > 1):
simplified_set = try_contracting_literals_in_union(simplified_set)
return UnionType.make_union(simplified_set, line, column)
def test_is_proper_subtype(self):
fx = self.fx
assert_true(is_proper_subtype(fx.a, fx.a))
assert_true(is_proper_subtype(fx.b, fx.a))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_false(is_proper_subtype(fx.a, fx.b))
assert_false(is_proper_subtype(fx.o, fx.b))
assert_true(is_proper_subtype(fx.anyt, fx.anyt))
assert_false(is_proper_subtype(fx.a, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, fx.a))
assert_true(is_proper_subtype(fx.ga, fx.ga))
assert_true(is_proper_subtype(fx.gdyn, fx.gdyn))
assert_false(is_proper_subtype(fx.ga, fx.gdyn))
assert_false(is_proper_subtype(fx.gdyn, fx.ga))
assert_true(is_proper_subtype(fx.t, fx.t))
assert_false(is_proper_subtype(fx.t, fx.s))
def test_is_proper_subtype(self) -> None:
fx = self.fx
assert_true(is_proper_subtype(fx.a, fx.a))
assert_true(is_proper_subtype(fx.b, fx.a))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_true(is_proper_subtype(fx.b, fx.o))
assert_false(is_proper_subtype(fx.a, fx.b))
assert_false(is_proper_subtype(fx.o, fx.b))
assert_true(is_proper_subtype(fx.anyt, fx.anyt))
assert_false(is_proper_subtype(fx.a, fx.anyt))
assert_false(is_proper_subtype(fx.anyt, fx.a))
assert_true(is_proper_subtype(fx.ga, fx.ga))
assert_true(is_proper_subtype(fx.gdyn, fx.gdyn))
assert_false(is_proper_subtype(fx.ga, fx.gdyn))
assert_false(is_proper_subtype(fx.gdyn, fx.ga))
assert_true(is_proper_subtype(fx.t, fx.t))
assert_false(is_proper_subtype(fx.t, fx.s))
assert_true(is_proper_subtype(fx.a, UnionType([fx.a, fx.b])))
assert_true(
is_proper_subtype(UnionType([fx.a, fx.b]),
UnionType([fx.a, fx.b, fx.c])))
assert_false(
is_proper_subtype(UnionType([fx.a, fx.b]), UnionType([fx.b,
fx.c])))
def visit_union_type(self, t: UnionType) -> ProperType:
if is_proper_subtype(self.s, t):
return t
else:
return mypy.typeops.make_simplified_union([self.s, t])
def _remove_redundant_union_items(items: List[ProperType],
keep_erased: bool) -> List[ProperType]:
from mypy.subtypes import is_proper_subtype
removed: Set[int] = set()
seen: Set[Tuple[str, ...]] = set()
# NB: having a separate fast path for Union of Literal and slow path for other things
# would arguably be cleaner, however it breaks down when simplifying the Union of two
# different enum types as try_expanding_sum_type_to_union works recursively and will
# trigger intermediate simplifications that would render the fast path useless
for i, item in enumerate(items):
if i in removed:
continue
# Avoid slow nested for loop for Union of Literal of strings/enums (issue #9169)
k = simple_literal_value_key(item)
if k is not None:
if k in seen:
removed.add(i)
continue
# NB: one would naively expect that it would be safe to skip the slow path
# always for literals. One would be sorely mistaken. Indeed, some simplifications
# such as that of None/Optional when strict optional is false, do require that we
# proceed with the slow path. Thankfully, all literals will have the same subtype
# relationship to non-literal types, so we only need to do that walk for the first
# literal, which keeps the fast path fast even in the presence of a mixture of
# literals and other types.
safe_skip = len(seen) > 0
seen.add(k)
if safe_skip:
continue
# Keep track of the truthiness info for deleted subtypes which can be relevant
cbt = cbf = False
for j, tj in enumerate(items):
if (i == j
# avoid further checks if this item was already marked redundant.
or j in removed
# if the current item is a simple literal then this simplification loop can
# safely skip all other simple literals as two literals will only ever be
# subtypes of each other if they are equal, which is already handled above.
# However, if the current item is not a literal, it might plausibly be a
# supertype of other literals in the union, so we must check them again.
# This is an important optimization as is_proper_subtype is pretty expensive.
or (k is not None and is_simple_literal(tj))):
continue
# actual redundancy checks
if (is_redundant_literal_instance(item, tj) # XXX?
and is_proper_subtype(
tj, item, keep_erased_types=keep_erased)):
# We found a redundant item in the union.
removed.add(j)
cbt = cbt or tj.can_be_true
cbf = cbf or tj.can_be_false
# if deleted subtypes had more general truthiness, use that
if not item.can_be_true and cbt:
items[i] = true_or_false(item)
elif not item.can_be_false and cbf:
items[i] = true_or_false(item)
return [items[i] for i in range(len(items)) if i not in removed]
def is_overlapping_types(left: Type,
right: Type,
ignore_promotions: bool = False,
prohibit_none_typevar_overlap: bool = False) -> bool:
"""Can a value of type 'left' also be of type 'right' or vice-versa?
If 'ignore_promotions' is True, we ignore promotions while checking for overlaps.
If 'prohibit_none_typevar_overlap' is True, we disallow None from overlapping with
TypeVars (in both strict-optional and non-strict-optional mode).
"""
def _is_overlapping_types(left: Type, right: Type) -> bool:
'''Encode the kind of overlapping check to perform.
This function mostly exists so we don't have to repeat keyword arguments everywhere.'''
return is_overlapping_types(
left, right,
ignore_promotions=ignore_promotions,
prohibit_none_typevar_overlap=prohibit_none_typevar_overlap)
# We should never encounter this type.
if isinstance(left, PartialType) or isinstance(right, PartialType):
assert False, "Unexpectedly encountered partial type"
# We should also never encounter these types, but it's possible a few
# have snuck through due to unrelated bugs. For now, we handle these
# in the same way we handle 'Any'.
#
# TODO: Replace these with an 'assert False' once we are more confident.
illegal_types = (UnboundType, ErasedType, DeletedType)
if isinstance(left, illegal_types) or isinstance(right, illegal_types):
return True
# 'Any' may or may not be overlapping with the other type
if isinstance(left, AnyType) or isinstance(right, AnyType):
return True
# When running under non-strict optional mode, simplify away types of
# the form 'Union[A, B, C, None]' into just 'Union[A, B, C]'.
if not state.strict_optional:
if isinstance(left, UnionType):
left = UnionType.make_union(left.relevant_items())
if isinstance(right, UnionType):
right = UnionType.make_union(right.relevant_items())
# We check for complete overlaps next as a general-purpose failsafe.
# If this check fails, we start checking to see if there exists a
# *partial* overlap between types.
#
# These checks will also handle the NoneTyp and UninhabitedType cases for us.
if (is_proper_subtype(left, right, ignore_promotions=ignore_promotions)
or is_proper_subtype(right, left, ignore_promotions=ignore_promotions)):
return True
# See the docstring for 'get_possible_variants' for more info on what the
# following lines are doing.
left_possible = get_possible_variants(left)
right_possible = get_possible_variants(right)
# We start by checking multi-variant types like Unions first. We also perform
# the same logic if either type happens to be a TypeVar.
#
# Handling the TypeVars now lets us simulate having them bind to the corresponding
# type -- if we deferred these checks, the "return-early" logic of the other
# checks will prevent us from detecting certain overlaps.
#
# If both types are singleton variants (and are not TypeVars), we've hit the base case:
# we skip these checks to avoid infinitely recursing.
def is_none_typevar_overlap(t1: Type, t2: Type) -> bool:
return isinstance(t1, NoneTyp) and isinstance(t2, TypeVarType)
if prohibit_none_typevar_overlap:
if is_none_typevar_overlap(left, right) or is_none_typevar_overlap(right, left):
return False
if (len(left_possible) > 1 or len(right_possible) > 1
or isinstance(left, TypeVarType) or isinstance(right, TypeVarType)):
for l in left_possible:
for r in right_possible:
if _is_overlapping_types(l, r):
return True
return False
# Now that we've finished handling TypeVars, we're free to end early
# if one one of the types is None and we're running in strict-optional mode.
# (None only overlaps with None in strict-optional mode).
#
# We must perform this check after the TypeVar checks because
# a TypeVar could be bound to None, for example.
if state.strict_optional and isinstance(left, NoneTyp) != isinstance(right, NoneTyp):
return False
# Next, we handle single-variant types that may be inherently partially overlapping:
#
# - TypedDicts
# - Tuples
#
# If we cannot identify a partial overlap and end early, we degrade these two types
# into their 'Instance' fallbacks.
if isinstance(left, TypedDictType) and isinstance(right, TypedDictType):
return are_typed_dicts_overlapping(left, right, ignore_promotions=ignore_promotions)
elif isinstance(left, TypedDictType):
left = left.fallback
elif isinstance(right, TypedDictType):
right = right.fallback
if is_tuple(left) and is_tuple(right):
return are_tuples_overlapping(left, right, ignore_promotions=ignore_promotions)
elif isinstance(left, TupleType):
left = left.fallback
elif isinstance(right, TupleType):
right = right.fallback
# Next, we handle single-variant types that cannot be inherently partially overlapping,
# but do require custom logic to inspect.
#
# As before, we degrade into 'Instance' whenever possible.
if isinstance(left, TypeType) and isinstance(right, TypeType):
# TODO: Can Callable[[...], T] and Type[T] be partially overlapping?
return _is_overlapping_types(left.item, right.item)
if isinstance(left, CallableType) and isinstance(right, CallableType):
return is_callable_compatible(left, right,
is_compat=_is_overlapping_types,
ignore_pos_arg_names=True,
allow_partial_overlap=True)
elif isinstance(left, CallableType):
left = left.fallback
elif isinstance(right, CallableType):
right = right.fallback
if isinstance(left, LiteralType) and isinstance(right, LiteralType):
return left == right
elif isinstance(left, LiteralType):
left = left.fallback
elif isinstance(right, LiteralType):
right = right.fallback
# Finally, we handle the case where left and right are instances.
if isinstance(left, Instance) and isinstance(right, Instance):
if left.type.is_protocol and is_protocol_implementation(right, left):
return True
if right.type.is_protocol and is_protocol_implementation(left, right):
return True
# Two unrelated types cannot be partially overlapping: they're disjoint.
# We don't need to handle promotions because they've already been handled
# by the calls to `is_subtype(...)` up above (and promotable types never
# have any generic arguments we need to recurse on).
if left.type.has_base(right.type.fullname()):
left = map_instance_to_supertype(left, right.type)
elif right.type.has_base(left.type.fullname()):
right = map_instance_to_supertype(right, left.type)
else:
return False
if len(left.args) == len(right.args):
# Note: we don't really care about variance here, since the overlapping check
# is symmetric and since we want to return 'True' even for partial overlaps.
#
# For example, suppose we have two types Wrapper[Parent] and Wrapper[Child].
# It doesn't matter whether Wrapper is covariant or contravariant since
# either way, one of the two types will overlap with the other.
#
# Similarly, if Wrapper was invariant, the two types could still be partially
# overlapping -- what if Wrapper[Parent] happened to contain only instances of
# specifically Child?
#
# Or, to use a more concrete example, List[Union[A, B]] and List[Union[B, C]]
# would be considered partially overlapping since it's possible for both lists
# to contain only instances of B at runtime.
for left_arg, right_arg in zip(left.args, right.args):
if _is_overlapping_types(left_arg, right_arg):
return True
return False
# We ought to have handled every case by now: we conclude the
# two types are not overlapping, either completely or partially.
#
# Note: it's unclear however, whether returning False is the right thing
# to do when inferring reachability -- see https://github.com/python/mypy/issues/5529
assert type(left) != type(right)
return False
