mypy.checkexpr

module documentation

(source)

Expression type checker. This file is conceptually part of TypeChecker.

Class	`ArgInferSecondPassQuery`	Query whether an argument type should be inferred in the second pass.
Class	`ExpressionChecker`	Expression type checker.
Class	`Finished`	Raised if we can terminate overload argument check early (no match).
Class	`HasAnyType`	Undocumented
Class	`HasErasedComponentsQuery`	Visitor for querying whether a type has an erased component.
Class	`HasTypeVarQuery`	Visitor for querying whether a type has a type variable component.
Class	`HasUninhabitedComponentsQuery`	Visitor for querying whether a type has an UninhabitedType component.
Class	`TooManyUnions`	Indicates that we need to stop splitting unions in an attempt to match an overload in order to save performance.
Function	`all_same_types`	Undocumented
Function	`any_causes_overload_ambiguity`	May an argument containing 'Any' cause ambiguous result type on call to overloaded function?
Function	`arg_approximate_similarity`	Return if caller argument (actual) is roughly compatible with signature arg (formal).
Function	`extract_refexpr_names`	Recursively extracts all module references from a reference expression.
Function	`get_partial_instance_type`	Undocumented
Function	`has_any_type`	Whether t contains an Any type
Function	`has_bytes_component`	Is this one of builtin byte types, or a union that contains it?
Function	`has_coroutine_decorator`	Whether t came from a function decorated with `@coroutine`.
Function	`has_erased_component`	Undocumented
Function	`has_uninhabited_component`	Undocumented
Function	`is_async_def`	Whether t came from a function defined using `async def`.
Function	`is_duplicate_mapping`	Undocumented
Function	`is_expr_literal_type`	Returns 'true' if the given node is a Literal
Function	`is_non_empty_tuple`	Undocumented
Function	`is_operator_method`	Undocumented
Function	`merge_typevars_in_callables_by_name`	Takes all the typevars present in the callables and 'combines' the ones with the same name.
Function	`replace_callable_return_type`	Return a copy of a callable type with a different return type.
Function	`try_getting_literal`	If possible, get a more precise literal type for a given type.
Function	`type_info_from_type`	Gets the TypeInfo for a type, indirecting through things like type variables and tuples.
Constant	`MAX_UNIONS`	Undocumented
Constant	`OVERLAPPING_TYPES_ALLOWLIST`	Undocumented
Variable	`ArgChecker`	Undocumented

def all_same_types(types): (source)

Undocumented

Parameters
types:`List[Type]`	Undocumented
Returns
`bool`	Undocumented

def any_causes_overload_ambiguity(items, return_types, arg_types, arg_kinds, arg_names): (source)

May an argument containing 'Any' cause ambiguous result type on call to overloaded function?

Note that this sometimes returns True even if there is no ambiguity, since a correct implementation would be complex (and the call would be imprecisely typed due to Any types anyway).

Args:: items: Overload items matching the actual arguments arg_types: Actual argument types arg_kinds: Actual argument kinds arg_names: Actual argument names

Parameters
items:`List[CallableType]`	Undocumented
return_types:`List[Type]`	Undocumented
arg_types:`List[Type]`	Undocumented
arg_kinds:`List[ArgKind]`	Undocumented
arg_names:`Optional[Sequence[Optional[str]]]`	Undocumented
Returns
`bool`	Undocumented

def arg_approximate_similarity(actual, formal): (source)

Return if caller argument (actual) is roughly compatible with signature arg (formal).

This function is deliberately loose and will report two types are similar as long as their "shapes" are plausibly the same.

This is useful when we're doing error reporting: for example, if we're trying to select an overload alternative and there's no exact match, we can use this function to help us identify which alternative the user might have meant to match.

Parameters
actual:`Type`	Undocumented
formal:`Type`	Undocumented
Returns
`bool`	Undocumented

def extract_refexpr_names(expr): (source)

Recursively extracts all module references from a reference expression.

Note that currently, the only two subclasses of RefExpr are NameExpr and MemberExpr.

Parameters
expr:`RefExpr`	Undocumented
Returns
`Set[str]`	Undocumented

def get_partial_instance_type(t): (source)

Undocumented

Parameters
t:`Optional[Type]`	Undocumented
Returns
`Optional[PartialType]`	Undocumented

def has_any_type(t, ignore_in_type_obj=False): (source)

Whether t contains an Any type

Parameters
t:`Type`	Undocumented
ignore_in_type_obj:`bool`	Undocumented
Returns
`bool`	Undocumented

def has_bytes_component(typ, py2=False): (source)

Is this one of builtin byte types, or a union that contains it?

Parameters
typ:`Type`	Undocumented
py2:`bool`	Undocumented
Returns
`bool`	Undocumented

def has_coroutine_decorator(t): (source)

Whether t came from a function decorated with @coroutine.

Parameters
t:`Type`	Undocumented
Returns
`bool`	Undocumented

def has_erased_component(t): (source)

Undocumented

Parameters
t:`Optional[Type]`	Undocumented
Returns
`bool`	Undocumented

def has_uninhabited_component(t): (source)

Undocumented

Parameters
t:`Optional[Type]`	Undocumented
Returns
`bool`	Undocumented

def is_async_def(t): (source)

Whether t came from a function defined using async def.

Parameters
t:`Type`	Undocumented
Returns
`bool`	Undocumented

def is_duplicate_mapping(mapping, actual_types, actual_kinds): (source)

Undocumented

Parameters
mapping:`List[int]`	Undocumented
actual_types:`List[Type]`	Undocumented
actual_kinds:`List[ArgKind]`	Undocumented
Returns
`bool`	Undocumented

def is_expr_literal_type(node): (source)

Returns 'true' if the given node is a Literal

Parameters
node:`Expression`	Undocumented
Returns
`bool`	Undocumented

def is_non_empty_tuple(t): (source)

Undocumented

Parameters
t:`Type`	Undocumented
Returns
`bool`	Undocumented

def is_operator_method(fullname): (source)

Undocumented

Parameters
fullname:`Optional[str]`	Undocumented
Returns
`bool`	Undocumented

def merge_typevars_in_callables_by_name(callables): (source)

Takes all the typevars present in the callables and 'combines' the ones with the same name.

For example, suppose we have two callables with signatures "f(x: T, y: S) -> T" and "f(x: List[Tuple[T, S]]) -> Tuple[T, S]". Both callables use typevars named "T" and "S", but we treat them as distinct, unrelated typevars. (E.g. they could both have distinct ids.)

If we pass in both callables into this function, it returns a list containing two new callables that are identical in signature, but use the same underlying TypeVarType for T and S.

This is useful if we want to take the output lists and "merge" them into one callable in some way -- for example, when unioning together overloads.

Returns both the new list of callables and a list of all distinct TypeVarType objects used.

Parameters
callables:`Sequence[CallableType]`	Undocumented
Returns
`Tuple[List[CallableType], List[TypeVarType]]`	Undocumented

def replace_callable_return_type(c, new_ret_type): (source)

Return a copy of a callable type with a different return type.

Parameters
c:`CallableType`	Undocumented
new_ret_type:`Type`	Undocumented
Returns
`CallableType`	Undocumented

def try_getting_literal(typ): (source)

If possible, get a more precise literal type for a given type.

Parameters
typ:`Type`	Undocumented
Returns
`ProperType`	Undocumented

def type_info_from_type(typ): (source)

Gets the TypeInfo for a type, indirecting through things like type variables and tuples.

Parameters
typ:`Type`	Undocumented
Returns
`Optional[TypeInfo]`	Undocumented

MAX_UNIONS: int = (source)

Undocumented

Value

OVERLAPPING_TYPES_ALLOWLIST: list[str] = (source)

Undocumented

Value

['builtins.set',
 'builtins.frozenset',
 'typing.KeysView',
 'typing.ItemsView',
 'builtins._dict_keys',
 'builtins._dict_items',
 '_collections_abc.dict_keys',
...

ArgChecker: _TypeAlias = (source)

Undocumented