mypy.checker.TypeChecker

Construct a type checker.

Use errors to report type check errors.

Repeatedly type check a loop body until the frame doesn't change. If exit_condition is set, assume it must be False on exit from the loop.

Then check the else_body.

Check if a type is a nominal container of a union of such.

Return the corresponding container item type.

Bind self-type and map type variables for a method.

Arguments:

sym: a symbol that points to method definition typ: method type on the definition sub_info: class where the method is used super_info: class where the method was defined

Undocumented

Generate error if the return type of __exit__ is problematic.

If __exit__ always returns False but the return type is declared as bool, mypy thinks that a with statement may "swallow" exceptions even though this is not the case, resulting in invalid reachability inference.

Undocumented

Undocumented

Undocumented

Check if attribute name in base1 is compatible with base2 in multiple inheritance.

Assume base1 comes before base2 in the MRO, and that base1 and base2 don't have a direct subclass relationship (i.e., the compatibility requirement only derives from multiple inheritance).

This check verifies that a definition taken from base1 (and mapped to the current class ctx), is type compatible with the definition taken from base2 (also mapped), so that unsafe subclassing like this can be detected:

class A(Generic[T]):

def foo(self, x: T) -> None: ...

class B:

def foo(self, x: str) -> None: ...

class C(B, A[int]): ... # this is unsafe because...

x: A[int] = C() x.foo # ...runtime type is (str) -> None, while static type is (int) -> None

Undocumented

Undocumented

Check if an assignment overrides a final attribute in a base class.

This only checks situations where either a node in base class is not a variable but a final method, or where override is explicitly declared as final. In these cases we give a more detailed error message. In addition, we check that a final variable doesn't override writeable attribute, which is not safe.

Other situations are checked in check_final().

Undocumented

Undocumented

Check if this assignment does not assign to a final attribute.

This function performs the check only for name assignments at module and class scope. The assignments to obj.attr and Cls.attr are checked in checkmember.py.

Undocumented

Type check the entire file, but defer functions with unresolved references.

Unresolved references are forward references to variables whose types haven't been inferred yet. They may occur later in the same file or in a different file that's being processed later (usually due to an import cycle).

Deferred functions will be processed by check_second_pass().

Undocumented

Undocumented

Type check a function.

If type_override is provided, use it as the function type.

Undocumented

Check that a final variable doesn't override writeable attribute.

This is done to prevent situations like this:

class C:

attr = 1

class D(C):

attr: Final = 2

x: C = D() x.attr = 3 # Oops!

Undocumented

Undocumented

Type check indexed assignment base[index] = rvalue.

The lvalue argument is the base[index] expression.

Check that keywords in a class definition are valid arguments for __init_subclass__().

In this example:

1 class Base: 2 def __init_subclass__(cls, thing: int): 3 pass 4 class Child(Base, thing=5): 5 def __init_subclass__(cls): 6 pass 7 Child()

Base.__init_subclass__(thing=5) is called at line 4. This is what we simulate here. Child.__init_subclass__ is never called.

Check an inplace operator method such as __iadd__.

They cannot arbitrarily overlap with __add__.

Undocumented

Type member assignment.

This defers to check_simple_assignment, unless the member expression is a descriptor, in which case this checks descriptor semantics as well.

Return the inferred rvalue_type, inferred lvalue_type, and whether to use the binder for this assignment.

Note: this method exists here and not in checkmember.py, because we need to take care about interaction between binder and __set__().

Check if method definition is compatible with a base class.

Return True if the node was deferred because one of the corresponding superclass nodes is not ready.

Check if function definition is compatible with base classes.

This may defer the method if a signature is not available in at least one base class.

Check if overriding an attribute name of base with defn is valid.

Return True if the supertype node was not analysed yet, and defn was deferred.

Undocumented

Undocumented

Check assignment to multiple lvalue targets when rvalue type is a Union[...]. For example:

t: Union[Tuple[int, int], Tuple[str, str]] x, y = t reveal_type(x) # Union[int, str]

The idea in this case is to process the assignment for every item of the union. Important note: the types are collected in two places, 'union_types' contains inferred types for first assignments, 'assignments' contains the narrowed types for binder.

Check for overlapping method and reverse method signatures.

This function assumes that:

• The reverse method has valid argument count and kinds.

• If the reverse operator method accepts some argument of type X, the forward operator method also belong to class X.

  For example, if we have the reverse operator A.__radd__(B), then the corresponding forward operator must have the type B.__add__(...).

Undocumented

Check a method override with given signatures.

Arguments:

override: The signature of the overriding method. original: The signature of the original supertype method. name: The name of the subtype. This and the next argument are

