def typed_dict_get_callback(ctx: MethodContext) -> Type:
"""Infer a precise return type for TypedDict.get with literal first argument."""
if (isinstance(ctx.type, TypedDictType)
and len(ctx.arg_types) >= 1
and len(ctx.arg_types[0]) == 1):
key = try_getting_str_literal(ctx.args[0][0], ctx.arg_types[0][0])
if key is None:
return ctx.default_return_type
value_type = ctx.type.items.get(key)
if value_type:
if len(ctx.arg_types) == 1:
return UnionType.make_simplified_union([value_type, NoneTyp()])
elif (len(ctx.arg_types) == 2 and len(ctx.arg_types[1]) == 1
and len(ctx.args[1]) == 1):
default_arg = ctx.args[1][0]
if (isinstance(default_arg, DictExpr) and len(default_arg.items) == 0
and isinstance(value_type, TypedDictType)):
# Special case '{}' as the default for a typed dict type.
return value_type.copy_modified(required_keys=set())
else:
return UnionType.make_simplified_union([value_type, ctx.arg_types[1][0]])
else:
ctx.api.msg.typeddict_key_not_found(ctx.type, key, ctx.context)
return AnyType(TypeOfAny.from_error)
return ctx.default_return_type
def typed_dict_pop_signature_callback(ctx: MethodSigContext) -> CallableType:
"""Try to infer a better signature type for TypedDict.pop.
This is used to get better type context for the second argument that
depends on a TypedDict value type.
"""
signature = ctx.default_signature
str_type = ctx.api.named_generic_type('builtins.str', [])
if (isinstance(ctx.type, TypedDictType)
and len(ctx.args) == 2
and len(ctx.args[0]) == 1
and isinstance(ctx.args[0][0], StrExpr)
and len(signature.arg_types) == 2
and len(signature.variables) == 1
and len(ctx.args[1]) == 1):
key = ctx.args[0][0].value
value_type = ctx.type.items.get(key)
if value_type:
# Tweak the signature to include the value type as context. It's
# only needed for type inference since there's a union with a type
# variable that accepts everything.
tv = TypeVarType(signature.variables[0])
typ = UnionType.make_simplified_union([value_type, tv])
return signature.copy_modified(
arg_types=[str_type, typ],
ret_type=typ)
return signature.copy_modified(arg_types=[str_type, signature.arg_types[1]])
def _autoconvertible_to_cdata(tp: Type, api: 'mypy.plugin.CheckerPluginInterface') -> Type:
"""Get a type that is compatible with all types that can be implicitly converted to the given
CData type.
Examples:
* c_int -> Union[c_int, int]
* c_char_p -> Union[c_char_p, bytes, int, NoneType]
* MyStructure -> MyStructure
"""
allowed_types = []
# If tp is a union, we allow all types that are convertible to at least one of the union
# items. This is not quite correct - strictly speaking, only types convertible to *all* of the
# union items should be allowed. This may be worth changing in the future, but the more
# correct algorithm could be too strict to be useful.
for t in union_items(tp):
# Every type can be converted from itself (obviously).
allowed_types.append(t)
if isinstance(t, Instance):
unboxed = _find_simplecdata_base_arg(t, api)
if unboxed is not None:
# If _SimpleCData appears in tp's (direct or indirect) bases, its type argument
# specifies the type's "unboxed" version, which can always be converted back to
# the original "boxed" type.
allowed_types.append(unboxed)
if t.type.has_base('ctypes._PointerLike'):
# Pointer-like _SimpleCData subclasses can also be converted from
# an int or None.
allowed_types.append(api.named_generic_type('builtins.int', []))
allowed_types.append(NoneTyp())
return UnionType.make_simplified_union(allowed_types)
def typed_dict_get_signature_callback(ctx: MethodSigContext) -> CallableType:
"""Try to infer a better signature type for TypedDict.get.
This is used to get better type context for the second argument that
depends on a TypedDict value type.
"""
signature = ctx.default_signature
if (isinstance(ctx.type, TypedDictType)
and len(ctx.args) == 2
and len(ctx.args[0]) == 1
and isinstance(ctx.args[0][0], StrExpr)
and len(signature.arg_types) == 2
and len(signature.variables) == 1
and len(ctx.args[1]) == 1):
key = ctx.args[0][0].value
value_type = ctx.type.items.get(key)
ret_type = signature.ret_type
if value_type:
default_arg = ctx.args[1][0]
if (isinstance(value_type, TypedDictType)
and isinstance(default_arg, DictExpr)
and len(default_arg.items) == 0):
# Caller has empty dict {} as default for typed dict.
value_type = value_type.copy_modified(required_keys=set())
# Tweak the signature to include the value type as context. It's
# only needed for type inference since there's a union with a type
# variable that accepts everything.
tv = TypeVarType(signature.variables[0])
return signature.copy_modified(
arg_types=[signature.arg_types[0],
UnionType.make_simplified_union([value_type, tv])],
ret_type=ret_type)
return signature
def join_simple(declaration: Type, s: Type, t: Type) -> Type:
"""Return a simple least upper bound given the declared type."""
if isinstance(s, AnyType):
return s
if isinstance(s, NoneTyp) and not isinstance(t, Void):
return t
if isinstance(s, ErasedType):
return t
if is_subtype(s, t):
return t
if is_subtype(t, s):
return s
if isinstance(declaration, UnionType):
return UnionType.make_simplified_union([s, t])
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 meet_simple_away(s: Type, t: Type) -> Type:
if isinstance(s, UnionType):
return UnionType.make_simplified_union([x for x in s.items
if not is_subtype(x, t)])
elif not isinstance(s, AnyType) and is_subtype(s, t):
return Void()
else:
return s
def visit_union_type(self, t: UnionType) -> Type:
if isinstance(self.s, UnionType):
meets = [] # type: List[Type]
for x in t.items:
for y in self.s.items:
meets.append(meet_types(x, y))
else:
meets = [meet_types(x, self.s) for x in t.items]
return UnionType.make_simplified_union(meets)
def visit_none_type(self, t: NoneTyp) -> Type:
if state.strict_optional:
if isinstance(self.s, (NoneTyp, UninhabitedType)):
return t
elif isinstance(self.s, UnboundType):
return AnyType(TypeOfAny.special_form)
else:
return UnionType.make_simplified_union([self.s, t])
else:
return self.s
def restrict_subtype_away(t: Type, s: Type) -> Type:
"""Return a supertype of (t intersect not s)
Currently just remove elements of a union type.
"""
if isinstance(t, UnionType):
new_items = [item for item in t.items if not is_subtype(item, s)]
return UnionType.make_union(new_items)
else:
return t
def visit_none_type(self, t: NoneTyp) -> Type:
if experiments.STRICT_OPTIONAL:
if isinstance(self.s, (NoneTyp, UninhabitedType)):
return t
elif isinstance(self.s, UnboundType):
return AnyType(TypeOfAny.special_form)
else:
return UnionType.make_simplified_union([self.s, t])
else:
return self.s
def generate_type_combinations(types: List[Type]) -> List[Type]:
"""Generate possible combinations of a list of types.
mypy essentially supports two different ways to do this: joining the types
and unioning the types. We try both.
"""
joined_type = join_type_list(types)
union_type = UnionType.make_simplified_union(types)
if is_same_type(joined_type, union_type):
return [joined_type]
else:
return [joined_type, union_type]
def meet_simple(s: Type, t: Type, default_right: bool = True) -> Type:
if s == t:
return s
if isinstance(s, UnionType):
return UnionType.make_simplified_union([meet_types(x, t) for x in s.items])
elif not is_overlapping_types(s, t):
return Void()
else:
if default_right:
return t
else:
return s
def narrow_declared_type(declared: Type, narrowed: Type) -> Type:
"""Return the declared type narrowed down to another type."""
if declared == narrowed:
return declared
if isinstance(declared, UnionType):
return UnionType.make_simplified_union([narrow_declared_type(x, narrowed)
for x in declared.relevant_items()])
elif not is_overlapping_types(declared, narrowed, use_promotions=True):
if experiments.STRICT_OPTIONAL:
return UninhabitedType()
else:
return NoneTyp()
elif isinstance(narrowed, UnionType):
return UnionType.make_simplified_union([narrow_declared_type(declared, x)
for x in narrowed.relevant_items()])
elif isinstance(narrowed, AnyType):
return narrowed
elif isinstance(declared, (Instance, TupleType)):
return meet_types(declared, narrowed)
elif isinstance(declared, TypeType) and isinstance(narrowed, TypeType):
return TypeType.make_normalized(narrow_declared_type(declared.item, narrowed.item))
return narrowed
def narrow_declared_type(declared: Type, narrowed: Type) -> Type:
"""Return the declared type narrowed down to another type."""
if declared == narrowed:
return declared
if isinstance(declared, UnionType):
return UnionType.make_simplified_union([narrow_declared_type(x, narrowed)
for x in declared.relevant_items()])
elif not is_overlapping_types(declared, narrowed,
prohibit_none_typevar_overlap=True):
if state.strict_optional:
return UninhabitedType()
else:
return NoneTyp()
elif isinstance(narrowed, UnionType):
return UnionType.make_simplified_union([narrow_declared_type(declared, x)
for x in narrowed.relevant_items()])
elif isinstance(narrowed, AnyType):
return narrowed
elif isinstance(declared, (Instance, TupleType)):
return meet_types(declared, narrowed)
elif isinstance(declared, TypeType) and isinstance(narrowed, TypeType):
return TypeType.make_normalized(narrow_declared_type(declared.item, narrowed.item))
return narrowed
def meet_simple(s: Type, t: Type, default_right: bool = True) -> Type:
if s == t:
return s
if isinstance(s, UnionType):
return UnionType.make_simplified_union([meet_types(x, t) for x in s.items])
elif not is_overlapping_types(s, t, use_promotions=True):
if experiments.STRICT_OPTIONAL:
return UninhabitedType()
else:
return NoneTyp()
else:
if default_right:
return t
else:
return s
def visit_none_type(self, t: NoneTyp) -> Type:
if experiments.STRICT_OPTIONAL:
if isinstance(self.s, (NoneTyp, UninhabitedType)):
return t
elif isinstance(self.s, UnboundType):
return AnyType()
elif isinstance(self.s, Void) or isinstance(self.s, ErrorType):
return ErrorType()
else:
return UnionType.make_simplified_union([self.s, t])
else:
if not isinstance(self.s, Void):
return self.s
else:
return self.default(self.s)
def array_raw_callback(ctx: 'mypy.plugin.AttributeContext') -> Type:
"""Callback to provide an accurate type for ctypes.Array.raw."""
et = _get_array_element_type(ctx.type)
if et is not None:
types = [] # type: List[Type]
for tp in union_items(et):
if (isinstance(tp, AnyType)
or isinstance(tp, Instance) and tp.type.fullname() == 'ctypes.c_char'):
types.append(_get_bytes_type(ctx.api))
else:
ctx.api.msg.fail(
'ctypes.Array attribute "raw" is only available'
' with element type c_char, not "{}"'
.format(et),
ctx.context)
return UnionType.make_simplified_union(types)
return ctx.default_attr_type
def _autounboxed_cdata(tp: Type) -> Type:
"""Get the auto-unboxed version of a CData type, if applicable.
For *direct* _SimpleCData subclasses, the only type argument of _SimpleCData in the bases list
is returned.
For all other CData types, including indirect _SimpleCData subclasses, tp is returned as-is.
"""
if isinstance(tp, UnionType):
return UnionType.make_simplified_union([_autounboxed_cdata(t) for t in tp.items])
elif isinstance(tp, Instance):
for base in tp.type.bases:
if base.type.fullname() == 'ctypes._SimpleCData':
# If tp has _SimpleCData as a direct base class,
# the auto-unboxed type is the single type argument of the _SimpleCData type.
assert len(base.args) == 1
return base.args[0]
# If tp is not a concrete type, or if there is no _SimpleCData in the bases,
# the type is not auto-unboxed.
return tp
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 typed_dict_pop_callback(ctx: MethodContext) -> Type:
"""Type check and infer a precise return type for TypedDict.pop."""
if (isinstance(ctx.type, TypedDictType)
and len(ctx.arg_types) >= 1
and len(ctx.arg_types[0]) == 1):
key = try_getting_str_literal(ctx.args[0][0], ctx.arg_types[0][0])
if key is None:
ctx.api.fail(message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL, ctx.context)
return AnyType(TypeOfAny.from_error)
if key in ctx.type.required_keys:
ctx.api.msg.typeddict_key_cannot_be_deleted(ctx.type, key, ctx.context)
value_type = ctx.type.items.get(key)
if value_type:
if len(ctx.args[1]) == 0:
return value_type
elif (len(ctx.arg_types) == 2 and len(ctx.arg_types[1]) == 1
and len(ctx.args[1]) == 1):
return UnionType.make_simplified_union([value_type, ctx.arg_types[1][0]])
else:
ctx.api.msg.typeddict_key_not_found(ctx.type, key, ctx.context)
return AnyType(TypeOfAny.from_error)
return ctx.default_return_type
def restrict_subtype_away(t: Type, s: Type) -> Type:
"""Return t minus s.
If we can't determine a precise result, return a supertype of the
ideal result (just t is a valid result).
This is used for type inference of runtime type checks such as
isinstance.
Currently this just removes elements of a union type.
"""
if isinstance(t, UnionType):
# Since runtime type checks will ignore type arguments, erase the types.
erased_s = erase_type(s)
# TODO: Implement more robust support for runtime isinstance() checks,
# see issue #3827
new_items = [item for item in t.relevant_items()
if (not (is_proper_subtype(erase_type(item), erased_s) or
is_proper_subtype(item, erased_s))
or isinstance(item, AnyType))]
return UnionType.make_union(new_items)
else:
return t
def test_literal_type(self) -> None:
a = self.fx.a
lit1 = self.fx.lit1
lit2 = self.fx.lit2
lit3 = self.fx.lit3
self.assert_meet(lit1, lit1, lit1)
self.assert_meet(lit1, a, lit1)
self.assert_meet_uninhabited(lit1, lit3)
self.assert_meet_uninhabited(lit1, lit2)
self.assert_meet(UnionType([lit1, lit2]), lit1, lit1)
self.assert_meet(UnionType([lit1, lit2]), UnionType([lit2, lit3]),
lit2)
self.assert_meet(UnionType([lit1, lit2]), UnionType([lit1, lit2]),
UnionType([lit1, lit2]))
self.assert_meet(lit1, self.fx.anyt, lit1)
self.assert_meet(lit1, self.fx.o, lit1)
assert is_same_type(lit1, narrow_declared_type(lit1, a))
assert is_same_type(lit2, narrow_declared_type(lit2, a))
def test_literal_type(self) -> None:
a = self.fx.a
d = self.fx.d
lit1 = LiteralType(1, a)
lit2 = LiteralType(2, a)
lit3 = LiteralType("foo", d)
self.assert_meet(lit1, lit1, lit1)
self.assert_meet(lit1, a, lit1)
self.assert_meet_uninhabited(lit1, lit3)
self.assert_meet_uninhabited(lit1, lit2)
self.assert_meet(UnionType([lit1, lit2]), lit1, lit1)
self.assert_meet(UnionType([lit1, lit2]), UnionType([lit2, lit3]),
lit2)
self.assert_meet(UnionType([lit1, lit2]), UnionType([lit1, lit2]),
UnionType([lit1, lit2]))
self.assert_meet(lit1, self.fx.anyt, lit1)
self.assert_meet(lit1, self.fx.o, lit1)
assert_true(is_same_type(lit1, narrow_declared_type(lit1, a)))
assert_true(is_same_type(lit2, narrow_declared_type(lit2, a)))
def visit_union_type(self, t: UnionType) -> Type:
# After substituting for type variables in t.items,
# some of the resulting types might be subtypes of others.
return UnionType.make_simplified_union(self.expand_types(t.items), t.line)
def object(self,
ctx: AnalyzeTypeContext,
schema: Dict[str, Any],
outer: bool = False,
**kwargs) -> Type:
"""Generate an annotation for an object, usually a TypedDict."""
properties = schema.get('properties')
pattern_properties = schema.get('patternProperties')
if pattern_properties is not None:
if properties is not None:
raise NotImplementedError(
'using `properties` in combination with `patternProperties`'
' is not supported')
# If we have pattern properties, we want Dict[str, Union[...]]
# where ... is the types of all patternProperties subschemas
return named_builtin_type(
ctx,
'dict',
[
named_builtin_type(ctx, 'str'),
UnionType([
self.get_type(ctx, subschema)
for subschema in pattern_properties.values()
]),
],
)
if properties is None:
return named_builtin_type(ctx, 'dict')
try:
fallback = ctx.api.named_type('mypy_extensions._TypedDict', [])
except AssertionError:
fallback = named_builtin_type(ctx, 'dict', [])
items, types = zip(*filter(
lambda o: o[1] is not None,
[
(prop, self.get_type(ctx, subschema))
for prop, subschema in properties.items() if prop not in
['default', 'const'] # These are reserved names,
# not properties.
]))
required_keys = set(schema.get('required', []))
if outer:
# We want to name the outer Type, so that we can support nested
# references. Note that this may not be fully supported in mypy
# at this time.
info = self._build_typeddict_typeinfo(ctx, self.outer_name,
list(items), list(types),
required_keys)
instance = Instance(info, [])
td = info.typeddict_type
typing_type = td.copy_modified(item_types=list(td.items.values()),
fallback=instance)
# # Resolve any forward (nested) references to this Type.
# if self.forward_refs:
#
# for fw in self.forward_refs:
# fw.resolve(typing_type)
return typing_type
struct = OrderedDict(zip(items, types))
return TypedDictType(struct, required_keys, fallback)
def anyOf(self, ctx: AnalyzeTypeContext, subschema: List, **kwargs):
"""Generate a ``Union`` annotation with the allowed types."""
return UnionType(list(filter(lambda o: o is not None,
[self.get_type(ctx, subs)
for subs in subschema])))
def integer(self, ctx: AnalyzeTypeContext, *args, **kwargs) -> UnionType:
"""Generate a ``Union`` annotation for an integer."""
return UnionType([named_builtin_type(ctx, 'int'),
named_builtin_type(ctx, 'float')])
def visit_unbound_type(self, t: UnboundType) -> Type:
if t.optional:
t.optional = False
# We don't need to worry about double-wrapping Optionals or
# wrapping Anys: Union simplification will take care of that.
return UnionType.make_simplified_union([self.visit_unbound_type(t), NoneTyp()])
sym = self.lookup(t.name, t)
if sym is not None:
if sym.node is None:
# UNBOUND_IMPORTED can happen if an unknown name was imported.
if sym.kind != UNBOUND_IMPORTED:
self.fail('Internal error (node is None, kind={})'.format(sym.kind), t)
return AnyType()
fullname = sym.node.fullname()
if sym.kind == BOUND_TVAR:
if len(t.args) > 0:
self.fail('Type variable "{}" used with arguments'.format(
t.name), t)
assert sym.tvar_def is not None
return TypeVarType(sym.tvar_def, t.line)
elif fullname == 'builtins.None':
if experiments.STRICT_OPTIONAL:
return NoneTyp(is_ret_type=t.is_ret_type)
else:
return Void()
elif fullname == 'typing.Any':
return AnyType()
elif fullname == 'typing.Tuple':
if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
# Tuple[T, ...] (uniform, variable-length tuple)
node = self.lookup_fqn_func('builtins.tuple')
tuple_info = cast(TypeInfo, node.node)
return Instance(tuple_info, [t.args[0].accept(self)], t.line)
return self.tuple_type(self.anal_array(t.args))
elif fullname == 'typing.Union':
items = self.anal_array(t.args)
items = [item for item in items if not isinstance(item, Void)]
return UnionType.make_union(items)
elif fullname == 'typing.Optional':
if len(t.args) != 1:
self.fail('Optional[...] must have exactly one type argument', t)
return AnyType()
items = self.anal_array(t.args)
if experiments.STRICT_OPTIONAL:
return UnionType.make_simplified_union([items[0], NoneTyp()])
else:
# Without strict Optional checking Optional[t] is just an alias for t.
return items[0]
elif fullname == 'typing.Callable':
return self.analyze_callable_type(t)
elif fullname == 'typing.Type':
if len(t.args) == 0:
return TypeType(AnyType(), line=t.line)
if len(t.args) != 1:
self.fail('Type[...] must have exactly one type argument', t)
items = self.anal_array(t.args)
item = items[0]
return TypeType(item, line=t.line)
elif sym.kind == TYPE_ALIAS:
# TODO: Generic type aliases.
return sym.type_override
elif not isinstance(sym.node, TypeInfo):
name = sym.fullname
if name is None:
name = sym.node.name()
if isinstance(sym.node, Var) and isinstance(sym.node.type, AnyType):
# Something with an Any type -- make it an alias for Any in a type
# context. This is slightly problematic as it allows using the type 'Any'
# as a base class -- however, this will fail soon at runtime so the problem
# is pretty minor.
return AnyType()
self.fail('Invalid type "{}"'.format(name), t)
return t
info = sym.node # type: TypeInfo
if len(t.args) > 0 and info.fullname() == 'builtins.tuple':
return TupleType(self.anal_array(t.args),
Instance(info, [AnyType()], t.line),
t.line)
else:
# Analyze arguments and construct Instance type. The
# number of type arguments and their values are
# checked only later, since we do not always know the
# valid count at this point. Thus we may construct an
# Instance with an invalid number of type arguments.
instance = Instance(info, self.anal_array(t.args), t.line)
tup = info.tuple_type
if tup is None:
return instance
else:
# The class has a Tuple[...] base class so it will be
# represented as a tuple type.
if t.args:
self.fail('Generic tuple types not supported', t)
return AnyType()
return tup.copy_modified(items=self.anal_array(tup.items),
fallback=instance)
else:
return AnyType()
def visit_union_type(self, t: UnionType) -> Type:
if is_subtype(self.s, t):
return t
else:
return UnionType.make_simplified_union([self.s, t])
def analyze_descriptor_access(instance_type: Type,
descriptor_type: Type,
builtin_type: Callable[[str], Instance],
msg: MessageBuilder,
context: Context, *,
chk: 'mypy.checker.TypeChecker') -> Type:
"""Type check descriptor access.
Arguments:
instance_type: The type of the instance on which the descriptor
attribute is being accessed (the type of ``a`` in ``a.f`` when
``f`` is a descriptor).
descriptor_type: The type of the descriptor attribute being accessed
(the type of ``f`` in ``a.f`` when ``f`` is a descriptor).
context: The node defining the context of this inference.
Return:
The return type of the appropriate ``__get__`` overload for the descriptor.
"""
if isinstance(descriptor_type, UnionType):
# Map the access over union types
return UnionType.make_simplified_union([
analyze_descriptor_access(instance_type, typ, builtin_type,
msg, context, chk=chk)
for typ in descriptor_type.items
])
elif not isinstance(descriptor_type, Instance):
return descriptor_type
if not descriptor_type.type.has_readable_member('__get__'):
return descriptor_type
dunder_get = descriptor_type.type.get_method('__get__')
if dunder_get is None:
msg.fail(message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(descriptor_type), context)
return AnyType(TypeOfAny.from_error)
function = function_type(dunder_get, builtin_type('builtins.function'))
bound_method = bind_self(function, descriptor_type)
typ = map_instance_to_supertype(descriptor_type, dunder_get.info)
dunder_get_type = expand_type_by_instance(bound_method, typ)
if isinstance(instance_type, FunctionLike) and instance_type.is_type_obj():
owner_type = instance_type.items()[0].ret_type
instance_type = NoneTyp()
elif isinstance(instance_type, TypeType):
owner_type = instance_type.item
instance_type = NoneTyp()
else:
owner_type = instance_type
_, inferred_dunder_get_type = chk.expr_checker.check_call(
dunder_get_type,
[TempNode(instance_type), TempNode(TypeType.make_normalized(owner_type))],
[ARG_POS, ARG_POS], context)
if isinstance(inferred_dunder_get_type, AnyType):
# check_call failed, and will have reported an error
return inferred_dunder_get_type
if not isinstance(inferred_dunder_get_type, CallableType):
msg.fail(message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(descriptor_type), context)
return AnyType(TypeOfAny.from_error)
return inferred_dunder_get_type.ret_type
def _scan_declarative_decorator_stmt(
cls: ClassDef,
api: SemanticAnalyzerPluginInterface,
stmt: Decorator,
cls_metadata: util.DeclClassApplied,
) -> None:
"""Extract mapping information from a @declared_attr in a declarative
class.
E.g.::
@reg.mapped
class MyClass:
# ...
@declared_attr
def updated_at(cls) -> Column[DateTime]:
return Column(DateTime)
Will resolve in mypy as::
@reg.mapped
class MyClass:
# ...
updated_at: Mapped[Optional[datetime.datetime]]
"""
for dec in stmt.decorators:
if (
isinstance(dec, (NameExpr, MemberExpr, SymbolNode))
and names._type_id_for_named_node(dec) is names.DECLARED_ATTR
):
break
else:
return
dec_index = cls.defs.body.index(stmt)
left_hand_explicit_type: Optional[ProperType] = None
if isinstance(stmt.func.type, CallableType):
func_type = stmt.func.type.ret_type
if isinstance(func_type, UnboundType):
type_id = names._type_id_for_unbound_type(func_type, cls, api)
else:
# this does not seem to occur unless the type argument is
# incorrect
return
if (
type_id
in {
names.MAPPED,
names.RELATIONSHIP,
names.COMPOSITE_PROPERTY,
names.MAPPER_PROPERTY,
names.SYNONYM_PROPERTY,
names.COLUMN_PROPERTY,
}
and func_type.args
):
left_hand_explicit_type = get_proper_type(func_type.args[0])
elif type_id is names.COLUMN and func_type.args:
typeengine_arg = func_type.args[0]
if isinstance(typeengine_arg, UnboundType):
sym = api.lookup_qualified(typeengine_arg.name, typeengine_arg)
if sym is not None and isinstance(sym.node, TypeInfo):
if names._has_base_type_id(sym.node, names.TYPEENGINE):
left_hand_explicit_type = UnionType(
[
infer._extract_python_type_from_typeengine(
api, sym.node, []
),
NoneType(),
]
)
else:
util.fail(
api,
"Column type should be a TypeEngine "
"subclass not '{}'".format(sym.node.fullname),
func_type,
)
if left_hand_explicit_type is None:
# no type on the decorated function. our option here is to
# dig into the function body and get the return type, but they
# should just have an annotation.
msg = (
"Can't infer type from @declared_attr on function '{}'; "
"please specify a return type from this function that is "
"one of: Mapped[<python type>], relationship[<target class>], "
"Column[<TypeEngine>], MapperProperty[<python type>]"
)
util.fail(api, msg.format(stmt.var.name), stmt)
left_hand_explicit_type = AnyType(TypeOfAny.special_form)
left_node = NameExpr(stmt.var.name)
left_node.node = stmt.var
# totally feeling around in the dark here as I don't totally understand
# the significance of UnboundType. It seems to be something that is
# not going to do what's expected when it is applied as the type of
# an AssignmentStatement. So do a feeling-around-in-the-dark version
# of converting it to the regular Instance/TypeInfo/UnionType structures
# we see everywhere else.
if isinstance(left_hand_explicit_type, UnboundType):
left_hand_explicit_type = get_proper_type(
util._unbound_to_instance(api, left_hand_explicit_type)
)
left_node.node.type = api.named_type(
"__sa_Mapped", [left_hand_explicit_type]
)
# this will ignore the rvalue entirely
# rvalue = TempNode(AnyType(TypeOfAny.special_form))
# rewrite the node as:
# <attr> : Mapped[<typ>] =
# _sa_Mapped._empty_constructor(lambda: <function body>)
# the function body is maintained so it gets type checked internally
column_descriptor = nodes.NameExpr("__sa_Mapped")
column_descriptor.fullname = "sqlalchemy.orm.attributes.Mapped"
mm = nodes.MemberExpr(column_descriptor, "_empty_constructor")
arg = nodes.LambdaExpr(stmt.func.arguments, stmt.func.body)
rvalue = CallExpr(
mm,
[arg],
[nodes.ARG_POS],
["arg1"],
)
new_stmt = AssignmentStmt([left_node], rvalue)
new_stmt.type = left_node.node.type
cls_metadata.mapped_attr_names.append(
(left_node.name, left_hand_explicit_type)
)
cls.defs.body[dec_index] = new_stmt
def visit_union_type(self, t: UnionType) -> Type:
return UnionType(self.anal_array(t.items), t.line)
def analyze_descriptor_access(instance_type: Type, descriptor_type: Type,
builtin_type: Callable[[str], Instance],
msg: MessageBuilder, context: Context, *,
chk: 'mypy.checker.TypeChecker') -> Type:
"""Type check descriptor access.
Arguments:
instance_type: The type of the instance on which the descriptor
attribute is being accessed (the type of ``a`` in ``a.f`` when
``f`` is a descriptor).
descriptor_type: The type of the descriptor attribute being accessed
(the type of ``f`` in ``a.f`` when ``f`` is a descriptor).
context: The node defining the context of this inference.
Return:
The return type of the appropriate ``__get__`` overload for the descriptor.
"""
if isinstance(descriptor_type, UnionType):
# Map the access over union types
return UnionType.make_simplified_union([
analyze_descriptor_access(instance_type,
typ,
builtin_type,
msg,
context,
chk=chk) for typ in descriptor_type.items
])
elif not isinstance(descriptor_type, Instance):
return descriptor_type
if not descriptor_type.type.has_readable_member('__get__'):
return descriptor_type
dunder_get = descriptor_type.type.get_method('__get__')
if dunder_get is None:
msg.fail(
message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(
descriptor_type), context)
return AnyType(TypeOfAny.from_error)
function = function_type(dunder_get, builtin_type('builtins.function'))
bound_method = bind_self(function, descriptor_type)
typ = map_instance_to_supertype(descriptor_type, dunder_get.info)
dunder_get_type = expand_type_by_instance(bound_method, typ)
if isinstance(instance_type, FunctionLike) and instance_type.is_type_obj():
owner_type = instance_type.items()[0].ret_type
instance_type = NoneTyp()
elif isinstance(instance_type, TypeType):
owner_type = instance_type.item
instance_type = NoneTyp()
else:
owner_type = instance_type
_, inferred_dunder_get_type = chk.expr_checker.check_call(
dunder_get_type, [
TempNode(instance_type),
TempNode(TypeType.make_normalized(owner_type))
], [ARG_POS, ARG_POS], context)
if isinstance(inferred_dunder_get_type, AnyType):
# check_call failed, and will have reported an error
return inferred_dunder_get_type
if not isinstance(inferred_dunder_get_type, CallableType):
msg.fail(
message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(
descriptor_type), context)
return AnyType(TypeOfAny.from_error)
return inferred_dunder_get_type.ret_type
def analyze_member_access(name: str,
typ: Type,
node: Context,
is_lvalue: bool,
is_super: bool,
is_operator: bool,
builtin_type: Callable[[str], Instance],
not_ready_callback: Callable[[str, Context], None],
msg: MessageBuilder,
*,
original_type: Type,
override_info: TypeInfo = None,
chk: 'mypy.checker.TypeChecker' = None) -> Type:
"""Return the type of attribute `name` of typ.
This is a general operation that supports various different variations:
1. lvalue or non-lvalue access (i.e. setter or getter access)
2. supertype access (when using super(); is_super == True and
override_info should refer to the supertype)
original_type is the most precise inferred or declared type of the base object
that we have available. typ is generally a supertype of original_type.
When looking for an attribute of typ, we may perform recursive calls targeting
the fallback type, for example.
original_type is always the type used in the initial call.
"""
if isinstance(typ, Instance):
if name == '__init__' and not is_super:
# Accessing __init__ in statically typed code would compromise
# type safety unless used via super().
msg.fail(messages.CANNOT_ACCESS_INIT, node)
return AnyType()
# The base object has an instance type.
info = typ.type
if override_info:
info = override_info
if (experiments.find_occurrences
and info.name() == experiments.find_occurrences[0]
and name == experiments.find_occurrences[1]):
msg.note(
"Occurrence of '{}.{}'".format(*experiments.find_occurrences),
node)
# Look up the member. First look up the method dictionary.
method = info.get_method(name)
if method:
if method.is_property:
assert isinstance(method, OverloadedFuncDef)
return analyze_var(name, method.items[0].var, typ, info, node,
is_lvalue, msg, original_type,
not_ready_callback)
if is_lvalue:
msg.cant_assign_to_method(node)
signature = function_type(method,
builtin_type('builtins.function'))
signature = freshen_function_type_vars(signature)
if name == '__new__':
# __new__ is special and behaves like a static method -- don't strip
# the first argument.
pass
else:
signature = bind_self(signature, original_type)
typ = map_instance_to_supertype(typ, method.info)
member_type = expand_type_by_instance(signature, typ)
freeze_type_vars(member_type)
return member_type
else:
# Not a method.
return analyze_member_var_access(name,
typ,
info,
node,
is_lvalue,
is_super,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
elif isinstance(typ, AnyType):
# The base object has dynamic type.
return AnyType()
elif isinstance(typ, NoneTyp):
if chk and chk.should_suppress_optional_error([typ]):
return AnyType()
# The only attribute NoneType has are those it inherits from object
return analyze_member_access(name,
builtin_type('builtins.object'),
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
elif isinstance(typ, UnionType):
# The base object has dynamic type.
msg.disable_type_names += 1
results = [
analyze_member_access(name,
subtype,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk) for subtype in typ.items
]
msg.disable_type_names -= 1
return UnionType.make_simplified_union(results)
elif isinstance(typ, TupleType):
# Actually look up from the fallback instance type.
return analyze_member_access(name,
typ.fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
elif isinstance(typ, TypedDictType):
# Actually look up from the fallback instance type.
return analyze_member_access(name,
typ.fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
elif isinstance(typ, FunctionLike) and typ.is_type_obj():
# Class attribute.
# TODO super?
ret_type = typ.items()[0].ret_type
if isinstance(ret_type, TupleType):
ret_type = ret_type.fallback
if isinstance(ret_type, Instance):
if not is_operator:
# When Python sees an operator (eg `3 == 4`), it automatically translates that
# into something like `int.__eq__(3, 4)` instead of `(3).__eq__(4)` as an
# optimization.
#
# While it normally it doesn't matter which of the two versions are used, it
# does cause inconsistencies when working with classes. For example, translating
# `int == int` to `int.__eq__(int)` would not work since `int.__eq__` is meant to
# compare two int _instances_. What we really want is `type(int).__eq__`, which
# is meant to compare two types or classes.
#
# This check makes sure that when we encounter an operator, we skip looking up
# the corresponding method in the current instance to avoid this edge case.
# See https://github.com/python/mypy/pull/1787 for more info.
result = analyze_class_attribute_access(
ret_type,
name,
node,
is_lvalue,
builtin_type,
not_ready_callback,
msg,
original_type=original_type)
if result:
return result
# Look up from the 'type' type.
return analyze_member_access(name,
typ.fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
else:
assert False, 'Unexpected type {}'.format(repr(ret_type))
elif isinstance(typ, FunctionLike):
# Look up from the 'function' type.
return analyze_member_access(name,
typ.fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
elif isinstance(typ, TypeVarType):
return analyze_member_access(name,
typ.upper_bound,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
elif isinstance(typ, DeletedType):
msg.deleted_as_rvalue(typ, node)
return AnyType()
elif isinstance(typ, TypeType):
# Similar to FunctionLike + is_type_obj() above.
item = None
if isinstance(typ.item, Instance):
item = typ.item
elif isinstance(typ.item, TypeVarType):
if isinstance(typ.item.upper_bound, Instance):
item = typ.item.upper_bound
if item and not is_operator:
# See comment above for why operators are skipped
result = analyze_class_attribute_access(
item,
name,
node,
is_lvalue,
builtin_type,
not_ready_callback,
msg,
original_type=original_type)
if result:
return result
fallback = builtin_type('builtins.type')
if item is not None:
fallback = item.type.metaclass_type or fallback
return analyze_member_access(name,
fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
original_type=original_type,
chk=chk)
if chk and chk.should_suppress_optional_error([typ]):
return AnyType()
return msg.has_no_attr(original_type, name, node)
def visit_file(self, file: MypyFile, fnam: str, mod_id: str,
options: Options) -> None:
"""Perform the first analysis pass.
Populate module global table. Resolve the full names of
definitions not nested within functions and construct type
info structures, but do not resolve inter-definition
references such as base classes.
Also add implicit definitions such as __name__.
In this phase we don't resolve imports. For 'from ... import',
we generate dummy symbol table nodes for the imported names,
and these will get resolved in later phases of semantic
analysis.
"""
sem = self.sem
self.sem.options = options # Needed because we sometimes call into it
self.pyversion = options.python_version
self.platform = options.platform
sem.cur_mod_id = mod_id
sem.cur_mod_node = file
sem.errors.set_file(fnam, mod_id, scope=sem.scope)
sem.globals = SymbolTable()
sem.global_decls = [set()]
sem.nonlocal_decls = [set()]
sem.block_depth = [0]
sem.scope.enter_file(mod_id)
defs = file.defs
with experiments.strict_optional_set(options.strict_optional):
# Add implicit definitions of module '__name__' etc.
for name, t in implicit_module_attrs.items():
# unicode docstrings should be accepted in Python 2
if name == '__doc__':
if self.pyversion >= (3, 0):
typ = UnboundType('__builtins__.str') # type: Type
else:
typ = UnionType([
UnboundType('__builtins__.str'),
UnboundType('__builtins__.unicode')
])
else:
assert t is not None, 'type should be specified for {}'.format(
name)
typ = UnboundType(t)
v = Var(name, typ)
v._fullname = self.sem.qualified_name(name)
self.sem.globals[name] = SymbolTableNode(GDEF, v)
for d in defs:
d.accept(self)
# Add implicit definition of literals/keywords to builtins, as we
# cannot define a variable with them explicitly.
if mod_id == 'builtins':
literal_types = [
('None', NoneTyp()),
# reveal_type is a mypy-only function that gives an error with
# the type of its arg.
('reveal_type', AnyType(TypeOfAny.special_form)),
# reveal_locals is a mypy-only function that gives an error with the types of
# locals
('reveal_locals', AnyType(TypeOfAny.special_form)),
] # type: List[Tuple[str, Type]]
# TODO(ddfisher): This guard is only needed because mypy defines
# fake builtins for its tests which often don't define bool. If
# mypy is fast enough that we no longer need those, this
# conditional check should be removed.
if 'bool' in self.sem.globals:
bool_type = self.sem.named_type('bool')
literal_types.extend([
('True', bool_type),
('False', bool_type),
('__debug__', bool_type),
])
else:
# We are running tests without 'bool' in builtins.
# TODO: Find a permanent solution to this problem.
# Maybe add 'bool' to all fixtures?
literal_types.append(
('True', AnyType(TypeOfAny.special_form)))
for name, typ in literal_types:
v = Var(name, typ)
v._fullname = self.sem.qualified_name(name)
self.sem.globals[name] = SymbolTableNode(GDEF, v)
del self.sem.options
sem.scope.leave()
def analyze_union_member_access(name: str, typ: UnionType, mx: MemberContext) -> Type:
mx.msg.disable_type_names += 1
results = [_analyze_member_access(name, subtype, mx)
for subtype in typ.relevant_items()]
mx.msg.disable_type_names -= 1
return UnionType.make_simplified_union(results)
def visit_union_type(self, t: UnionType) -> Type:
if is_subtype(self.s, t):
return t
else:
return UnionType(t.items + [self.s])
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 simplify_union(t: Type) -> Type:
if isinstance(t, UnionType):
return UnionType.make_simplified_union(t.items)
return t
def argument(self, ctx: 'mypy.plugin.ClassDefContext') -> Argument:
"""Return this attribute as an argument to __init__."""
assert self.init
init_type = self.init_type or self.info[self.name].type
if self.converter.name:
# When a converter is set the init_type is overridden by the first argument
# of the converter method.
converter = lookup_qualified_stnode(ctx.api.modules, self.converter.name, True)
if not converter:
# The converter may be a local variable. Check there too.
converter = ctx.api.lookup_qualified(self.converter.name, self.info, True)
# Get the type of the converter.
converter_type = None # type: Optional[Type]
if converter and isinstance(converter.node, TypeInfo):
from mypy.checkmember import type_object_type # To avoid import cycle.
converter_type = type_object_type(converter.node, ctx.api.builtin_type)
elif converter and isinstance(converter.node, OverloadedFuncDef):
converter_type = converter.node.type
elif converter and converter.type:
converter_type = converter.type
init_type = None
converter_type = get_proper_type(converter_type)
if isinstance(converter_type, CallableType) and converter_type.arg_types:
init_type = ctx.api.anal_type(converter_type.arg_types[0])
elif isinstance(converter_type, Overloaded):
types = [] # type: List[Type]
for item in converter_type.items():
# Walk the overloads looking for methods that can accept one argument.
num_arg_types = len(item.arg_types)
if not num_arg_types:
continue
if num_arg_types > 1 and any(kind == ARG_POS for kind in item.arg_kinds[1:]):
continue
types.append(item.arg_types[0])
# Make a union of all the valid types.
if types:
args = make_simplified_union(types)
init_type = ctx.api.anal_type(args)
if self.converter.is_attr_converters_optional and init_type:
# If the converter was attr.converter.optional(type) then add None to
# the allowed init_type.
init_type = UnionType.make_union([init_type, NoneType()])
if not init_type:
ctx.api.fail("Cannot determine __init__ type from converter", self.context)
init_type = AnyType(TypeOfAny.from_error)
elif self.converter.name == '':
# This means we had a converter but it's not of a type we can infer.
# Error was shown in _get_converter_name
init_type = AnyType(TypeOfAny.from_error)
if init_type is None:
if ctx.api.options.disallow_untyped_defs:
# This is a compromise. If you don't have a type here then the
# __init__ will be untyped. But since the __init__ is added it's
# pointing at the decorator. So instead we also show the error in the
# assignment, which is where you would fix the issue.
node = self.info[self.name].node
assert node is not None
ctx.api.msg.need_annotation_for_var(node, self.context)
# Convert type not set to Any.
init_type = AnyType(TypeOfAny.unannotated)
if self.kw_only:
arg_kind = ARG_NAMED_OPT if self.has_default else ARG_NAMED
else:
arg_kind = ARG_OPT if self.has_default else ARG_POS
# Attrs removes leading underscores when creating the __init__ arguments.
return Argument(Var(self.name.lstrip("_"), init_type), init_type,
None,
arg_kind)
def _scan_symbol_table_entry(
cls: ClassDef,
api: SemanticAnalyzerPluginInterface,
name: str,
value: SymbolTableNode,
cls_metadata: util.DeclClassApplied,
) -> None:
"""Extract mapping information from a SymbolTableNode that's in the
type.names dictionary.
"""
value_type = get_proper_type(value.type)
if not isinstance(value_type, Instance):
return
left_hand_explicit_type = None
type_id = names._type_id_for_named_node(value_type.type)
# type_id = names._type_id_for_unbound_type(value.type.type, cls, api)
err = False
# TODO: this is nearly the same logic as that of
# _scan_declarative_decorator_stmt, likely can be merged
if type_id in {
names.MAPPED,
names.RELATIONSHIP,
names.COMPOSITE_PROPERTY,
names.MAPPER_PROPERTY,
names.SYNONYM_PROPERTY,
names.COLUMN_PROPERTY,
}:
if value_type.args:
left_hand_explicit_type = get_proper_type(value_type.args[0])
else:
err = True
elif type_id is names.COLUMN:
if not value_type.args:
err = True
else:
typeengine_arg: Union[ProperType, TypeInfo] = get_proper_type(
value_type.args[0]
)
if isinstance(typeengine_arg, Instance):
typeengine_arg = typeengine_arg.type
if isinstance(typeengine_arg, (UnboundType, TypeInfo)):
sym = api.lookup_qualified(typeengine_arg.name, typeengine_arg)
if sym is not None and isinstance(sym.node, TypeInfo):
if names._has_base_type_id(sym.node, names.TYPEENGINE):
left_hand_explicit_type = UnionType(
[
infer._extract_python_type_from_typeengine(
api, sym.node, []
),
NoneType(),
]
)
else:
util.fail(
api,
"Column type should be a TypeEngine "
"subclass not '{}'".format(sym.node.fullname),
value_type,
)
if err:
msg = (
"Can't infer type from attribute {} on class {}. "
"please specify a return type from this function that is "
"one of: Mapped[<python type>], relationship[<target class>], "
"Column[<TypeEngine>], MapperProperty[<python type>]"
)
util.fail(api, msg.format(name, cls.name), cls)
left_hand_explicit_type = AnyType(TypeOfAny.special_form)
if left_hand_explicit_type is not None:
cls_metadata.mapped_attr_names.append((name, left_hand_explicit_type))
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 test_literal_type(self) -> None:
a = self.fx.a
d = self.fx.d
lit1 = LiteralType(1, a)
lit2 = LiteralType(2, a)
lit3 = LiteralType("foo", d)
self.assert_join(lit1, lit1, lit1)
self.assert_join(lit1, a, a)
self.assert_join(lit1, d, self.fx.o)
self.assert_join(lit1, lit2, a)
self.assert_join(lit1, lit3, self.fx.o)
self.assert_join(lit1, self.fx.anyt, self.fx.anyt)
self.assert_join(UnionType([lit1, lit2]), lit2, UnionType([lit1,
lit2]))
self.assert_join(UnionType([lit1, lit2]), a, a)
self.assert_join(UnionType([lit1, lit3]), a, UnionType([a, lit3]))
self.assert_join(UnionType([d, lit3]), lit3, d)
self.assert_join(UnionType([d, lit3]), d, UnionType([d, lit3]))
self.assert_join(UnionType([a, lit1]), lit1, a)
self.assert_join(UnionType([a, lit1]), lit2, a)
self.assert_join(UnionType([lit1, lit2]), UnionType([lit1, lit2]),
UnionType([lit1, lit2]))
# The order in which we try joining two unions influences the
# ordering of the items in the final produced unions. So, we
# manually call 'assert_simple_join' and tune the output
# after swapping the arguments here.
self.assert_simple_join(UnionType([lit1, lit2]),
UnionType([lit2, lit3]),
UnionType([lit1, lit2, lit3]))
self.assert_simple_join(UnionType([lit2, lit3]),
UnionType([lit1, lit2]),
UnionType([lit2, lit3, lit1]))
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
def assign_type(self, expr: Expression,
type: Type,
declared_type: Optional[Type],
restrict_any: bool = False) -> None:
# We should erase last known value in binder, because if we are using it,
# it means that the target is not final, and therefore can't hold a literal.
type = remove_instance_last_known_values(type)
type = get_proper_type(type)
declared_type = get_proper_type(declared_type)
if self.type_assignments is not None:
# We are in a multiassign from union, defer the actual binding,
# just collect the types.
self.type_assignments[expr].append((type, declared_type))
return
if not isinstance(expr, (IndexExpr, MemberExpr, NameExpr)):
return None
if not literal(expr):
return
self.invalidate_dependencies(expr)
if declared_type is None:
# Not sure why this happens. It seems to mainly happen in
# member initialization.
return
if not is_subtype(type, declared_type):
# Pretty sure this is only happens when there's a type error.
# Ideally this function wouldn't be called if the
# expression has a type error, though -- do other kinds of
# errors cause this function to get called at invalid
# times?
return
enclosing_type = get_proper_type(self.most_recent_enclosing_type(expr, type))
if isinstance(enclosing_type, AnyType) and not restrict_any:
# If x is Any and y is int, after x = y we do not infer that x is int.
# This could be changed.
# Instead, since we narrowed type from Any in a recent frame (probably an
# isinstance check), but now it is reassigned, we broaden back
# to Any (which is the most recent enclosing type)
self.put(expr, enclosing_type)
# As a special case, when assigning Any to a variable with a
# declared Optional type that has been narrowed to None,
# replace all the Nones in the declared Union type with Any.
# This overrides the normal behavior of ignoring Any assignments to variables
# in order to prevent false positives.
# (See discussion in #3526)
elif (isinstance(type, AnyType)
and isinstance(declared_type, UnionType)
and any(isinstance(item, NoneType) for item in declared_type.items)
and isinstance(get_proper_type(self.most_recent_enclosing_type(expr, NoneType())),
NoneType)):
# Replace any Nones in the union type with Any
new_items = [type if isinstance(item, NoneType) else item
for item in declared_type.items]
self.put(expr, UnionType(new_items))
elif (isinstance(type, AnyType)
and not (isinstance(declared_type, UnionType)
and any(isinstance(item, AnyType) for item in declared_type.items))):
# Assigning an Any value doesn't affect the type to avoid false negatives, unless
# there is an Any item in a declared union type.
self.put(expr, declared_type)
else:
self.put(expr, type)
for i in self.try_frames:
# XXX This should probably not copy the entire frame, but
# just copy this variable into a single stored frame.
self.allow_jump(i)
def visit_union_type(self, t: UnionType) -> Type:
# After substituting for type variables in t.items,
# some of the resulting types might be subtypes of others.
return UnionType.make_simplified_union(self.expand_types(t.items), t.line, t.column)
def analyze_member_access(
name: str,
typ: Type,
node: Context,
is_lvalue: bool,
is_super: bool,
is_operator: bool,
builtin_type: Callable[[str], Instance],
not_ready_callback: Callable[[str, Context], None],
msg: MessageBuilder,
override_info: TypeInfo = None,
report_type: Type = None,
chk: "mypy.checker.TypeChecker" = None,
) -> Type:
"""Analyse attribute access.
This is a general operation that supports various different variations:
1. lvalue or non-lvalue access (i.e. setter or getter access)
2. supertype access (when using super(); is_super == True and
override_info should refer to the supertype)
"""
report_type = report_type or typ
if isinstance(typ, Instance):
if name == "__init__" and not is_super:
# Accessing __init__ in statically typed code would compromise
# type safety unless used via super().
msg.fail(messages.CANNOT_ACCESS_INIT, node)
return AnyType()
# The base object has an instance type.
info = typ.type
if override_info:
info = override_info
# Look up the member. First look up the method dictionary.
method = info.get_method(name)
if method:
if method.is_property:
assert isinstance(method, OverloadedFuncDef)
return analyze_var(name, method.items[0].var, typ, info, node, is_lvalue, msg, not_ready_callback)
if is_lvalue:
msg.cant_assign_to_method(node)
typ = map_instance_to_supertype(typ, method.info)
if name == "__new__":
# __new__ is special and behaves like a static method -- don't strip
# the first argument.
signature = function_type(method, builtin_type("builtins.function"))
else:
signature = method_type_with_fallback(method, builtin_type("builtins.function"))
return expand_type_by_instance(signature, typ)
else:
# Not a method.
return analyze_member_var_access(
name,
typ,
info,
node,
is_lvalue,
is_super,
builtin_type,
not_ready_callback,
msg,
report_type=report_type,
chk=chk,
)
elif isinstance(typ, AnyType):
# The base object has dynamic type.
return AnyType()
elif isinstance(typ, NoneTyp):
if chk and chk.should_suppress_optional_error([typ]):
return AnyType()
# The only attribute NoneType has are those it inherits from object
return analyze_member_access(
name,
builtin_type("builtins.object"),
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
report_type=report_type,
chk=chk,
)
elif isinstance(typ, UnionType):
# The base object has dynamic type.
msg.disable_type_names += 1
results = [
analyze_member_access(
name, subtype, node, is_lvalue, is_super, is_operator, builtin_type, not_ready_callback, msg, chk=chk
)
for subtype in typ.items
]
msg.disable_type_names -= 1
return UnionType.make_simplified_union(results)
elif isinstance(typ, TupleType):
# Actually look up from the fallback instance type.
return analyze_member_access(
name, typ.fallback, node, is_lvalue, is_super, is_operator, builtin_type, not_ready_callback, msg, chk=chk
)
elif isinstance(typ, FunctionLike) and typ.is_type_obj():
# Class attribute.
# TODO super?
ret_type = typ.items()[0].ret_type
if isinstance(ret_type, TupleType):
ret_type = ret_type.fallback
if isinstance(ret_type, Instance):
if not is_operator:
# When Python sees an operator (eg `3 == 4`), it automatically translates that
# into something like `int.__eq__(3, 4)` instead of `(3).__eq__(4)` as an
# optimation.
#
# While it normally it doesn't matter which of the two versions are used, it
# does cause inconsistencies when working with classes. For example, translating
# `int == int` to `int.__eq__(int)` would not work since `int.__eq__` is meant to
# compare two int _instances_. What we really want is `type(int).__eq__`, which
# is meant to compare two types or classes.
#
# This check makes sure that when we encounter an operator, we skip looking up
# the corresponding method in the current instance to avoid this edge case.
# See https://github.com/python/mypy/pull/1787 for more info.
result = analyze_class_attribute_access(
ret_type, name, node, is_lvalue, builtin_type, not_ready_callback, msg
)
if result:
return result
# Look up from the 'type' type.
return analyze_member_access(
name,
typ.fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
report_type=report_type,
chk=chk,
)
else:
assert False, "Unexpected type {}".format(repr(ret_type))
elif isinstance(typ, FunctionLike):
# Look up from the 'function' type.
return analyze_member_access(
name,
typ.fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
report_type=report_type,
chk=chk,
)
elif isinstance(typ, TypeVarType):
return analyze_member_access(
name,
typ.upper_bound,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
report_type=report_type,
chk=chk,
)
elif isinstance(typ, DeletedType):
msg.deleted_as_rvalue(typ, node)
return AnyType()
elif isinstance(typ, TypeType):
# Similar to FunctionLike + is_type_obj() above.
item = None
if isinstance(typ.item, Instance):
item = typ.item
elif isinstance(typ.item, TypeVarType):
if isinstance(typ.item.upper_bound, Instance):
item = typ.item.upper_bound
if item and not is_operator:
# See comment above for why operators are skipped
result = analyze_class_attribute_access(item, name, node, is_lvalue, builtin_type, not_ready_callback, msg)
if result:
return result
fallback = builtin_type("builtins.type")
return analyze_member_access(
name,
fallback,
node,
is_lvalue,
is_super,
is_operator,
builtin_type,
not_ready_callback,
msg,
report_type=report_type,
chk=chk,
)
if chk and chk.should_suppress_optional_error([typ]):
return AnyType()
return msg.has_no_attr(report_type, name, node)
def visit_unbound_type(self, t: UnboundType) -> Type:
if t.optional:
t.optional = False
# We don't need to worry about double-wrapping Optionals or
# wrapping Anys: Union simplification will take care of that.
return make_optional_type(self.visit_unbound_type(t))
sym = self.lookup(t.name, t)
if sym is not None:
if sym.node is None:
# UNBOUND_IMPORTED can happen if an unknown name was imported.
if sym.kind != UNBOUND_IMPORTED:
self.fail(
'Internal error (node is None, kind={})'.format(
sym.kind), t)
return AnyType()
fullname = sym.node.fullname()
hook = self.plugin.get_type_analyze_hook(fullname)
if hook:
return hook(AnalyzeTypeContext(t, t, self))
if (fullname in nongen_builtins and t.args and not sym.normalized
and not self.allow_unnormalized):
self.fail(no_subscript_builtin_alias(fullname), t)
tvar_def = self.tvar_scope.get_binding(sym)
if sym.kind == TVAR and tvar_def is not None:
if len(t.args) > 0:
self.fail(
'Type variable "{}" used with arguments'.format(
t.name), t)
return TypeVarType(tvar_def, t.line)
elif fullname == 'builtins.None':
return NoneTyp()
elif fullname == 'typing.Any' or fullname == 'builtins.Any':
return AnyType(explicit=True)
elif fullname == 'typing.Tuple':
if len(t.args) == 0 and not t.empty_tuple_index:
# Bare 'Tuple' is same as 'tuple'
if 'generics' in self.options.disallow_any and not self.is_typeshed_stub:
self.fail(messages.BARE_GENERIC, t)
typ = self.named_type('builtins.tuple',
line=t.line,
column=t.column)
typ.from_generic_builtin = True
return typ
if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
# Tuple[T, ...] (uniform, variable-length tuple)
instance = self.named_type('builtins.tuple',
[self.anal_type(t.args[0])])
instance.line = t.line
return instance
return self.tuple_type(self.anal_array(t.args))
elif fullname == 'typing.Union':
items = self.anal_array(t.args)
return UnionType.make_union(items)
elif fullname == 'typing.Optional':
if len(t.args) != 1:
self.fail(
'Optional[...] must have exactly one type argument', t)
return AnyType()
item = self.anal_type(t.args[0])
return make_optional_type(item)
elif fullname == 'typing.Callable':
return self.analyze_callable_type(t)
elif fullname == 'typing.Type':
if len(t.args) == 0:
any_type = AnyType(from_omitted_generics=True,
line=t.line,
column=t.column)
return TypeType(any_type, line=t.line, column=t.column)
if len(t.args) != 1:
self.fail('Type[...] must have exactly one type argument',
t)
item = self.anal_type(t.args[0])
return TypeType.make_normalized(item, line=t.line)
elif fullname == 'typing.ClassVar':
if self.nesting_level > 0:
self.fail(
'Invalid type: ClassVar nested inside other type', t)
if len(t.args) == 0:
return AnyType(line=t.line)
if len(t.args) != 1:
self.fail(
'ClassVar[...] must have at most one type argument', t)
return AnyType()
item = self.anal_type(t.args[0])
if isinstance(item, TypeVarType) or get_type_vars(item):
self.fail('Invalid type: ClassVar cannot be generic', t)
return AnyType()
return item
elif fullname in ('mypy_extensions.NoReturn', 'typing.NoReturn'):
return UninhabitedType(is_noreturn=True)
elif sym.kind == TYPE_ALIAS:
override = sym.type_override
all_vars = sym.alias_tvars
assert override is not None
an_args = self.anal_array(t.args)
if all_vars is not None:
exp_len = len(all_vars)
else:
exp_len = 0
act_len = len(an_args)
if exp_len > 0 and act_len == 0:
# Interpret bare Alias same as normal generic, i.e., Alias[Any, Any, ...]
assert all_vars is not None
return set_any_tvars(override, all_vars, t.line, t.column)
if exp_len == 0 and act_len == 0:
return override
if act_len != exp_len:
self.fail(
'Bad number of arguments for type alias, expected: %s, given: %s'
% (exp_len, act_len), t)
return set_any_tvars(override,
all_vars or [],
t.line,
t.column,
implicit=False)
assert all_vars is not None
return replace_alias_tvars(override, all_vars, an_args, t.line,
t.column)
elif not isinstance(sym.node, TypeInfo):
name = sym.fullname
if name is None:
name = sym.node.name()
if isinstance(sym.node, Var) and isinstance(
sym.node.type, AnyType):
# Something with an Any type -- make it an alias for Any in a type
# context. This is slightly problematic as it allows using the type 'Any'
# as a base class -- however, this will fail soon at runtime so the problem
# is pretty minor.
return AnyType(from_unimported_type=True)
# Allow unbound type variables when defining an alias
if not (self.aliasing and sym.kind == TVAR
and self.tvar_scope.get_binding(sym) is None):
self.fail('Invalid type "{}"'.format(name), t)
return t
info = sym.node # type: TypeInfo
if len(t.args) > 0 and info.fullname() == 'builtins.tuple':
return TupleType(self.anal_array(t.args),
Instance(info, [AnyType()], t.line), t.line)
else:
# Analyze arguments and construct Instance type. The
# number of type arguments and their values are
# checked only later, since we do not always know the
# valid count at this point. Thus we may construct an
# Instance with an invalid number of type arguments.
instance = Instance(info, self.anal_array(t.args), t.line,
t.column)
instance.from_generic_builtin = sym.normalized
tup = info.tuple_type
if tup is not None:
# The class has a Tuple[...] base class so it will be
# represented as a tuple type.
if t.args:
self.fail('Generic tuple types not supported', t)
return AnyType()
return tup.copy_modified(items=self.anal_array(tup.items),
fallback=instance)
td = info.typeddict_type
if td is not None:
# The class has a TypedDict[...] base class so it will be
# represented as a typeddict type.
if t.args:
self.fail('Generic TypedDict types not supported', t)
return AnyType()
# Create a named TypedDictType
return td.copy_modified(item_types=self.anal_array(
list(td.items.values())),
fallback=instance)
return instance
else:
return AnyType()
def enum(self, ctx: AnalyzeTypeContext, values: List[Union[str, int]],
**kwargs) -> UnionType:
"""Generate a ``Union`` of ``Literal``s for an enum."""
return UnionType([self.const(ctx, value) for value in values])
def visit_union_type(self, t: UnionType) -> Type:
if is_subtype(self.s, t):
return t
else:
return UnionType.make_simplified_union([self.s, t])
def number(self, ctx: AnalyzeTypeContext, *args, **kwargs):
"""Generate a ``Union[int, float]`` annotation."""
return UnionType([named_builtin_type(ctx, 'int'),
named_builtin_type(ctx, 'float')])
def analyze_member_access(name: str,
typ: Type,
node: Context,
is_lvalue: bool,
is_super: bool,
builtin_type: Callable[[str], Instance],
msg: MessageBuilder,
override_info: TypeInfo = None,
report_type: Type = None) -> Type:
"""Analyse attribute access.
This is a general operation that supports various different variations:
1. lvalue or non-lvalue access (i.e. setter or getter access)
2. supertype access (when using super(); is_super == True and
override_info should refer to the supertype)
"""
report_type = report_type or typ
if isinstance(typ, Instance):
if name == '__init__' and not is_super:
# Accessing __init__ in statically typed code would compromise
# type safety unless used via super().
msg.fail(messages.CANNOT_ACCESS_INIT, node)
return AnyType()
# The base object has an instance type.
info = typ.type
if override_info:
info = override_info
# Look up the member. First look up the method dictionary.
method = info.get_method(name)
if method:
if method.is_property:
assert isinstance(method, OverloadedFuncDef)
method = cast(OverloadedFuncDef, method)
return analyze_var(name, method.items[0].var, typ, info, node,
is_lvalue, msg)
if is_lvalue:
msg.cant_assign_to_method(node)
typ = map_instance_to_supertype(typ, method.info)
return expand_type_by_instance(
method_type_with_fallback(method,
builtin_type('builtins.function')),
typ)
else:
# Not a method.
return analyze_member_var_access(name,
typ,
info,
node,
is_lvalue,
is_super,
builtin_type,
msg,
report_type=report_type)
elif isinstance(typ, AnyType):
# The base object has dynamic type.
return AnyType()
elif isinstance(typ, UnionType):
# The base object has dynamic type.
msg.disable_type_names += 1
results = [
analyze_member_access(name, subtype, node, is_lvalue, is_super,
builtin_type, msg) for subtype in typ.items
]
msg.disable_type_names -= 1
return UnionType.make_simplified_union(results)
elif isinstance(typ, TupleType):
# Actually look up from the fallback instance type.
return analyze_member_access(name, typ.fallback, node, is_lvalue,
is_super, builtin_type, msg)
elif isinstance(typ, FunctionLike) and typ.is_type_obj():
# Class attribute.
# TODO super?
itype = cast(Instance, typ.items()[0].ret_type)
result = analyze_class_attribute_access(itype, name, node, is_lvalue,
builtin_type, msg)
if result:
return result
# Look up from the 'type' type.
return analyze_member_access(name,
typ.fallback,
node,
is_lvalue,
is_super,
builtin_type,
msg,
report_type=report_type)
elif isinstance(typ, FunctionLike):
# Look up from the 'function' type.
return analyze_member_access(name,
typ.fallback,
node,
is_lvalue,
is_super,
builtin_type,
msg,
report_type=report_type)
elif isinstance(typ, TypeVarType):
return analyze_member_access(name,
typ.upper_bound,
node,
is_lvalue,
is_super,
builtin_type,
msg,
report_type=report_type)
return msg.has_no_attr(report_type, name, node)
def test_erase_with_generic_type_recursive(self) -> None:
tuple_any = Instance(self.fx.std_tuplei, [AnyType(TypeOfAny.explicit)])
A, _ = self.fx.def_alias_1(self.fx.a)
self.assert_erase(A, tuple_any)
A, _ = self.fx.def_alias_2(self.fx.a)
self.assert_erase(A, UnionType([self.fx.a, tuple_any]))
def visit_unbound_type(self, t: UnboundType) -> Type:
sym = self.lookup(t.name, t)
if sym is not None:
fullname = sym.node.fullname()
if sym.kind == BOUND_TVAR:
if len(t.args) > 0:
self.fail('Type variable "{}" used with arguments'.format(
t.name), t)
tvar_expr = cast(TypeVarExpr, sym.node)
return TypeVarType(t.name, sym.tvar_id, tvar_expr.values,
self.builtin_type('builtins.object'),
tvar_expr.variance,
t.line)
elif fullname == 'builtins.None':
return Void()
elif fullname == 'typing.Any':
return AnyType()
elif fullname == 'typing.Tuple':
if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
# Tuple[T, ...] (uniform, variable-length tuple)
node = self.lookup_fqn_func('builtins.tuple')
info = cast(TypeInfo, node.node)
return Instance(info, [t.args[0].accept(self)], t.line)
return TupleType(self.anal_array(t.args),
self.builtin_type('builtins.tuple'))
elif fullname == 'typing.Union':
items = self.anal_array(t.args)
items = [item for item in items if not isinstance(item, Void)]
return UnionType.make_union(items)
elif fullname == 'typing.Optional':
if len(t.args) != 1:
self.fail('Optional[...] must have exactly one type argument', t)
items = self.anal_array(t.args)
# Currently Optional[t] is just an alias for t.
return items[0]
elif fullname == 'typing.Callable':
return self.analyze_callable_type(t)
elif sym.kind == TYPE_ALIAS:
# TODO: Generic type aliases.
return sym.type_override
elif not isinstance(sym.node, TypeInfo):
name = sym.fullname
if name is None:
name = sym.node.name()
if isinstance(sym.node, Var) and isinstance(sym.node.type, AnyType):
# Something with an Any type -- make it an alias for Any in a type
# context. This is slightly problematic as it allows using the type 'Any'
# as a base class -- however, this will fail soon at runtime so the problem
# is pretty minor.
return AnyType()
self.fail('Invalid type "{}"'.format(name), t)
return t
info = cast(TypeInfo, sym.node)
if len(t.args) > 0 and info.fullname() == 'builtins.tuple':
return TupleType(self.anal_array(t.args),
Instance(info, [AnyType()], t.line),
t.line)
else:
# Analyze arguments and construct Instance type. The
# number of type arguments and their values are
# checked only later, since we do not always know the
# valid count at this point. Thus we may construct an
# Instance with an invalid number of type arguments.
instance = Instance(info, self.anal_array(t.args), t.line)
if info.tuple_type is None:
return instance
else:
# The class has a Tuple[...] base class so it will be
# represented as a tuple type.
if t.args:
self.fail('Generic tuple types not supported', t)
return AnyType()
return TupleType(self.anal_array(info.tuple_type.items),
fallback=instance,
line=t.line)
else:
return t
def visit_unbound_type(self, t: UnboundType) -> Type:
if t.optional:
t.optional = False
# We don't need to worry about double-wrapping Optionals or
# wrapping Anys: Union simplification will take care of that.
return make_optional_type(self.visit_unbound_type(t))
sym = self.lookup(t.name, t,
suppress_errors=self.third_pass) # type: ignore
if sym is not None:
if sym.node is None:
# UNBOUND_IMPORTED can happen if an unknown name was imported.
if sym.kind != UNBOUND_IMPORTED:
self.fail(errorcode.INTERNAL_ERROR_NODE_IS_NONE(sym.kind),
t)
return AnyType(TypeOfAny.special_form)
fullname = sym.node.fullname()
hook = self.plugin.get_type_analyze_hook(fullname)
if hook:
return hook(AnalyzeTypeContext(t, t, self))
if (fullname in nongen_builtins and t.args and not sym.normalized
and not self.allow_unnormalized):
self.fail(errorcode.NO_SUBSCRIPT_BUILTIN_ALIAS(fullname), t)
if self.tvar_scope:
tvar_def = self.tvar_scope.get_binding(sym)
else:
tvar_def = None
if self.warn_bound_tvar and sym.kind == TVAR and tvar_def is not None:
self.fail(
errorcode.
CANNOT_USE_BOUND_TYPE_VAR_TO_DEFINE_GENERIC_ALIAS(t.name),
t)
return AnyType(TypeOfAny.from_error)
elif sym.kind == TVAR and tvar_def is not None:
if len(t.args) > 0:
self.fail(errorcode.TYPE_VAR_USED_WITH_ARG(t.name), t)
return TypeVarType(tvar_def, t.line)
elif fullname == 'builtins.None':
return NoneTyp()
elif fullname == 'typing.Any' or fullname == 'builtins.Any':
return AnyType(TypeOfAny.explicit)
elif fullname == 'typing.Tuple':
if len(t.args) == 0 and not t.empty_tuple_index:
# Bare 'Tuple' is same as 'tuple'
if self.options.disallow_any_generics and not self.is_typeshed_stub:
self.fail(errorcode.BARE_GENERIC(), t)
typ = self.named_type('builtins.tuple',
line=t.line,
column=t.column)
typ.from_generic_builtin = True
return typ
if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
# Tuple[T, ...] (uniform, variable-length tuple)
instance = self.named_type('builtins.tuple',
[self.anal_type(t.args[0])])
instance.line = t.line
return instance
return self.tuple_type(self.anal_array(t.args))
elif fullname == 'typing.Union':
items = self.anal_array(t.args)
return UnionType.make_union(items)
elif fullname == 'typing.Optional':
if len(t.args) != 1:
self.fail(errorcode.OPTIONAL_MUST_HAVE_ONE_ARGUMENT(), t)
return AnyType(TypeOfAny.from_error)
item = self.anal_type(t.args[0])
return make_optional_type(item)
elif fullname == 'typing.Callable':
return self.analyze_callable_type(t)
elif fullname == 'typing.Type':
if len(t.args) == 0:
any_type = AnyType(TypeOfAny.from_omitted_generics,
line=t.line,
column=t.column)
return TypeType(any_type, line=t.line, column=t.column)
if len(t.args) != 1:
self.fail(errorcode.TYPE_MUST_HAVE_EXACTLY_ONE_TYPE(), t)
item = self.anal_type(t.args[0])
return TypeType.make_normalized(item, line=t.line)
elif fullname == 'typing.ClassVar':
if self.nesting_level > 0:
self.fail(
errorcode.INVALID_TYPE_CLASSVAR_NESTED_INSIDE_TYPE(),
t)
if len(t.args) == 0:
return AnyType(TypeOfAny.from_omitted_generics,
line=t.line,
column=t.column)
if len(t.args) != 1:
self.fail(
errorcode.CLASS_VAR_MUST_HAVE_AT_MOST_ONE_TYPE_ARG(),
t)
return AnyType(TypeOfAny.from_error)
item = self.anal_type(t.args[0])
if isinstance(item, TypeVarType) or get_type_vars(item):
self.fail(errorcode.CLASSVAR_CANNOT_BE_GENERIC(), t)
return AnyType(TypeOfAny.from_error)
return item
elif fullname in ('mypy_extensions.NoReturn', 'typing.NoReturn'):
return UninhabitedType(is_noreturn=True)
elif sym.kind == TYPE_ALIAS:
override = sym.type_override
all_vars = sym.alias_tvars
assert override is not None
an_args = self.anal_array(t.args)
if all_vars is not None:
exp_len = len(all_vars)
else:
exp_len = 0
act_len = len(an_args)
if exp_len > 0 and act_len == 0:
# Interpret bare Alias same as normal generic, i.e., Alias[Any, Any, ...]
assert all_vars is not None
return set_any_tvars(override, all_vars, t.line, t.column)
if exp_len == 0 and act_len == 0:
return override
if act_len != exp_len:
self.fail(
errorcode.BAD_NUMBER_ARGUMENT_FOR_TYPEALIAS(
exp_len, act_len), t)
return set_any_tvars(override,
all_vars or [],
t.line,
t.column,
implicit=False)
assert all_vars is not None
return replace_alias_tvars(override, all_vars, an_args, t.line,
t.column)
elif not isinstance(sym.node, TypeInfo):
name = sym.fullname
if name is None:
name = sym.node.name()
if isinstance(sym.node, Var) and isinstance(
sym.node.type, AnyType):
# Something with an Any type -- make it an alias for Any in a type
# context. This is slightly problematic as it allows using the type 'Any'
# as a base class -- however, this will fail soon at runtime so the problem
# is pretty minor.
return AnyType(TypeOfAny.from_unimported_type)
# Allow unbound type variables when defining an alias
if not (self.aliasing and sym.kind == TVAR and
(not self.tvar_scope
or self.tvar_scope.get_binding(sym) is None)):
if (not self.third_pass and not self.in_dynamic_func
and not (isinstance(sym.node, (FuncDef, Decorator))
or isinstance(sym.node, Var)
and sym.node.is_ready)
and not (sym.kind == TVAR and tvar_def is None)):
if t.args and not self.global_scope:
self.fail(
errorcode.UNSUPPORTED_FORWARD_REFERENCE(
t.name), t)
return AnyType(TypeOfAny.from_error)
return ForwardRef(t)
self.fail(errorcode.INVALID_TYPE_X(name), t)
if self.third_pass and sym.kind == TVAR:
self.note_func(
errorcode.FORWARD_REERENCES_TO_TYPE_VAR_PROHIBITED(
), t)
return t
info = sym.node # type: TypeInfo
if len(t.args) > 0 and info.fullname() == 'builtins.tuple':
fallback = Instance(info, [AnyType(TypeOfAny.special_form)],
t.line)
return TupleType(self.anal_array(t.args), fallback, t.line)
else:
# Analyze arguments and construct Instance type. The
# number of type arguments and their values are
# checked only later, since we do not always know the
# valid count at this point. Thus we may construct an
# Instance with an invalid number of type arguments.
instance = Instance(info, self.anal_array(t.args), t.line,
t.column)
instance.from_generic_builtin = sym.normalized
tup = info.tuple_type
if tup is not None:
# The class has a Tuple[...] base class so it will be
# represented as a tuple type.
if t.args:
self.fail(
errorcode.GENERIC_TUPLE_TYPES_NOT_SUPPORTED(), t)
return AnyType(TypeOfAny.from_error)
return tup.copy_modified(items=self.anal_array(tup.items),
fallback=instance)
td = info.typeddict_type
if td is not None:
# The class has a TypedDict[...] base class so it will be
# represented as a typeddict type.
if t.args:
self.fail(
errorcode.GENERIC_TYPEDDICT_TYPES_NOT_SUPPORTED(),
t)
return AnyType(TypeOfAny.from_error)
# Create a named TypedDictType
return td.copy_modified(item_types=self.anal_array(
list(td.items.values())),
fallback=instance)
return instance
else:
if self.third_pass:
self.fail(errorcode.INVALID_TYPE_X(t.name), t)
return AnyType(TypeOfAny.from_error)
return AnyType(TypeOfAny.special_form)
def test_union_can_not_be_true_if_none_true(self) -> None:
union_type = UnionType([self.tuple(), self.tuple()])
assert_false(union_type.can_be_true)
def visit_union_type(self, t: UnionType) -> Type:
erased_items = [erase_type(item) for item in t.items]
return UnionType.make_simplified_union(erased_items)
def test_union_can_be_false_if_any_false(self) -> None:
union_type = UnionType([self.fx.a, self.tuple()])
assert_true(union_type.can_be_false)
def make_optional(typ: MypyType) -> MypyType:
return UnionType.make_union([typ, NoneTyp()])
def test_union_can_not_be_false_if_none_false(self) -> None:
union_type = UnionType([self.tuple(self.fx.a), self.tuple(self.fx.d)])
assert_false(union_type.can_be_false)
