mypy.semanal

module documentation

(source)

The semantic analyzer.

Bind names to definitions and do various other simple consistency checks. Populate symbol tables. The semantic analyzer also detects special forms which reuse generic syntax such as NamedTuple and cast(). Multiple analysis iterations may be needed to analyze forward references and import cycles. Each iteration "fills in" additional bindings and references until everything has been bound.

For example, consider this program:

x = 1 y = x

Here semantic analysis would detect that the assignment 'x = 1' defines a new variable, the type of which is to be inferred (in a later pass; type inference or type checking is not part of semantic analysis). Also, it would bind both references to 'x' to the same module-level variable (Var) node. The second assignment would also be analyzed, and the type of 'y' marked as being inferred.

Semantic analysis of types is implemented in typeanal.py.

See semanal_main.py for the top-level logic.

Some important properties:

After semantic analysis is complete, no PlaceholderNode and PlaceholderType instances should remain. During semantic analysis, if we encounter one of these, the current target should be deferred.
A TypeInfo is only created once we know certain basic information about a type, such as the MRO, existence of a Tuple base class (e.g., for named tuples), and whether we have a TypedDict. We use a temporary PlaceholderNode node in the symbol table if some such information is missing.
For assignments, we only add a non-placeholder symbol table entry once we know the sort of thing being defined (variable, NamedTuple, type alias, etc.).
Every part of the analysis step must support multiple iterations over the same AST nodes, and each iteration must be able to fill in arbitrary things that were missing or incomplete in previous iterations.
Changes performed by the analysis need to be reversible, since mypy daemon strips and reuses existing ASTs (to improve performance and/or reduce memory use).

Class	`HasPlaceholders`	Undocumented
Class	`MakeAnyNonExplicit`	Undocumented
Class	`SemanticAnalyzer`	Semantically analyze parsed mypy files.
Function	`apply_semantic_analyzer_patches`	Call patch callbacks in the right order.
Function	`dummy_context`	Undocumented
Function	`find_duplicate`	If the list has duplicates, return one of the duplicates.
Function	`has_placeholder`	Check if a type contains any placeholder types (recursively).
Function	`is_same_symbol`	Undocumented
Function	`is_same_var_from_getattr`	Do n1 and n2 refer to the same Var derived from module-level __getattr__?
Function	`is_valid_replacement`	Can symbol table node replace an existing one?
Function	`make_any_non_explicit`	Replace all Any types within in with Any that has attribute 'explicit' set to False
Function	`names_modified_by_assignment`	Return all unqualified (short) names assigned to in an assignment statement.
Function	`names_modified_in_lvalue`	Return all NameExpr assignment targets in an Lvalue.
Function	`refers_to_class_or_function`	Does semantically analyzed node refer to a class?
Function	`refers_to_fullname`	Is node a name or member expression with the given full name?
Function	`remove_imported_names_from_symtable`	Remove all imported names from the symbol table of a module.
Function	`replace_implicit_first_type`	Undocumented
Constant	`CORE_BUILTIN_CLASSES`	Undocumented
Constant	`FUTURE_IMPORTS`	Undocumented
Constant	`T`	Undocumented

def apply_semantic_analyzer_patches(patches): (source)

Call patch callbacks in the right order.

This should happen after semantic analyzer pass 3.

Parameters
patches:`List[Tuple[int, Callable[[], None]]]`	Undocumented

def dummy_context(): (source)

Undocumented

Returns
`Context`	Undocumented

def find_duplicate(list): (source)

If the list has duplicates, return one of the duplicates.

Otherwise, return None.

Parameters
list:`List[T]`	Undocumented
Returns
`Optional[T]`	Undocumented

def has_placeholder(typ): (source)

Check if a type contains any placeholder types (recursively).

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

def is_same_symbol(a, b): (source)

Undocumented

Parameters
a:`Optional[SymbolNode]`	Undocumented
b:`Optional[SymbolNode]`	Undocumented
Returns
`bool`	Undocumented

def is_same_var_from_getattr(n1, n2): (source)

Do n1 and n2 refer to the same Var derived from module-level __getattr__?

Parameters
n1:`Optional[SymbolNode]`	Undocumented
n2:`Optional[SymbolNode]`	Undocumented
Returns
`bool`	Undocumented

def is_valid_replacement(old, new): (source)

Can symbol table node replace an existing one?

These are the only valid cases:

Placeholder gets replaced with a non-placeholder
Placeholder that isn't known to become type replaced with a placeholder that can become a type

Parameters
old:`SymbolTableNode`	Undocumented
new:`SymbolTableNode`	Undocumented
Returns
`bool`	Undocumented

def make_any_non_explicit(t): (source)

Replace all Any types within in with Any that has attribute 'explicit' set to False

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

def names_modified_by_assignment(s): (source)

Return all unqualified (short) names assigned to in an assignment statement.

Parameters
s:`AssignmentStmt`	Undocumented
Returns
`List[NameExpr]`	Undocumented

def names_modified_in_lvalue(lvalue): (source)

Return all NameExpr assignment targets in an Lvalue.

Parameters
lvalue:`Lvalue`	Undocumented
Returns
`List[NameExpr]`	Undocumented

def refers_to_class_or_function(node): (source)

Does semantically analyzed node refer to a class?

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

def refers_to_fullname(node, fullname): (source)

Is node a name or member expression with the given full name?

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

def remove_imported_names_from_symtable(names, module): (source)

Remove all imported names from the symbol table of a module.

Parameters
names:`SymbolTable`	Undocumented
module:`str`	Undocumented

def replace_implicit_first_type(sig, new): (source)

Undocumented

Parameters
sig:`FunctionLike`	Undocumented
new:`Type`	Undocumented
Returns
`FunctionLike`	Undocumented

CORE_BUILTIN_CLASSES: list[str] = (source)

Undocumented

Value

['object', 'bool', 'function']

FUTURE_IMPORTS: dict[str, str] = (source)

Undocumented

Value

{'__future__.nested_scopes': 'nested_scopes',
 '__future__.generators': 'generators',
 '__future__.division': 'division',
 '__future__.absolute_import': 'absolute_import',
 '__future__.with_statement': 'with_statement',
 '__future__.print_function': 'print_function',
 '__future__.unicode_literals': 'unicode_literals',
...

T = (source)

Undocumented

Value

TypeVar('T')