mypy.semanal.SemanticAnalyzer

Construct semantic analyzer.

We reuse the same semantic analyzer instance across multiple modules.

Args:

modules: Global modules dictionary missing_modules: Modules that could not be imported encountered so far incomplete_namespaces: Namespaces that are being populated during semantic analysis

(can contain modules and classes within the current SCC; mutated by the caller)

errors: Report analysis errors using this instance

Undocumented

Add builtin type aliases to typing module.

For historical reasons, the aliases like List = list are not defined in typeshed stubs for typing module. Instead we need to manually add the corresponding nodes on the fly. We explicitly mark these aliases as normalized, so that a user can write typing.List[int].

Undocumented

Undocumented

Add dependency from trigger to a target.

If the target is not given explicitly, use the current target.

Add a symbol table node that reflects a redefinition as a function or a class.

Redefinitions need to be added to the symbol table so that they can be found through AST traversal, but they have dummy names of form 'name-redefinition[N]', where N ranges over 2, 3, ... (omitted for the first redefinition).

Note: we always store redefinitions independently of whether they are valid or not (so they will be semantically analyzed), the caller should give an error for invalid redefinitions (such as e.g. variable redefined as a class).

Add symbol to the currently active symbol table.

Generally additions to symbol table should go through this method or one of the methods below so that kinds, redefinitions, conditional definitions, and skipped names are handled consistently.

Return True if we actually added the symbol, or False if we refused to do so (because something is not ready).

If can_defer is True, defer current target if adding a placeholder.

Same as above, but skipping the local namespace.

This doesn't check for previous definition and is only used for serialization of method-level classes.

Classes defined within methods can be exposed through an attribute type, but method-level symbol tables aren't serialized. This method can be used to add such classes to an enclosing, serialized symbol table.

Add symbol table node to the currently active symbol table.

Return True if we actually added the symbol, or False if we refused to do so (because something is not ready or it was a no-op).

Generate an error if there is an invalid redefinition.

If context is None, unconditionally add node, since we can't report an error. Note that this is used by plugins to forcibly replace nodes!

TODO: Prevent plugins from replacing nodes, as it could cause problems?

Args:

name: short name of symbol symbol: Node to add can_defer: if True, defer current target if adding a placeholder context: error context (see above about None value)

Add full names of type aliases on which the current node depends.

This is used by fine-grained incremental mode to re-check the corresponding nodes. If target is None, then the target node used will be the current scope.

Typing extensions module does contain some type aliases.

We need to analyze them as such, because in typeshed they are just defined as _Alias() call. Which is not supported natively.

Add symbol that we don't know what it points to because resolving an import failed.

This can happen if a module is missing, or it is present, but doesn't have the imported attribute. The target_name is the name of symbol in the namespace it is imported from. For example, for 'from mod import x as y' the target_name is 'mod.x'. This is currently used only to track logical dependencies.

Undocumented

Semantically analyze a type.

Args:

typ: Type to analyze (if already analyzed, this is a no-op) allow_placeholder: If True, may return PlaceholderType if

encountering an incomplete definition

third_pass: Unused; only for compatibility with old semantic

analyzer

Return None only if some part of the type couldn't be bound and it referred to an incomplete namespace or definition. In this case also defer as needed. During a final iteration this won't return None; instead report an error if the type can't be analyzed and return AnyType.

In case of other errors, report an error message and return AnyType.

NOTE: The caller shouldn't defer even if this returns None or a

placeholder type.

Check if 'rvalue' is a valid type allowed for aliasing (e.g. not a type variable).

If yes, return the corresponding type, a list of qualified type variable names for generic aliases, a set of names the alias depends on, and a list of type variables if the alias is generic. An schematic example for the dependencies:

A = int B = str analyze_alias(Dict[A, B])[2] == {'__main__.A', '__main__.B'}

Undocumented

Analyze base class types.

Return None if some definition was incomplete. Otherwise, return a tuple with these items:

• List of (analyzed type, original expression) tuples
• Boolean indicating whether one of the bases had a semantic analysis error

Undocumented

Undocumented

Undocumented

Analyze type variables declared using Generic[...] or Protocol[...].

Args:

base: Non-analyzed base class

Return None if the base class does not declare type variables. Otherwise, return the type variables.

Analyses the 'comp_for' part of comprehensions (part 1).

That is the part after 'for' in (x for x in l if p). This analyzes variables and conditions which are analyzed in a local scope.

Analyses the 'comp_for' part of comprehensions (part 2).

That is the part after 'for' in (x for x in l if p). This analyzes the 'l' part which is analyzed in the surrounding scope.

Undocumented

Undocumented

Special case 'X = X' in global scope.

This allows supporting some important use cases.

Return true if special casing was applied.

Analyze an lvalue or assignment target.

Args:

lval: The target lvalue nested: If true, the lvalue is within a tuple or list lvalue expression explicit_type: Assignment has type annotation escape_comprehensions: If we are inside a comprehension, set the variable

in the enclosing scope instead. This implements https://www.python.org/dev/peps/pep-0572/#scope-of-the-target

Undocumented

Analyze lvalue that is a member expression.

Arguments:

lval: The target lvalue explicit_type: Assignment has type annotation is_final: Is the target final

Undocumented

Analyze an lvalue that targets a name expression.

Arguments are similar to "analyze_lvalue".

Find overload signatures, the implementation, and items with missing @overload.

Assume that the first was already analyzed. As a side effect: analyzes remaining items and updates 'is_overload' flags.

Undocumented

Analyze a property defined using multiple methods (e.g., using @x.setter).

Assume that the first method (@property) has already been analyzed.

Return builtins.int if rvalue is an int literal, etc.

If this is a 'Final' context, we return "Literal[...]" instead.

Undocumented

Analyze type arguments (index) in a type application.

Return None if anything was incomplete.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Calculate method resolution order for a class.

obj_type may be omitted in the third pass when all classes are already analyzed. It exists just to fill in empty base class list during second pass in case of an import cycle.

Is this a valid r.h.s. for an alias definition?

Note: this function should be only called for expressions where self.should_wait_rhs() returns False.

Undocumented

Check if assignment creates a type alias and set it up as needed.

Return True if it is a type alias (even if the target is not ready), or False otherwise.

Note: the resulting types for subscripted (including generic) aliases are also stored in rvalue.analyzed.

Undocumented

Undocumented

Do basic checks for final declaration on self in __init__.

Additional re-definition checks are performed by analyze_lvalue.

Verify that expr has specified number of positional args.

Return True if the arguments are valid.

Undocumented

Undocumented

Undocumented

Remove extra base classes such as Generic and infer type vars.

For example, consider this class:

class Foo(Bar, Generic[T]): ...

Now we will remove Generic[T] from bases of Foo and infer that the type variable 'T' is a type argument of Foo.

Note that this is performed before semantic analysis.

Returns (remaining base expressions, inferred type variables, is protocol).

Set up base classes.

This computes several attributes on the corresponding TypeInfo defn.info related to the base classes: defn.info.bases, defn.info.mro, and miscellaneous others (at least tuple_type, fallback_to_any, and is_enum.)

Undocumented

Undocumented

Undocumented

Create a dummy variable using module-level __getattr__ return type.

If not possible, return None.

Note that multiple Var nodes can be created for a single name. We can use the from_module_getattr and the fullname attributes to check if two dummy Var nodes refer to the same thing. Reusing Var nodes would require non-local mutable state, which we prefer to avoid.

Undocumented

Get currently active symbol table.

May be module, class, or local namespace.

Defer current analysis target to be analyzed again.

This must be called if something in the current target is incomplete or has a placeholder node. However, this must not be called during the final analysis iteration! Instead, an error should be generated. Often 'process_placeholder' is a good way to either defer or generate an error.

NOTE: Some methods, such as 'anal_type', 'mark_incomplete' and

'record_incomplete_ref', call this implicitly, or when needed. They are usually preferable to a direct defer() call.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Configure analyzer for analyzing targets within a file/class.

Args:

file_node: target file options: options specific to the file active_type: must be the surrounding class to analyze method targets

Undocumented

Look up a symbol from a module.

Return None if no matching symbol could be bound.

Generate errors for overload items without @overload.

Side effect: remote non-overload items.

Should we type-check the current function?

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

Can a symbol defined in class body accessed at current statement?

Only allow access to class attributes textually after the definition, so that it's possible to fall back to the outer scope. Example:

class X: ...

class C:

X = X # Initializer refers to outer scope

Nested classes are an exception, since we want to support arbitrary forward references in type annotations.

Undocumented

Check whether a protocol member is annotated.

There are some exceptions that can be left unannotated, like __slots__.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Is a module or class namespace potentially missing some definitions?

If a name is missing from an incomplete namespace, we'll need to defer the current analysis target.

Undocumented

Undocumented

Undocumented

Undocumented

Is this a r.h.s. for a None alias?

We special case the assignments like Void = type(None), to allow using Void in type annotations.

Check if a node is defined textually before the current statement

Note that decorated functions' line number are the same as the top decorator.

Does this expression refer to a type?

This includes:

• Special forms, like Any or Union
• Classes (except subscripted enums)
• Other type aliases
• PlaceholderNodes with becomes_typeinfo=True (these can be not ready class definitions, and not ready aliases).