only used for generating error messages.

supertype: The name of the supertype.

Undocumented

Check that protocol definition is compatible with declared variances of type variables.

Note that we also prohibit declaring protocol classes as invariant if they are actually covariant/contravariant, since this may break transitivity of subtyping, see PEP 544.

Undocumented

Undocumented

Run second or following pass of type checking.

This goes through deferred nodes, returning True if there were any.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Takes in an expression and the current type of the expression.

Returns a 2-tuple: The first element is a map from the expression to the restricted type if it were callable. The second element is a map from the expression to the type it would hold if it weren't callable.

Undocumented

Undocumented

Defer a node for processing during next type-checking pass.

Args:

node: function/method being deferred enclosing_class: for methods, the class where the method is defined

NOTE: this can't handle nested functions/methods.

Undocumented

Undocumented

Enter a new scope for collecting partial types.

Also report errors for (some) variables which still have partial types, i.e. we couldn't infer a complete type.

Undocumented

Find any isinstance checks (within a chain of ands). Includes implicit and explicit checks for None and calls to callable. Also includes TypeGuard functions.

Return value is a map of variables to their types if the condition is true and a map of variables to their types if the condition is false.

If either of the values in the tuple is None, then that particular branch can never occur.

May return {}, {}. Can return None, None in situations involving NoReturn.

Undocumented

Look for an active partial type scope containing variable.

A scope is active if assignments in the current context can refine a partial type originally defined in the scope. This is affected by the local_partial_types configuration option.

Look for partial type scope containing variable.

Return tuple (is the scope active, is the scope a local scope, scope).

Narrow types based on any checks of the type type(x) == T

Args:

node: The node that might contain the comparison expr_indices: The list of indices of expressions in node that are being

compared

Convert a partial type that we couldn't resolve into something concrete.

This means, for None we make it Optional[Any], and for anything else we fill in all of the type arguments with Any.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Handle a reference to a partial type through a var.

(Used by checkexpr and checkmember.)

Should we type-check the current function?

• Yes if --check-untyped-defs is set.
• Yes outside functions.
• Yes in annotated functions.
• No otherwise.

Undocumented

Undocumented

Creates a fake type that represents the intersection of an Instance and a CallableType.

It operates by creating a bare-minimum dummy TypeInfo that subclasses type and adds a __call__ method matching callable_type.

Try creating an ad-hoc intersection of the given instances.

Note that this function does not try and create a full-fledged intersection type. Instead, it returns an instance of a new ad-hoc subclass of the given instances.

This is mainly useful when you need a way of representing some theoretical subclass of the instances the user may be trying to use the generated intersection can serve as a placeholder.

This function will create a fresh subclass every time you call it, even if you pass in the exact same arguments. So this means calling self.intersect_intersection([inst_1, inst_2], ctx) twice will result in instances of two distinct subclasses of inst_1 and inst_2.

This is by design: we want each ad-hoc intersection to be unique since they're supposed represent some other unknown subclass.

Returns None if creating the subclass is impossible (e.g. due to MRO errors or incompatible signatures). If we do successfully create a subclass, its TypeInfo will automatically be added to the global scope.

Undocumented

Is typ a valid type for an async generator?

True if typ is a supertype of AsyncGenerator.

Undocumented

Undocumented

Undocumented

Is typ a valid type for a generator/coroutine?

True if typ is a supertype of Generator or Awaitable. Also true it it's exactly AwaitableGenerator (modulo type parameters).

Returns 'true' if the given statement either throws an error of some kind or is a no-op.

We use this function mostly while handling the '--warn-unreachable' flag. When that flag is present, we normally report an error on any unreachable statement. But if that statement is just something like a 'pass' or a just-in-case 'assert False', reporting an error would be annoying.

Undocumented

Returns 'true' if the given body is "trivial" -- if it contains just a "pass", "..." (ellipsis), or "raise NotImplementedError()". A trivial body may also start with a statement containing just a string (e.g. a docstring).

Note: functions that raise other kinds of exceptions do not count as "trivial". We use this function to help us determine when it's ok to relax certain checks on body, but functions that raise arbitrary exceptions are more likely to do non-trivial work. For example:

def halt(self, reason: str = ...) -> NoReturn:

raise MyCustomError("Fatal error: " + reason, self.line, self.context)

A function that raises just NotImplementedError is much less likely to be this complex.

Undocumented

Check if t can be used as the basis for a partial defaultdict value type.

Examples:

• t is 'int' --> True
• t is 'list[<nothing>]' --> True
• t is 'dict[...]' --> False (only generic types with a single type argument supported)

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Return an instance with the given name and type arguments.

Assume that the number of arguments is correct. Assume that the name refers to a compatible generic type.

Return an instance type with given name and implicit Any type args.

For example, named_type('builtins.object') produces the 'object' type.

Partitions a type into callable subtypes and uncallable subtypes.

Thus, given: callables, uncallables = partition_by_callable(type)

If we assert callable(type) then type has type Union[*callables], and If we assert not callable(type) then type has type Union[*uncallables]

If unsound_partition is set, assume that anything that is not clearly callable is in fact not callable. Otherwise we generate a new subtype that is callable.

Guaranteed to not return [], [].

Attempts refining parent expressions of any MemberExpr or IndexExprs in new_types.

Specifically, this function accepts two mappings of expression to original types: the original mapping (existing_types), and a new mapping (new_types) intended to update the original.

This function iterates through new_types and attempts to use the information to try refining any parent types that happen to be unions.

For example, suppose there are two types "A = Tuple[int, int]" and "B = Tuple[str, str]". Next, suppose that 'new_types' specifies the expression 'foo[0]' has a refined type of 'int' and that 'foo' was previously deduced to be of type Union[A, B].

Then, this function will observe that since A[0] is an int and B[0] is not, the type of 'foo' can be further refined from Union[A, B] into just B.

We perform this kind of "parent narrowing" for member lookup expressions and indexing expressions into tuples, namedtuples, and typeddicts. We repeat this narrowing recursively if the parent is also a "lookup expression". So for example, if we have the expression "foo['bar'].baz[0]", we'd potentially end up refining types for the expressions "foo", "foo['bar']", and "foo['bar'].baz".

We return the newly refined map. This map is guaranteed to be a superset of 'new_types'.

Undocumented

Produces conditional type maps refining away None in an identity/equality chain.

For more details about what the different arguments mean, see the docstring of 'refine_identity_comparison_expression' up above.

Produce conditional type maps refining expressions by an identity/equality comparison.

The 'operands' and 'operand_types' lists should be the full list of operands used in the overall comparison expression. The 'chain_indices' list is the list of indices actually used within this identity comparison chain.

So if we have the expression:

a <= b is c is d <= e

...then 'operands' and 'operand_types' would be lists of length 5 and 'chain_indices' would be the list [1, 2, 3].

The 'narrowable_operand_indices' parameter is the set of all indices we are allowed to refine the types of: that is, all operands that will potentially be a part of the output TypeMaps.

Although this function could theoretically try setting the types of the operands in the chains to the meet, doing that causes too many issues in real-world code. Instead, we use 'is_valid_target' to identify which of the given chain types we could plausibly use as the refined type for the expressions in the chain.

Similarly, 'coerce_only_in_literal_context' controls whether we should try coercing expressions in the chain to a Literal type. Performing this coercion is sometimes too aggressive of a narrowing, depending on context.

Checks if the given expr is a 'lookup operation' into a union and iteratively refines the parent types based on the 'expr_type'.

For example, if 'expr' is an expression like 'a.b.c.d', we'll potentially return refined types for expressions 'a', 'a.b', and 'a.b.c'.

For more details about what a 'lookup operation' is and how we use the expr_type to refine the parent types of lookup_expr, see the docstring in 'propagate_up_typemap_info'.

Cleanup stale state that might be left over from a typechecking run.

This allows us to reuse TypeChecker objects in fine-grained incremental mode.

Store best known type for variable if type inference failed.

If a program ignores error on type inference error, the variable should get some inferred type so that if can used later on in the program. Example:

x = [] # type: ignore x.append(1) # Should be ok!

We implement this here by giving x a valid type (replacing inferred <nothing> with Any).

Store inferred variable type.

Store the type to both the variable node and the expression node that refers to the variable (lvalue). If var is None, do nothing.

Undocumented

Undocumented

Splits a list of items in three to match another list of length 'length' that contains a starred expression at 'star_index' in the following way:

star_index = 2, length = 5 (i.e., [a,b,*,c,d]), items = [1,2,3,4,5,6,7] returns in: ([1,2], [3,4,5], [6,7])

Try to infer a precise type for partial generic type from assignment.

'op' is '=' for normal assignment and a binary operator ('+', ...) for augmented assignment.

Example where this happens:

x = [] if foo():

x = [1] # Infer List[int] as type of 'x'

Undocumented

Undocumented

Undocumented

Undocumented

Type check an assignment statement.

Handle all kinds of assignment statements (simple, indexed, multiple).

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Type check a try statement, ignoring the finally block.

On entry, the top frame should receive all flow that exits the try block abnormally (i.e., such that the else block does not execute), and its parent should receive all flow that exits the try block normally.

Undocumented