mypy.checkexpr.ExpressionChecker

Get type of a type alias (could be generic) in a runtime expression.

Note that this function can be called only if the alias appears _not_ as a target of type application, which is treated separately in the visit_type_application method. Some examples where this method is called are casts and instantiation:

class LongName(Generic[T]): ... A = LongName[int]

x = A() y = cast(A, ...)

Undocumented

Undocumented

Analyze the callee X in X(...) where X is Type[item].

Return a Y that we can pass to check_call(Y, ...).

Undocumented

Use special case logic to infer the return type of a specific named function/method.

Caller must ensure that a plugin hook exists. There are two different cases:

• If object_type is None, the caller must ensure that a function hook exists for fullname.
• If object_type is not None, the caller must ensure that a method hook exists for fullname.

Return the inferred return type.

Apply inferred values of type arguments to a generic function.

Inferred_args contains the values of function type arguments.

Apply type arguments to a generic callable type coming from a type object.

This will first perform type arguments count checks, report the error as needed, and return the correct kind of Any. As a special case this returns Any for non-callable types, because if type object type is not callable, then an error should be already reported.

Undocumented

Undocumented

Check that there is a value for all required arguments to a function.

Also check that there are no duplicate values for arguments. Report found errors using 'messages' if it's not None. If 'messages' is given, 'context' must also be given.

Return False if there were any errors. Otherwise return True

Check argument types against a callable type.

Report errors if the argument types are not compatible.

The check_call docstring describes some of the arguments.

Check the argument to await and extract the type of value.

Also used by async for and async with.

Type check a call.

Also infer type arguments if the callee is a generic function.

Return (result type, inferred callee type).

Arguments:

callee: type of the called value args: actual argument expressions arg_kinds: contains nodes.ARG_* constant for each argument in args

describing whether the argument is positional, *arg, etc.

context: current expression context, used for inference. arg_names: names of arguments (optional) callable_node: associate the inferred callable type to this node,

if specified

arg_messages: utility for generating messages, can be swapped to suppress errors,

by default uses 'self.msg' to show errors

callable_name: Fully-qualified name of the function/method to call,

or None if unavailable (examples: 'builtins.open', 'typing.Mapping.get')

object_type: If callable_name refers to a method, the type of the object

on which the method is being called

Type check call expression.

The callee_type should be used as the type of callee expression. In particular, in case of a union type this can be a particular item of the union, so that we can apply plugin hooks to each item.

The 'member', 'callable_name' and 'object_type' are only used to call plugin hooks. If 'callable_name' is None but 'member' is not None (member call), try constructing 'callable_name' using 'object_type' (the base type on which the method is called), for example 'typing.Mapping.get'.

Type check a call that targets a callable value.

See the docstring of check_call for more information.

Check the for_comp part of comprehensions. That is the part from 'for': ... for x in y if z

Note: This adds the type information derived from the condlists to the current binder.

Check for extra actual arguments.

Return tuple (was everything ok,

was there an extra keyword argument error [used to avoid duplicate errors]).

Type check an expression of form '[...] * e'.

Type inference is special-cased for this common construct.

Undocumented

Type check a call to a method with the given name and type on an object.

Return tuple (result type, inferred method type).

Type check a call to a named method on an object.

Return tuple (result type, inferred method type). The 'original_type' is used for error messages.

Type check a binary operation which maps to a method call.

Return tuple (result type, inferred operator method type).

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Type check a call to a named method on an object with union type.

This essentially checks the call using check_method_call_by_name() for each union item and unions the result. We do this to allow plugins to act on individual union items.

Accepts a list of function signatures and attempts to combine them together into a new CallableType consisting of the union of all of the given arguments and return types.

If there is at least one non-callable type, return Any (this can happen if there is an ambiguity because of Any in arguments).

Check for dangerous non-overlapping comparisons like 42 == 'no'.

The original_container is the original container type for 'in' checks (and None for equality checks).

Rules:

• X and None are overlapping even in strict-optional mode. This is to allow

'assert x is not None' for x defined as 'x = None # type: str' in class body (otherwise mypy itself would have couple dozen errors because of this). * Optional[X] and Optional[Y] are non-overlapping if X and Y are non-overlapping, although technically None is overlap, it is most likely an error. * Any overlaps with everything, i.e. always safe. * Special case: b'abc' in b'cde' is safe.

Fast path to determine the type of a list or set literal, based on the list of entries. This mostly impacts large module-level constant definitions.

Limitations:

• no active type context
• no star expressions
• the joined type of all entries must be an Instance type

Fast path to determine the type of a dict literal, based on the list of entries. This mostly impacts large module-level constant definitions.

Limitations:

• no active type context
• only supported star expressions are other dict instances
• the joined types of all keys and values must be Instance types

If expression has a partial generic type, return it without additional checks.

In particular, this does not generate an error about a missing annotation.

Otherwise, return None.

Undocumented

Return pass numbers for args for two-pass argument type inference.

For each actual, the pass number is either 1 (first pass) or 2 (second pass).

Two-pass argument type inference primarily lets us infer types of lambdas more effectively.

Undocumented

Get variable node for a partial self attribute.

If the expression is not a self attribute, or attribute is not variable, or variable is not partial, return None.