If bare is True, this is not a base of an index expression, so some special forms are not valid (like a bare Union).

Note: This method should be only used in context of a type alias definition. This method can only return True for RefExprs, to check if C[int] is a valid target for type alias call this method on expr.base (i.e. on C in C[int]). See also can_be_type_alias().

Undocumented

Look up an unqualified (no dots) name in all active namespaces.

Note that the result may contain a PlaceholderNode. The caller may want to defer in that case.

Generate an error if the name is not defined unless suppress_errors is true or the current namespace is incomplete. In the latter case defer.

Undocumented

Lookup a symbol by its fully qualified name.

Raise an error if not found.

Lookup a fully qualified name that refers to a module-level definition.

Don't assume that the name is defined. This happens in the global namespace -- the local module namespace is ignored. This does not dereference indirect refs.

Note that this can't be used for names nested in class namespaces.

Lookup a qualified name in all activate namespaces.

Note that the result may contain a PlaceholderNode. The caller may want to defer in that case.

Generate an error if the name is not defined unless suppress_errors is true or the current namespace is incomplete. In the latter case defer.

Undocumented

Undocumented

Update an lvalue to point to existing definition in the same scope.

Arguments are similar to "analyze_lvalue".

Assume that an existing name exists.

Mark a definition as incomplete (and defer current analysis target).

Also potentially mark the current namespace as incomplete.

Args:

name: The name that we weren't able to define (or '*' if the name is unknown) node: The node that refers to the name (definition or lvalue) becomes_typeinfo: Pass this to PlaceholderNode (used by special forms like

named tuples that will create TypeInfos).

Undocumented

Undocumented

Construct an instance of a type with given type arguments.

Return None if a type could not be constructed for the qualified type name. This is possible when the qualified name includes a module name and the module has not been imported.

Undocumented

Undocumented

Add certain special-cased definitions to the builtins module.

Some definitions are too special or fundamental to be processed normally from the AST.

Prepare for the analysis of a class definition.

Create an empty TypeInfo and store it in a symbol table, or if the 'info' argument is provided, store it instead (used for magic type definitions).

Remove dummy alias definitions such as List = TypeAlias(object) from typing.

They will be replaced with real aliases when corresponding targets are ready.

Undocumented

Processing __slots__ if defined in type.

See: https://docs.python.org/3/reference/datamodel.html#slots

Undocumented

Undocumented

Propagate module references across assignments.

Recursively handles the simple form of iterable unpacking; doesn't handle advanced unpacking with *rest, dictionary unpacking, etc.

In an expression like x = y = z, z is the rval and lvals will be [x, y].

Checks if s declares a ParamSpec; if yes, store it in symbol table.

Return True if this looks like a ParamSpec (maybe with errors), otherwise return False.

In the future, ParamSpec may accept bounds and variance arguments, in which case more aggressive sharing of code with process_typevar_declaration should be pursued.

Process a reference targeting placeholder node.

If this is not a final iteration, defer current node, otherwise report an error.

The 'kind' argument indicates if this a name or attribute expression (used for better error message).

Undocumented

Check if s declares a TypeVar; it yes, store it in symbol table.

Return True if this looks like a type variable declaration (but maybe with errors), otherwise return False.

Undocumented

Record minimal necessary information about l.h.s. of a special form.

This exists mostly for compatibility with the old semantic analyzer.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

If 'new' conditionally redefine 'previous', set 'previous' as original

We reject straight redefinitions of functions, as they are usually a programming error. For example:

def f(): ... def f(): ... # Error: 'f' redefined

Can we already classify this r.h.s. of an assignment or should we wait?

This returns True if we don't have enough information to decide whether an assignment is just a normal variable definition or a special form. Always return False if this is a final iteration. This will typically cause the lvalue to be classified as a variable plus emit an error.

Undocumented

Undocumented

Translate 'dict(x=y, ...)' to {'x': y, ...} and 'dict()' to {}.

For other variants of dict(...), return None.

Undocumented

Undocumented

Undocumented

Strip Final[...] if present in an assignment.

This is done to invoke type inference during type checking phase for this assignment. Also, Final[...] doesn't affect type in any way -- it is rather an access qualifier for given Var.

Also perform various consistency checks.

Returns True if Final[...] was present.

Make any type variables in the signature of defn explicit.

Update the signature of defn to contain type variable definitions if defn is generic.

Lookup for special metaclass declarations, and update defn fields accordingly.

• __metaclass__ attribute in Python 2
• six.with_metaclass(M, B1, B2, ...)
• @six.add_metaclass(M)
• future.utils.with_metaclass(M, B1, B2, ...)
• past.utils.with_metaclass(M, B1, B2, ...)

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented