"""The semantic analyzer passes 1 and 2.

Bind names to definitions and do various other simple consistency

checks. 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 is the first analysis pass after parsing, and it is

subdivided into three passes:

* SemanticAnalyzerPass1 is defined in mypy.semanal_pass1.

* SemanticAnalyzerPass2 is the second pass. It does the bulk of the work.

It assumes that dependent modules have been semantically analyzed,

up to the second pass, unless there is a import cycle.

* SemanticAnalyzerPass3 is the third pass. It's in mypy.semanal_pass3.

Semantic analysis of types is implemented in module mypy.typeanal.

TODO: Check if the third pass slows down type checking significantly.

We could probably get rid of it -- for example, we could collect all

analyzed types in a collection and check them without having to

traverse the entire AST.

"""

from contextlib import contextmanager

from typing import (

List, Dict, Set, Tuple, cast, TypeVar, Union, Optional, Callable, Iterator, Iterable

)

from mypy.nodes import (

MypyFile, TypeInfo, Node, AssignmentStmt, FuncDef, OverloadedFuncDef,

ClassDef, Var, GDEF, MODULE_REF, FuncItem, Import, Expression, Lvalue,

ImportFrom, ImportAll, Block, LDEF, NameExpr, MemberExpr,

IndexExpr, TupleExpr, ListExpr, ExpressionStmt, ReturnStmt,

RaiseStmt, AssertStmt, OperatorAssignmentStmt, WhileStmt,

ForStmt, BreakStmt, ContinueStmt, IfStmt, TryStmt, WithStmt, DelStmt, PassStmt,

GlobalDecl, SuperExpr, DictExpr, CallExpr, RefExpr, OpExpr, UnaryExpr,

SliceExpr, CastExpr, RevealTypeExpr, TypeApplication, Context, SymbolTable,

SymbolTableNode, TVAR, ListComprehension, GeneratorExpr,

LambdaExpr, MDEF, FuncBase, Decorator, SetExpr, TypeVarExpr, NewTypeExpr,

StrExpr, BytesExpr, PrintStmt, ConditionalExpr, PromoteExpr,

ComparisonExpr, StarExpr, ARG_POS, ARG_NAMED, ARG_NAMED_OPT, MroError, type_aliases,

YieldFromExpr, NamedTupleExpr, TypedDictExpr, NonlocalDecl, SymbolNode,

SetComprehension, DictionaryComprehension, TYPE_ALIAS, TypeAliasExpr,

YieldExpr, ExecStmt, Argument, BackquoteExpr, ImportBase, AwaitExpr,

IntExpr, FloatExpr, UnicodeExpr, EllipsisExpr, TempNode, EnumCallExpr, ImportedName,

COVARIANT, CONTRAVARIANT, INVARIANT, UNBOUND_IMPORTED, LITERAL_YES, ARG_OPT, nongen_builtins,

collections_type_aliases, get_member_expr_fullname,

)

from mypy.literals import literal

from mypy.tvar_scope import TypeVarScope

from mypy.typevars import fill_typevars

from mypy.visitor import NodeVisitor

from mypy.traverser import TraverserVisitor

from mypy.errors import Errors, report_internal_error

from mypy.messages import CANNOT_ASSIGN_TO_TYPE, MessageBuilder

from mypy.types import (

FunctionLike, UnboundType, TypeVarDef, TypeType, TupleType, UnionType, StarType, function_type,

TypedDictType, NoneTyp, CallableType, Overloaded, Instance, Type, TypeVarType, AnyType,

TypeTranslator, TypeOfAny, TypeVisitor, UninhabitedType, ErasedType, DeletedType

)

from mypy.nodes import implicit_module_attrs

from mypy.typeanal import (

TypeAnalyser, analyze_type_alias, no_subscript_builtin_alias,

TypeVariableQuery, TypeVarList, remove_dups, has_any_from_unimported_type,

check_for_explicit_any

)

from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError

from mypy.sametypes import is_same_type

from mypy.options import Options

from mypy import experiments

from mypy.plugin import Plugin, ClassDefContext, SemanticAnalyzerPluginInterface

from mypy import join

from mypy.util import get_prefix, correct_relative_import

from mypy.semanal_shared import SemanticAnalyzerInterface, set_callable_name, PRIORITY_FALLBACKS

from mypy.scope import Scope

from mypy.semanal_namedtuple import NamedTupleAnalyzer, NAMEDTUPLE_PROHIBITED_NAMES

from mypy.semanal_typeddict import TypedDictAnalyzer

from mypy.semanal_enum import EnumCallAnalyzer

from mypy.semanal_newtype import NewTypeAnalyzer

T = TypeVar('T')

# Inferred truth value of an expression.

ALWAYS_TRUE = 1

MYPY_TRUE = 2 # True in mypy, False at runtime

ALWAYS_FALSE = 3

MYPY_FALSE = 4 # False in mypy, True at runtime

TRUTH_VALUE_UNKNOWN = 5

inverted_truth_mapping = {

ALWAYS_TRUE: ALWAYS_FALSE,

ALWAYS_FALSE: ALWAYS_TRUE,

TRUTH_VALUE_UNKNOWN: TRUTH_VALUE_UNKNOWN,

MYPY_TRUE: MYPY_FALSE,

MYPY_FALSE: MYPY_TRUE,

}

# Map from obsolete name to the current spelling.

obsolete_name_mapping = {

'typing.Function': 'typing.Callable',

'typing.typevar': 'typing.TypeVar',

}

# Hard coded type promotions (shared between all Python versions).

# These add extra ad-hoc edges to the subtyping relation. For example,

# int is considered a subtype of float, even though there is no

# subclass relationship.

TYPE_PROMOTIONS = {

'builtins.int': 'builtins.float',

'builtins.float': 'builtins.complex',

}

# Hard coded type promotions for Python 3.

#

# Note that the bytearray -> bytes promotion is a little unsafe

# as some functions only accept bytes objects. Here convenience

# trumps safety.

TYPE_PROMOTIONS_PYTHON3 = TYPE_PROMOTIONS.copy()

TYPE_PROMOTIONS_PYTHON3.update({

'builtins.bytearray': 'builtins.bytes',

})

# Hard coded type promotions for Python 2.

#

# These promotions are unsafe, but we are doing them anyway

# for convenience and also for Python 3 compatibility

# (bytearray -> str).

TYPE_PROMOTIONS_PYTHON2 = TYPE_PROMOTIONS.copy()

TYPE_PROMOTIONS_PYTHON2.update({

'builtins.str': 'builtins.unicode',

'builtins.bytearray': 'builtins.str',

})

# When analyzing a function, should we analyze the whole function in one go, or

# should we only perform one phase of the analysis? The latter is used for

# nested functions. In the first phase we add the function to the symbol table

# but don't process body. In the second phase we process function body. This

# way we can have mutually recursive nested functions.

FUNCTION_BOTH_PHASES = 0 # Everything in one go

FUNCTION_FIRST_PHASE_POSTPONE_SECOND = 1 # Add to symbol table but postpone body

FUNCTION_SECOND_PHASE = 2 # Only analyze body

# Map from the full name of a missing definition to the test fixture (under

# test-data/unit/fixtures/) that provides the definition. This is used for

# generating better error messages when running mypy tests only.

SUGGESTED_TEST_FIXTURES = {

'typing.List': 'list.pyi',

'typing.Dict': 'dict.pyi',

'typing.Set': 'set.pyi',

'builtins.bool': 'bool.pyi',

'builtins.Exception': 'exception.pyi',

'builtins.BaseException': 'exception.pyi',

'builtins.isinstance': 'isinstancelist.pyi',

'builtins.property': 'property.pyi',

'builtins.classmethod': 'classmethod.pyi',

}

class SemanticAnalyzerPass2(NodeVisitor[None],

SemanticAnalyzerInterface,

SemanticAnalyzerPluginInterface):

"""Semantically analyze parsed mypy files.

The analyzer binds names and does various consistency checks for a

parse tree. Note that type checking is performed as a separate

pass.

This is the second phase of semantic analysis.

"""

# Library search paths

lib_path = None # type: List[str]

# Module name space

modules = None # type: Dict[str, MypyFile]

# Global name space for current module

globals = None # type: SymbolTable

# Names declared using "global" (separate set for each scope)

global_decls = None # type: List[Set[str]]

# Names declated using "nonlocal" (separate set for each scope)

nonlocal_decls = None # type: List[Set[str]]

# Local names of function scopes; None for non-function scopes.

locals = None # type: List[Optional[SymbolTable]]

# Nested block depths of scopes

block_depth = None # type: List[int]

# TypeInfo of directly enclosing class (or None)

type = None # type: Optional[TypeInfo]

# Stack of outer classes (the second tuple item contains tvars).

type_stack = None # type: List[Optional[TypeInfo]]

# Type variables bound by the current scope, be it class or function

tvar_scope = None # type: TypeVarScope

# Per-module options

options = None # type: Options

# Stack of functions being analyzed

function_stack = None # type: List[FuncItem]

# Status of postponing analysis of nested function bodies. By using this we

# can have mutually recursive nested functions. Values are FUNCTION_x

# constants. Note that separate phasea are not used for methods.

postpone_nested_functions_stack = None # type: List[int]

# Postponed functions collected if

# postpone_nested_functions_stack[-1] == FUNCTION_FIRST_PHASE_POSTPONE_SECOND.

postponed_functions_stack = None # type: List[List[Node]]

loop_depth = 0 # Depth of breakable loops

cur_mod_id = '' # Current module id (or None) (phase 2)

is_stub_file = False # Are we analyzing a stub file?

is_typeshed_stub_file = False # Are we analyzing a typeshed stub file?

imports = None # type: Set[str] # Imported modules (during phase 2 analysis)

errors = None # type: Errors # Keeps track of generated errors

plugin = None # type: Plugin # Mypy plugin for special casing of library features

def __init__(self,

modules: Dict[str, MypyFile],

missing_modules: Set[str],

lib_path: List[str], errors: Errors,

plugin: Plugin) -> None:

"""Construct semantic analyzer.

Use lib_path to search for modules, and report analysis errors

using the Errors instance.

"""

self.locals = [None]

self.imports = set()

self.type = None

self.type_stack = []

self.tvar_scope = TypeVarScope()

self.function_stack = []

self.block_depth = [0]

self.loop_depth = 0

self.lib_path = lib_path

self.errors = errors

self.modules = modules

self.msg = MessageBuilder(errors, modules)

self.missing_modules = missing_modules

self.postpone_nested_functions_stack = [FUNCTION_BOTH_PHASES]

self.postponed_functions_stack = []

self.all_exports = set() # type: Set[str]

self.plugin = plugin

# If True, process function definitions. If False, don't. This is used

# for processing module top levels in fine-grained incremental mode.

self.recurse_into_functions = True

self.scope = Scope()

def visit_file(self, file_node: MypyFile, fnam: str, options: Options,

patches: List[Tuple[int, Callable[[], None]]]) -> None:

"""Run semantic analysis phase 2 over a file.

Add (priority, callback) pairs by mutating the 'patches' list argument. They

will be called after all semantic analysis phases but before type checking,

lowest priority values first.

"""

self.recurse_into_functions = True

self.options = options

self.errors.set_file(fnam, file_node.fullname(), scope=self.scope)

self.cur_mod_node = file_node

self.cur_mod_id = file_node.fullname()

self.is_stub_file = fnam.lower().endswith('.pyi')

self.is_typeshed_stub_file = self.errors.is_typeshed_file(file_node.path)

self.globals = file_node.names

self.patches = patches

self.named_tuple_analyzer = NamedTupleAnalyzer(options, self)

self.typed_dict_analyzer = TypedDictAnalyzer(options, self, self.msg)

self.enum_call_analyzer = EnumCallAnalyzer(options, self)

self.newtype_analyzer = NewTypeAnalyzer(options, self, self.msg)

with experiments.strict_optional_set(options.strict_optional):

if 'builtins' in self.modules:

self.globals['__builtins__'] = SymbolTableNode(MODULE_REF,

self.modules['builtins'])

for name in implicit_module_attrs:

v = self.globals[name].node

if isinstance(v, Var):

assert v.type is not None, "Type of implicit attribute not set"

v.type = self.anal_type(v.type)

v.is_ready = True

defs = file_node.defs

self.scope.enter_file(file_node.fullname())

for d in defs:

self.accept(d)

self.scope.leave()

if self.cur_mod_id == 'builtins':

remove_imported_names_from_symtable(self.globals, 'builtins')

for alias_name in type_aliases:

self.globals.pop(alias_name.split('.')[-1], None)

if '__all__' in self.globals:

for name, g in self.globals.items():

if name not in self.all_exports:

g.module_public = False

del self.options

del self.patches

del self.cur_mod_node

del self.globals

def refresh_partial(self, node: Union[MypyFile, FuncItem, OverloadedFuncDef],

patches: List[Tuple[int, Callable[[], None]]]) -> None:

"""Refresh a stale target in fine-grained incremental mode."""

self.patches = patches

if isinstance(node, MypyFile):

self.refresh_top_level(node)

else:

self.recurse_into_functions = True

self.accept(node)

del self.patches

def refresh_top_level(self, file_node: MypyFile) -> None:

"""Reanalyze a stale module top-level in fine-grained incremental mode."""

self.recurse_into_functions = False

for d in file_node.defs:

self.accept(d)

@contextmanager

def file_context(self, file_node: MypyFile, fnam: str, options: Options,

active_type: Optional[TypeInfo],

scope: Optional[Scope] = None) -> Iterator[None]:

# TODO: Use this above in visit_file

scope = scope or self.scope

self.options = options

self.errors.set_file(fnam, file_node.fullname(), scope=scope)

self.cur_mod_node = file_node

self.cur_mod_id = file_node.fullname()

scope.enter_file(self.cur_mod_id)

self.is_stub_file = fnam.lower().endswith('.pyi')

self.is_typeshed_stub_file = self.errors.is_typeshed_file(file_node.path)

self.globals = file_node.names

self.tvar_scope = TypeVarScope()

if active_type:

scope.enter_class(active_type)

self.enter_class(active_type.defn.info)

for tvar in active_type.defn.type_vars:

self.tvar_scope.bind_existing(tvar)

yield

if active_type:

scope.leave()

self.leave_class()

self.type = None

scope.leave()

del self.options

def visit_func_def(self, defn: FuncDef) -> None:

if not self.recurse_into_functions:

return

with self.scope.function_scope(defn):

self._visit_func_def(defn)

def _visit_func_def(self, defn: FuncDef) -> None:

phase_info = self.postpone_nested_functions_stack[-1]

if phase_info != FUNCTION_SECOND_PHASE:

self.function_stack.append(defn)

# First phase of analysis for function.

if not defn._fullname:

defn._fullname = self.qualified_name(defn.name())

if defn.type:

assert isinstance(defn.type, CallableType)

self.update_function_type_variables(defn.type, defn)

self.function_stack.pop()

defn.is_conditional = self.block_depth[-1] > 0

# TODO(jukka): Figure out how to share the various cases. It doesn't

# make sense to have (almost) duplicate code (here and elsewhere) for

# 3 cases: module-level, class-level and local names. Maybe implement

# a common stack of namespaces. As the 3 kinds of namespaces have

# different semantics, this wouldn't always work, but it might still

# be a win.

if self.is_class_scope():

# Method definition

assert self.type is not None, "Type not set at class scope"

defn.info = self.type

if not defn.is_decorated and not defn.is_overload:

if (defn.name() in self.type.names and

self.type.names[defn.name()].node != defn):

# Redefinition. Conditional redefinition is okay.

n = self.type.names[defn.name()].node

if not self.set_original_def(n, defn):

self.name_already_defined(defn.name(), defn)

self.type.names[defn.name()] = SymbolTableNode(MDEF, defn)

self.prepare_method_signature(defn, self.type)

elif self.is_func_scope():

# Nested function

assert self.locals[-1] is not None, "No locals at function scope"

if not defn.is_decorated and not defn.is_overload:

if defn.name() in self.locals[-1]:

# Redefinition. Conditional redefinition is okay.

n = self.locals[-1][defn.name()].node

if not self.set_original_def(n, defn):

self.name_already_defined(defn.name(), defn)

else:

self.add_local(defn, defn)

else:

# Top-level function

if not defn.is_decorated and not defn.is_overload:

symbol = self.globals[defn.name()]

if isinstance(symbol.node, FuncDef) and symbol.node != defn:

# This is redefinition. Conditional redefinition is okay.

if not self.set_original_def(symbol.node, defn):

# Report error.

self.check_no_global(defn.name(), defn, True)

if phase_info == FUNCTION_FIRST_PHASE_POSTPONE_SECOND:

# Postpone this function (for the second phase).

self.postponed_functions_stack[-1].append(defn)

return

if phase_info != FUNCTION_FIRST_PHASE_POSTPONE_SECOND:

# Second phase of analysis for function.

self.analyze_function(defn)

if defn.is_coroutine and isinstance(defn.type, CallableType):

if defn.is_async_generator:

# Async generator types are handled elsewhere

pass

else:

# A coroutine defined as `async def foo(...) -> T: ...`

# has external return type `Awaitable[T]`.

ret_type = self.named_type_or_none('typing.Awaitable', [defn.type.ret_type])

assert ret_type is not None, "Internal error: typing.Awaitable not found"

defn.type = defn.type.copy_modified(ret_type=ret_type)

def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:

"""Check basic signature validity and tweak annotation of self/cls argument."""

# Only non-static methods are special.

functype = func.type

if not func.is_static:

if not func.arguments:

self.fail('Method must have at least one argument', func)

elif isinstance(functype, CallableType):

self_type = functype.arg_types[0]

if isinstance(self_type, AnyType):

if func.is_class or func.name() in ('__new__', '__init_subclass__'):

leading_type = self.class_type(info)

else:

leading_type = fill_typevars(info)

func.type = replace_implicit_first_type(functype, leading_type)

def set_original_def(self, previous: Optional[Node], new: FuncDef) -> bool:

"""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

"""

if isinstance(previous, (FuncDef, Var, Decorator)) and new.is_conditional:

new.original_def = previous

return True

else:

return False

def update_function_type_variables(self, fun_type: CallableType, defn: FuncItem) -> None:

"""Make any type variables in the signature of defn explicit.

Update the signature of defn to contain type variable definitions

if defn is generic.

"""

with self.tvar_scope_frame(self.tvar_scope.method_frame()):

a = self.type_analyzer()

fun_type.variables = a.bind_function_type_variables(fun_type, defn)

def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:

if not self.recurse_into_functions:

return

# NB: Since _visit_overloaded_func_def will call accept on the

# underlying FuncDefs, the function might get entered twice.

# This is fine, though, because only the outermost function is

# used to compute targets.

with self.scope.function_scope(defn):

self._visit_overloaded_func_def(defn)

def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:

# OverloadedFuncDef refers to any legitimate situation where you have

# more than one declaration for the same function in a row. This occurs

# with a @property with a setter or a deleter, and for a classic

# @overload.

# Decide whether to analyze this as a property or an overload. If an

# overload, and we're outside a stub, find the impl and set it. Remove

# the impl from the item list, it's special.

types = [] # type: List[CallableType]

non_overload_indexes = []

# See if the first item is a property (and not an overload)

first_item = defn.items[0]

first_item.is_overload = True

first_item.accept(self)

defn._fullname = self.qualified_name(defn.name())

if isinstance(first_item, Decorator) and first_item.func.is_property:

first_item.func.is_overload = True

self.analyze_property_with_multi_part_definition(defn)

typ = function_type(first_item.func, self.builtin_type('builtins.function'))

assert isinstance(typ, CallableType)

types = [typ]

else:

for i, item in enumerate(defn.items):

if i != 0:

# The first item was already visited

item.is_overload = True

item.accept(self)

# TODO support decorated overloaded functions properly

if isinstance(item, Decorator):

callable = function_type(item.func, self.builtin_type('builtins.function'))

assert isinstance(callable, CallableType)

if not any(refers_to_fullname(dec, 'typing.overload')

for dec in item.decorators):

if i == len(defn.items) - 1 and not self.is_stub_file:

# Last item outside a stub is impl

defn.impl = item

else:

# Oops it wasn't an overload after all. A clear error

# will vary based on where in the list it is, record

# that.

non_overload_indexes.append(i)

else:

item.func.is_overload = True

types.append(callable)

elif isinstance(item, FuncDef):

if i == len(defn.items) - 1 and not self.is_stub_file:

defn.impl = item

else:

non_overload_indexes.append(i)

if non_overload_indexes:

if types:

# Some of them were overloads, but not all.

for idx in non_overload_indexes:

if self.is_stub_file:

self.fail("An implementation for an overloaded function "

"is not allowed in a stub file", defn.items[idx])

else:

self.fail("The implementation for an overloaded function "

"must come last", defn.items[idx])

else:

for idx in non_overload_indexes[1:]:

self.name_already_defined(defn.name(), defn.items[idx])

if defn.impl:

self.name_already_defined(defn.name(), defn.impl)

# Remove the non-overloads

for idx in reversed(non_overload_indexes):

del defn.items[idx]

# If we found an implementation, remove it from the overloads to

# consider.

if defn.impl is not None:

assert defn.impl is defn.items[-1]

defn.items = defn.items[:-1]

elif not self.is_stub_file and not non_overload_indexes:

if not (self.type and not self.is_func_scope() and self.type.is_protocol):

self.fail(

"An overloaded function outside a stub file must have an implementation",

defn)

else:

for item in defn.items:

if isinstance(item, Decorator):

item.func.is_abstract = True

else:

item.is_abstract = True

if types:

defn.type = Overloaded(types)

defn.type.line = defn.line

if not defn.items:

# It was not any kind of overload def after all. We've visited the

# redfinitions already.

return

if self.type and not self.is_func_scope():

self.type.names[defn.name()] = SymbolTableNode(MDEF, defn,

typ=defn.type)

defn.info = self.type

elif self.is_func_scope():

self.add_local(defn, defn)

def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -> None:

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

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

"""

defn.is_property = True

items = defn.items

first_item = cast(Decorator, defn.items[0])

for item in items[1:]:

if isinstance(item, Decorator) and len(item.decorators) == 1:

node = item.decorators[0]

if isinstance(node, MemberExpr):

if node.name == 'setter':

# The first item represents the entire property.

first_item.var.is_settable_property = True

# Get abstractness from the original definition.

item.func.is_abstract = first_item.func.is_abstract

else:

self.fail("Decorated property not supported", item)

if isinstance(item, Decorator):

item.func.accept(self)

def analyze_function(self, defn: FuncItem) -> None:

is_method = self.is_class_scope()

with self.tvar_scope_frame(self.tvar_scope.method_frame()):

if defn.type:

self.check_classvar_in_signature(defn.type)

assert isinstance(defn.type, CallableType)

# Signature must be analyzed in the surrounding scope so that

# class-level imported names and type variables are in scope.

analyzer = self.type_analyzer()

defn.type = analyzer.visit_callable_type(defn.type, nested=False)

self.add_type_alias_deps(analyzer.aliases_used)

self.check_function_signature(defn)

if isinstance(defn, FuncDef):

assert isinstance(defn.type, CallableType)

defn.type = set_callable_name(defn.type, defn)

for arg in defn.arguments:

if arg.initializer:

arg.initializer.accept(self)

# Bind the type variables again to visit the body.

if defn.type:

a = self.type_analyzer()

a.bind_function_type_variables(cast(CallableType, defn.type), defn)

self.function_stack.append(defn)

self.enter()

for arg in defn.arguments:

self.add_local(arg.variable, defn)

# The first argument of a non-static, non-class method is like 'self'

# (though the name could be different), having the enclosing class's

# instance type.

if is_method and not defn.is_static and not defn.is_class and defn.arguments:

defn.arguments[0].variable.is_self = True

# First analyze body of the function but ignore nested functions.

self.postpone_nested_functions_stack.append(FUNCTION_FIRST_PHASE_POSTPONE_SECOND)

self.postponed_functions_stack.append([])

defn.body.accept(self)

# Analyze nested functions (if any) as a second phase.

self.postpone_nested_functions_stack[-1] = FUNCTION_SECOND_PHASE

for postponed in self.postponed_functions_stack[-1]:

postponed.accept(self)

self.postpone_nested_functions_stack.pop()

self.postponed_functions_stack.pop()

self.leave()

self.function_stack.pop()

def check_classvar_in_signature(self, typ: Type) -> None:

if isinstance(typ, Overloaded):

for t in typ.items(): # type: Type

self.check_classvar_in_signature(t)

return

if not isinstance(typ, CallableType):

return

for t in typ.arg_types + [typ.ret_type]:

if self.is_classvar(t):

self.fail_invalid_classvar(t)

# Show only one error per signature

break

def check_function_signature(self, fdef: FuncItem) -> None:

sig = fdef.type

assert isinstance(sig, CallableType)

if len(sig.arg_types) < len(fdef.arguments):

self.fail('Type signature has too few arguments', fdef)

# Add dummy Any arguments to prevent crashes later.

num_extra_anys = len(fdef.arguments) - len(sig.arg_types)

extra_anys = [AnyType(TypeOfAny.from_error)] * num_extra_anys

sig.arg_types.extend(extra_anys)

elif len(sig.arg_types) > len(fdef.arguments):

self.fail('Type signature has too many arguments', fdef, blocker=True)

def visit_class_def(self, defn: ClassDef) -> None:

with self.scope.class_scope(defn.info):

with self.analyze_class_body(defn) as should_continue:

if should_continue:

# Analyze class body.

defn.defs.accept(self)

@contextmanager

def analyze_class_body(self, defn: ClassDef) -> Iterator[bool]:

with self.tvar_scope_frame(self.tvar_scope.class_frame()):

is_protocol = self.detect_protocol_base(defn)

self.update_metaclass(defn)

self.clean_up_bases_and_infer_type_variables(defn)

self.analyze_class_keywords(defn)

if self.typed_dict_analyzer.analyze_typeddict_classdef(defn):

yield False

return

named_tuple_info = self.named_tuple_analyzer.analyze_namedtuple_classdef(defn)

if named_tuple_info is not None:

# Temporarily clear the names dict so we don't get errors about duplicate names

# that were already set in build_namedtuple_typeinfo.

nt_names = named_tuple_info.names

named_tuple_info.names = SymbolTable()

# This is needed for the cls argument to classmethods to get bound correctly.

named_tuple_info.names['__init__'] = nt_names['__init__']

self.enter_class(named_tuple_info)

yield True

self.leave_class()

# make sure we didn't use illegal names, then reset the names in the typeinfo

for prohibited in NAMEDTUPLE_PROHIBITED_NAMES:

if prohibited in named_tuple_info.names:

if nt_names.get(prohibited) is named_tuple_info.names[prohibited]:

continue

ctx = named_tuple_info.names[prohibited].node

assert ctx is not None

self.fail('Cannot overwrite NamedTuple attribute "{}"'.format(prohibited),

ctx)

# Restore the names in the original symbol table. This ensures that the symbol

# table contains the field objects created by build_namedtuple_typeinfo. Exclude

# __doc__, which can legally be overwritten by the class.

named_tuple_info.names.update({

key: value for key, value in nt_names.items()

if key not in named_tuple_info.names or key != '__doc__'

})

else:

self.setup_class_def_analysis(defn)

self.analyze_base_classes(defn)

self.analyze_metaclass(defn)

defn.info.is_protocol = is_protocol

defn.info.runtime_protocol = False

for decorator in defn.decorators:

self.analyze_class_decorator(defn, decorator)

self.enter_class(defn.info)

yield True

self.calculate_abstract_status(defn.info)

self.setup_type_promotion(defn)

self.apply_class_plugin_hooks(defn)

self.leave_class()

def apply_class_plugin_hooks(self, defn: ClassDef) -> None:

"""Apply a plugin hook that may infer a more precise definition for a class."""

def get_fullname(expr: Expression) -> Optional[str]:

if isinstance(expr, CallExpr):

return get_fullname(expr.callee)

elif isinstance(expr, IndexExpr):

return get_fullname(expr.base)

elif isinstance(expr, RefExpr):

if expr.fullname:

return expr.fullname

# If we don't have a fullname look it up. This happens because base classes are

# analyzed in a different manner (see exprtotype.py) and therefore those AST

# nodes will not have full names.

sym = self.lookup_type_node(expr)

if sym:

return sym.fullname

return None

for decorator in defn.decorators:

decorator_name = get_fullname(decorator)

if decorator_name:

hook = self.plugin.get_class_decorator_hook(decorator_name)

if hook:

hook(ClassDefContext(defn, decorator, self))

if defn.metaclass:

metaclass_name = get_fullname(defn.metaclass)

if metaclass_name:

hook = self.plugin.get_metaclass_hook(metaclass_name)

if hook:

hook(ClassDefContext(defn, defn.metaclass, self))

for base_expr in defn.base_type_exprs:

base_name = get_fullname(base_expr)

if base_name:

hook = self.plugin.get_base_class_hook(base_name)

if hook:

hook(ClassDefContext(defn, base_expr, self))

def analyze_class_keywords(self, defn: ClassDef) -> None:

for value in defn.keywords.values():

value.accept(self)

def enter_class(self, info: TypeInfo) -> None:

# Remember previous active class

self.type_stack.append(self.type)

self.locals.append(None) # Add class scope

self.block_depth.append(-1) # The class body increments this to 0

self.postpone_nested_functions_stack.append(FUNCTION_BOTH_PHASES)

self.type = info

def leave_class(self) -> None:

""" Restore analyzer state. """

self.postpone_nested_functions_stack.pop()

self.block_depth.pop()

self.locals.pop()

self.type = self.type_stack.pop()

def analyze_class_decorator(self, defn: ClassDef, decorator: Expression) -> None:

decorator.accept(self)

if (isinstance(decorator, RefExpr) and

decorator.fullname in ('typing.runtime', 'typing_extensions.runtime')):

if defn.info.is_protocol:

defn.info.runtime_protocol = True

else:

self.fail('@runtime can only be used with protocol classes', defn)

def calculate_abstract_status(self, typ: TypeInfo) -> None:

"""Calculate abstract status of a class.

Set is_abstract of the type to True if the type has an unimplemented

abstract attribute. Also compute a list of abstract attributes.

"""

concrete = set() # type: Set[str]

abstract = [] # type: List[str]

for base in typ.mro:

for name, symnode in base.names.items():

node = symnode.node

if isinstance(node, OverloadedFuncDef):

# Unwrap an overloaded function definition. We can just

# check arbitrarily the first overload item. If the

# different items have a different abstract status, there

# should be an error reported elsewhere.

func = node.items[0] # type: Optional[Node]

else:

func = node

if isinstance(func, Decorator):

fdef = func.func

if fdef.is_abstract and name not in concrete:

typ.is_abstract = True

abstract.append(name)

elif isinstance(node, Var):

if node.is_abstract_var and name not in concrete:

typ.is_abstract = True

abstract.append(name)

concrete.add(name)

typ.abstract_attributes = sorted(abstract)

def setup_type_promotion(self, defn: ClassDef) -> None:

"""Setup extra, ad-hoc subtyping relationships between classes (promotion).

This includes things like 'int' being compatible with 'float'.

"""

promote_target = None # type: Optional[Type]

for decorator in defn.decorators:

if isinstance(decorator, CallExpr):

analyzed = decorator.analyzed

if isinstance(analyzed, PromoteExpr):

# _promote class decorator (undocumented faeture).

promote_target = analyzed.type

if not promote_target:

promotions = (TYPE_PROMOTIONS_PYTHON3 if self.options.python_version[0] >= 3

else TYPE_PROMOTIONS_PYTHON2)

if defn.fullname in promotions:

promote_target = self.named_type_or_none(promotions[defn.fullname])

defn.info._promote = promote_target

def detect_protocol_base(self, defn: ClassDef) -> bool:

for base_expr in defn.base_type_exprs:

try:

base = expr_to_unanalyzed_type(base_expr)

except TypeTranslationError:

continue # This will be reported later

if not isinstance(base, UnboundType):

continue

sym = self.lookup_qualified(base.name, base)

if sym is None or sym.node is None:

continue

if sym.node.fullname() in ('typing.Protocol', 'typing_extensions.Protocol'):

return True

return False

def clean_up_bases_and_infer_type_variables(self, defn: ClassDef) -> None:

"""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.

"""

removed = [] # type: List[int]

declared_tvars = [] # type: TypeVarList

for i, base_expr in enumerate(defn.base_type_exprs):

try:

base = expr_to_unanalyzed_type(base_expr)

except TypeTranslationError:

# This error will be caught later.

continue

tvars = self.analyze_typevar_declaration(base)

if tvars is not None:

if declared_tvars:

self.fail('Only single Generic[...] or Protocol[...] can be in bases', defn)

removed.append(i)

declared_tvars.extend(tvars)

if isinstance(base, UnboundType):

sym = self.lookup_qualified(base.name, base)

if sym is not None and sym.node is not None:

if (sym.node.fullname() in ('typing.Protocol',

'typing_extensions.Protocol') and

i not in removed):

# also remove bare 'Protocol' bases

removed.append(i)

all_tvars = self.get_all_bases_tvars(defn, removed)

if declared_tvars:

if len(remove_dups(declared_tvars)) < len(declared_tvars):

self.fail("Duplicate type variables in Generic[...] or Protocol[...]", defn)

declared_tvars = remove_dups(declared_tvars)

if not set(all_tvars).issubset(set(declared_tvars)):

self.fail("If Generic[...] or Protocol[...] is present"

" it should list all type variables", defn)

# In case of error, Generic tvars will go first

declared_tvars = remove_dups(declared_tvars + all_tvars)

else:

declared_tvars = all_tvars

if declared_tvars:

if defn.info:

defn.info.type_vars = [name for name, _ in declared_tvars]

for i in reversed(removed):

defn.removed_base_type_exprs.append(defn.base_type_exprs[i])

del defn.base_type_exprs[i]

tvar_defs = [] # type: List[TypeVarDef]

for name, tvar_expr in declared_tvars:

tvar_def = self.tvar_scope.bind_new(name, tvar_expr)

tvar_defs.append(tvar_def)

defn.type_vars = tvar_defs

def analyze_typevar_declaration(self, t: Type) -> Optional[TypeVarList]:

if not isinstance(t, UnboundType):

return None

unbound = t

sym = self.lookup_qualified(unbound.name, unbound)

if sym is None or sym.node is None:

return None

if (sym.node.fullname() == 'typing.Generic' or

sym.node.fullname() == 'typing.Protocol' and t.args or

sym.node.fullname() == 'typing_extensions.Protocol' and t.args):

tvars = [] # type: TypeVarList

for arg in unbound.args:

tvar = self.analyze_unbound_tvar(arg)

if tvar:

tvars.append(tvar)

else:

self.fail('Free type variable expected in %s[...]' %

sym.node.name(), t)

return tvars

return None

def analyze_unbound_tvar(self, t: Type) -> Optional[Tuple[str, TypeVarExpr]]:

if not isinstance(t, UnboundType):

return None

unbound = t

sym = self.lookup_qualified(unbound.name, unbound)

if sym is None or sym.kind != TVAR:

return None

elif sym.fullname and not self.tvar_scope.allow_binding(sym.fullname):

# It's bound by our type variable scope

return None

else:

assert isinstance(sym.node, TypeVarExpr)

return unbound.name, sym.node

def get_all_bases_tvars(self, defn: ClassDef, removed: List[int]) -> TypeVarList:

tvars = [] # type: TypeVarList

for i, base_expr in enumerate(defn.base_type_exprs):

if i not in removed:

try:

base = expr_to_unanalyzed_type(base_expr)

except TypeTranslationError:

# This error will be caught later.

continue

base_tvars = base.accept(TypeVariableQuery(self.lookup_qualified, self.tvar_scope))

tvars.extend(base_tvars)

return remove_dups(tvars)

def setup_class_def_analysis(self, defn: ClassDef) -> None:

"""Prepare for the analysis of a class definition."""

if not defn.info:

defn.info = TypeInfo(SymbolTable(), defn, self.cur_mod_id)

defn.info._fullname = defn.info.name()

if self.is_func_scope() or self.type:

kind = MDEF

if self.is_func_scope():

kind = LDEF

node = SymbolTableNode(kind, defn.info)