Undocumented

Undocumented

Infer argument expression types using a callable type as context.

For example, if callee argument 2 has type List[int], infer the argument expression with List[int] type context.

Returns the inferred types of actual arguments.

Infer argument expression types in an empty context.

In short, we basically recurse on each argument without considering in what context the argument was called.

Infer the type arguments for a generic callee type.

Infer based on the types of arguments.

Return a derived callable type that has the arguments applied.

Perform second pass of generic function type argument inference.

The second pass is needed for arguments with types such as Callable[[T], S], where both T and S are type variables, when the actual argument is a lambda with inferred types. The idea is to infer the type variable T in the first pass (based on the types of other arguments). This lets us infer the argument and return type of the lambda expression and thus also the type variable S in this second pass.

Return (the callee with type vars applied, inferred actual arg types).

Unify callable return type to type context to infer type vars.

For example, if the return type is set[t] where 't' is a type variable of callable, and if the context is set[int], return callable modified by substituting 't' with 'int'.

Try to infer lambda expression type using context.

Return None if could not infer type. The second item in the return type is the type_override parameter for check_func_item.

Analyzes the given literal expression and determines if we should be inferring an Instance type, a Literal[...] type, or an Instance that remembers the original literal. We...

1. ...Infer a normal Instance in most circumstances.
2. ...Infer a Literal[...] if we're in a literal context. For example, if we were analyzing the "3" in "foo(3)" where "foo" has a signature of "def foo(Literal[3]) -> None", we'd want to infer that the "3" has a type of Literal[3] instead of Instance.
3. ...Infer an Instance that remembers the original Literal if we're declaring a Final variable with an inferred type -- for example, "bar" in "bar: Final = 3" would be assigned an Instance that remembers it originated from a '3'. See the comments in Instance's constructor for more details.

Attempts to find the first matching callable from the given list.

If a match is found, returns a tuple containing the result type and the inferred callee type. (This tuple is meant to be eventually returned by check_call.) If multiple targets match due to ambiguous Any parameters, returns (AnyType, AnyType). If no targets match, returns None.

Assumes all of the given targets have argument counts compatible with the caller.

Undocumented

Undocumented

Narrow down a known type of expression using information in conditional type binder.

If 'skip_non_overlapping' is True, return None if the type and restriction are non-overlapping.

Undocumented

Called when we can't infer the type of a variable because it's not ready yet.

Either defer type checking of the enclosing function to the next pass or report an error.

Returns a list of all targets that match the caller after erasing types.

Assumes all of the given targets have argument counts compatible with the caller.

Returns all overload call targets that having matching argument counts.

If the given args contains a star-arg (*arg or **kwarg argument), this method will ensure all star-arg overloads appear at the start of the list, instead of their usual location.

The only exception is if the starred argument is something like a Tuple or a NamedTuple, which has a definitive "shape". If so, we don't move the corresponding alternative to the front since we can infer a more precise match using the original order.

Undocumented

Attempt to determine a more accurate signature for a method call.

This is done by looking up and applying a method signature hook (if one exists for the given method name).

If no matching method signature hook is found, callee is returned unmodified. The same happens if the arguments refer to a non-method callable (this is allowed so that the code calling transform_callee_type needs to perform fewer boilerplate checks).

Note: this method is not called automatically as part of check_call, because in some cases check_call is called multiple times while checking a single call (for example when dealing with overloads). Instead, this method needs to be called explicitly (if appropriate) before the signature is passed to check_call.

If the given expression or type corresponds to an int literal or a union of int literals, returns a list of the underlying ints. Otherwise, returns None.

Specifically, this function is guaranteed to return a list with one or more ints if one one the following is true:

1. 'expr' is a IntExpr or a UnaryExpr backed by an IntExpr
2. 'typ' is a LiteralType containing an int
3. 'typ' is a UnionType containing only LiteralType of ints

Accepts a list of overload signatures and attempts to match calls by destructuring the first union.

Return a list of (<return type>, <inferred variant type>) if call succeeds for every item of the desctructured union. Returns None if there is no match.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Type check a comparison expression.

Comparison expressions are type checked consecutive-pair-wise That is, 'a < b > c == d' is check as 'a < b and b > c and c == d'

Undocumented

Type check a dict expression.

Translate it into a call to dict(), with provisions for **expr.

Undocumented

Undocumented

Undocumented

Type check an index expression (base[index]).

It may also represent type application.

Undocumented

Analyze type of an index expression for a given type of base expression.

The 'original_type' is used for error messages (currently used for union types).

Undocumented

Type check a name expression.

It can be of any kind: local, member or global.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Right hand side of a type alias definition.

It has the same type as if the alias itself was used in a runtime context. For example, here:

A = reveal_type(List[T]) reveal_type(A)

both reveal_type instances will reveal the same type def (...) -> builtins.list[Any]. Note that type variables are implicitly substituted with Any.

Type check a type application (expr[type, ...]).

There are two different options here, depending on whether expr refers to a type alias or directly to a generic class. In the first case we need to use a dedicated function typeanal.expand_type_aliases. This is due to the fact that currently type aliases machinery uses unbound type variables, while normal generics use bound ones; see TypeAlias docstring for more details.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented