"""Mypy type checker.

Infer types of expressions and type-check the AST. We use multi-pass architecture,

this means we re-visit the AST until either all types are inferred, or we hit the

upper limit on number of passes (currently 3). The number of passes is intentionally

low, mostly to keep performance predictable. An example of code where more than one

pass is needed:

def foo() -> None:

C().x += 1 # we don't know the type of x before we visit C

class C:

def __init__(self) -> None:

self.x = <some non-literal expression>

In this example, encountering attribute C.x will trigger handle_cannot_determine_type()

which in turn will schedule foo() to be re-visited in the next pass. This process is

called deferring, some notes on it:

* Only a top-level function or method can be deferred. For historical reasons we don't

defer module top-levels.

* There are two reasons that can trigger deferral: a type of name/attribute used in

a function body is not inferred yet, or type of superclass node is not known when

checking LSP.

* In first case, the actual deferred node will be always FuncDef, even if the actual

top-level function is either a Decorator or an OverloadedFuncDef.

* In the second case, the deferred node will be actual top-level node, unless FuncDef

is sufficient (in case when deferring a method of a class nested in function).

* When a function was deferred we suppress most errors, and infer all expressions as

Any until the end of deferred function. This is done to avoid false positives. We may

change this in future by adding a special kind of Any that signifies not ready type.

Second important aspect of architecture is two-phase checking. Currently, it is only

used in parallel type-checking mode, but at some point it will be the default in

sequential mode as well.

In first phase (called interface phase) we type-check only module top-levels, function

signatures, and bodies of functions/methods that were found during semantic analysis as

(possibly) affecting external module interface (most notably __init__ methods). This is

done by setting recurse_into_functions flag to False. We handle all deferrals triggered

during this phase (still with recurse_into_functions being False) before moving to

the next one.

In second phase (called implementation phase) we type-check only the bodies of functions

and methods not type-checked in interface phase. This is done by setting

recurse_into_functions to True, and gathering all functions/methods with def_or_infer_vars

flag being False. Note that we execute only parts of the relevant visit methods that

were not executed before (i.e. we don't handle function signatures twice), see

check_partial() method for more details.

The boundary between function signature logic and function body logic is somewhat arbitrary,

and currently mostly sits where it was historically. Some rules about this are:

* Any logic that can *change* function signature *must* be executed in phase one.

* In general, we want to put as much of logic into phase two for better performance.

* Try keeping things clear/consistent, right now the boundary always sits at the point when

we push the function on the scope stack and call check_func_item().

Note: some parts of the type-checker live in other `check*.py` files, like `checkexpr.py`,

the orchestration between various type-checking phases and passes is done in `build.py`.

"""

from __future__ import annotations

import itertools

from collections import defaultdict

from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence, Set as AbstractSet

from contextlib import ExitStack, contextmanager

from typing import (

Final,

Generic,

Literal,

NamedTuple,

TypeAlias as _TypeAlias,

TypeGuard,

TypeVar,

cast,

overload,

)

import mypy.checkexpr

from mypy import errorcodes as codes, join, message_registry, nodes, operators

from mypy.binder import ConditionalTypeBinder, Frame, get_declaration

from mypy.checker_shared import CheckerScope, TypeCheckerSharedApi, TypeRange

from mypy.checker_state import checker_state

from mypy.checkmember import (

MemberContext,

analyze_class_attribute_access,

analyze_instance_member_access,

analyze_member_access,

is_instance_var,

)

from mypy.checkpattern import PatternChecker

from mypy.constraints import SUPERTYPE_OF

from mypy.erasetype import (

erase_type,

erase_typevars,

remove_instance_last_known_values,

shallow_erase_type_for_equality,

)

from mypy.errorcodes import TYPE_VAR, UNUSED_AWAITABLE, UNUSED_COROUTINE, ErrorCode

from mypy.errors import (

ErrorInfo,

Errors,

ErrorWatcher,

IterationDependentErrors,

IterationErrorWatcher,

report_internal_error,

)

from mypy.expandtype import expand_type

from mypy.literals import Key, extract_var_from_literal_hash, literal, literal_hash

from mypy.maptype import map_instance_to_supertype

from mypy.meet import is_overlapping_types, meet_types

from mypy.message_registry import ErrorMessage

from mypy.messages import (

SUGGESTED_TEST_FIXTURES,

MessageBuilder,

append_invariance_notes,

append_union_note,

format_type,

format_type_bare,

format_type_distinctly,

make_inferred_type_note,

pretty_seq,

)

from mypy.mro import MroError, calculate_mro

from mypy.nodes import (

ARG_NAMED,

ARG_POS,

ARG_STAR,

CONTRAVARIANT,

COVARIANT,

FUNC_NO_INFO,

GDEF,

IMPLICITLY_ABSTRACT,

INVARIANT,

IS_ABSTRACT,

LDEF,

LITERAL_TYPE,

MDEF,

NOT_ABSTRACT,

SYMBOL_FUNCBASE_TYPES,

AssertStmt,

AssignmentExpr,

AssignmentStmt,

AwaitExpr,

Block,

BreakStmt,

BytesExpr,

CallExpr,

ClassDef,

ComparisonExpr,

Context,

ContinueStmt,

Decorator,

DelStmt,

DictExpr,

EllipsisExpr,

Expression,

ExpressionStmt,

FloatExpr,

ForStmt,

FuncBase,

FuncDef,

FuncItem,

GlobalDecl,

IfStmt,

Import,

ImportAll,

ImportBase,

ImportFrom,

IndexExpr,

IntExpr,

LambdaExpr,

ListExpr,

Lvalue,

MatchStmt,

MemberExpr,

MypyFile,

NameExpr,

Node,

NonlocalDecl,

OperatorAssignmentStmt,

OpExpr,

OverloadedFuncDef,

OverloadPart,

PassStmt,

PromoteExpr,

RaiseStmt,

RefExpr,

ReturnStmt,

SetExpr,

SplittingVisitor,

StarExpr,

Statement,

StrExpr,

SymbolNode,

SymbolTable,

SymbolTableNode,

TempNode,

TryStmt,

TupleExpr,

TypeAlias,

TypeAliasStmt,

TypeInfo,

UnaryExpr,

Var,

WhileStmt,

WithStmt,

YieldExpr,

get_func_def,

is_final_node,

)

from mypy.operators import flip_ops, int_op_to_method, neg_ops

from mypy.options import PRECISE_TUPLE_TYPES, Options

from mypy.patterns import AsPattern, StarredPattern

from mypy.plugin import Plugin

from mypy.plugins import dataclasses as dataclasses_plugin

from mypy.scope import Scope

from mypy.semanal import is_trivial_body, refers_to_fullname, set_callable_name

from mypy.semanal_enum import ENUM_BASES, ENUM_SPECIAL_PROPS

from mypy.semanal_shared import SemanticAnalyzerCoreInterface

from mypy.sharedparse import BINARY_MAGIC_METHODS

from mypy.state import state

from mypy.subtypes import (

find_member,

infer_class_variances,

is_callable_compatible,

is_equivalent,

is_more_precise,

is_proper_subtype,

is_same_type,

is_subtype,

restrict_subtype_away,

unify_generic_callable,

)

from mypy.traverser import TraverserVisitor, all_return_statements, has_return_statement

from mypy.treetransform import TransformVisitor

from mypy.typeanal import check_for_explicit_any, has_any_from_unimported_type, make_optional_type

from mypy.typeops import (

bind_self,

can_have_shared_disjoint_base,

coerce_to_literal,

custom_special_method,

erase_def_to_union_or_bound,

erase_to_bound,

erase_to_union_or_bound,

false_only,

fixup_partial_type,

function_type,

is_literal_type_like,

is_singleton_equality_type,

is_singleton_identity_type,

make_simplified_union,

true_only,

try_expanding_sum_type_to_union,

try_getting_int_literals_from_type,

try_getting_str_literals,

try_getting_str_literals_from_type,

tuple_fallback,

type_object_type,

)

from mypy.types import (

ANY_STRATEGY,

MYPYC_NATIVE_INT_NAMES,

NOT_IMPLEMENTED_TYPE_NAMES,

OVERLOAD_NAMES,

AnyType,

BoolTypeQuery,

CallableType,

DeletedType,

ErasedType,

FunctionLike,

Instance,

LiteralType,

NoneType,

Overloaded,

PartialType,

ProperType,

TupleType,

Type,

TypeAliasType,

TypedDictType,

TypeGuardedType,

TypeOfAny,

TypeTranslator,

TypeType,

TypeVarId,

TypeVarLikeType,

TypeVarTupleType,

TypeVarType,

UnboundType,

UninhabitedType,

UnionType,

UnpackType,

find_unpack_in_list,

flatten_nested_unions,

get_proper_type,

get_proper_types,

instance_cache,

is_literal_type,

is_named_instance,

is_unannotated_any,

)

from mypy.types_utils import is_overlapping_none, remove_optional, store_argument_type, strip_type

from mypy.typetraverser import TypeTraverserVisitor

from mypy.typevars import fill_typevars, fill_typevars_with_any, has_no_typevars

from mypy.util import is_dunder, is_sunder

from mypy.visitor import NodeVisitor

T = TypeVar("T")

DEFAULT_LAST_PASS: Final = 2 # Pass numbers start at 0

# Maximum length of fixed tuple types inferred when narrowing from variadic tuples.

MAX_PRECISE_TUPLE_SIZE: Final = 8

DeferredNodeType: _TypeAlias = FuncDef | OverloadedFuncDef | Decorator

FineGrainedDeferredNodeType: _TypeAlias = FuncDef | MypyFile | OverloadedFuncDef

# A node which is postponed to be processed during the next pass.

# In normal mode one can defer functions and methods (also decorated and/or overloaded)

# but not lambda expressions. Nested functions can't be deferred -- only top-level functions

# and methods of classes not defined within a function can be deferred.

class DeferredNode(NamedTuple):

node: DeferredNodeType

# And its TypeInfo (for semantic analysis self type handling)

active_typeinfo: TypeInfo | None

# Same as above, but for fine-grained mode targets. Only top-level functions/methods

# and module top levels are allowed as such.

class FineGrainedDeferredNode(NamedTuple):

node: FineGrainedDeferredNodeType

active_typeinfo: TypeInfo | None

# Data structure returned by find_isinstance_check representing

# information learned from the truth or falsehood of a condition. The

# dict maps nodes representing expressions like 'a[0].x' to their

# refined types under the assumption that the condition has a

# particular truth value. A value of None means that the condition can

# never have that truth value.

# NB: The keys of this dict are nodes in the original source program,

# which are compared by reference equality--effectively, being *the

# same* expression of the program, not just two identical expressions

# (such as two references to the same variable). TODO: it would

# probably be better to have the dict keyed by the nodes' literal_hash

# field instead.

TypeMap: _TypeAlias = dict[Expression, Type]

# Keeps track of partial types in a single scope. In fine-grained incremental

# mode partial types initially defined at the top level cannot be completed in

# a function, and we use the 'is_function' attribute to enforce this.

class PartialTypeScope:

def __init__(self, map: dict[Var, Context], is_function: bool, is_local: bool) -> None:

self.map: Final = map

self.is_function: Final = is_function

self.is_local: Final = is_local

class LocalTypeMap:

"""Store inferred types into a temporary type map (returned).

This can be used to perform type checking "experiments" without

affecting exported types (which are used by mypyc).

"""

def __init__(self, chk: TypeChecker) -> None:

self.chk = chk

def __enter__(self) -> dict[Expression, Type]:

temp_type_map: dict[Expression, Type] = {}

self.chk._type_maps.append(temp_type_map)

return temp_type_map

def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> Literal[False]:

self.chk._type_maps.pop()

return False

class TypeChecker(NodeVisitor[None], TypeCheckerSharedApi, SplittingVisitor):

"""Mypy type checker.

Type check mypy source files that have been semantically analyzed.

You must create a separate instance for each source file.

"""

# Are we type checking a stub?

is_stub = False

# Error message reporter

errors: Errors

# Utility for generating messages

msg: MessageBuilder

# Types of type checked nodes. The first item is the "master" type

# map that will store the final, exported types. Additional items

# are temporary type maps used during type inference, and these

# will be eventually popped and either discarded or merged into

# the master type map.

#

# Avoid accessing this directly, but prefer the lookup_type(),

# has_type() etc. helpers instead.

_type_maps: list[dict[Expression, Type]]

# Helper for managing conditional types

binder: ConditionalTypeBinder

# Helper for type checking expressions

_expr_checker: mypy.checkexpr.ExpressionChecker

pattern_checker: PatternChecker

tscope: Scope

scope: CheckerScope

# Stack of function return types

return_types: list[Type]

# Flags; true for dynamically typed functions

dynamic_funcs: list[bool]

# Stack of collections of variables with partial types

partial_types: list[PartialTypeScope]

# Vars for which partial type errors are already reported

# (to avoid logically duplicate errors with different error context).

partial_reported: set[Var]

# Short names of Var nodes whose previous inferred type has been widened via assignment.

# NOTE: The names might not be unique, they are only for debugging purposes.

widened_vars: list[str]

# Global variables widened inside a function body, to be propagated to

# the module-level binder after the function is type checked (with --allow-redefinition-new).

_globals_widened_in_func: list[tuple[NameExpr, Type]]

globals: SymbolTable

modules: dict[str, MypyFile]

# Nodes that couldn't be checked because some types weren't available. We'll run

# another pass and try these again.

deferred_nodes: list[DeferredNode]

# Type checking pass number (0 = first pass)

pass_num = 0

# Last pass number to take

last_pass = DEFAULT_LAST_PASS

# Have we deferred the current function? If yes, don't infer additional

# types during this pass within the function.

current_node_deferred = False

# Is this file a typeshed stub?

is_typeshed_stub = False

options: Options

# Used for collecting inferred attribute types so that they can be checked

# for consistency.

inferred_attribute_types: dict[Var, Type] | None = None

# Don't infer partial None types if we are processing assignment from Union

no_partial_types: bool = False

# Extra module references not detected during semantic analysis (these are rare cases

# e.g. access to class-level import via instance).

module_refs: set[str]

# A map from variable nodes to a snapshot of the frame ids of the

# frames that were active when the variable was declared. This can

# be used to determine nearest common ancestor frame of a variable's

# declaration and the current frame, which lets us determine if it

# was declared in a different branch of the same `if` statement

# (if that frame is a conditional_frame).

var_decl_frames: dict[Var, set[int]]

# Plugin that provides special type checking rules for specific library

# functions such as open(), etc.

plugin: Plugin

# A helper state to produce unique temporary names on demand.

_unique_id: int

# Fake concrete type used when checking variance

_variance_dummy_type: Instance | None

def __init__(

self,

errors: Errors,

modules: dict[str, MypyFile],

options: Options,

tree: MypyFile,

path: str,

plugin: Plugin,

per_line_checking_time_ns: dict[int, int],

) -> None:

"""Construct a type checker.

Use errors to report type check errors.

"""

self.errors = errors

self.modules = modules

self.options = options

self.tree = tree

self.path = path

self.msg = MessageBuilder(errors, modules)

self.plugin = plugin

self.tscope = Scope()

self.scope = CheckerScope(tree)

self.binder = ConditionalTypeBinder(options)

self.globals_binder = self.binder

self.globals = tree.names

self.globals_unreachable: set[int] = set()

self.return_types = []

self.dynamic_funcs = []

self.partial_types = []

self.partial_reported = set()

self.var_decl_frames = {}

self.deferred_nodes = []

self.widened_vars = []

self._globals_widened_in_func = []

self._type_maps = [{}]

self.module_refs = set()

self.pass_num = 0

self.current_node_deferred = False

self.is_stub = tree.is_stub

self.is_typeshed_stub = tree.is_typeshed_file(options)

self.inferred_attribute_types = None

self.allow_constructor_cache = True

self.local_type_map = LocalTypeMap(self)

self.can_skip_diagnostics: Final = (

self.options.ignore_errors

or self.path in self.msg.errors.ignored_files

or (self.options.test_env and self.is_typeshed_stub)

)

self.recurse_into_functions = True

# This internal flag is used to track whether we a currently type-checking

# a final declaration (assignment), so that some errors should be suppressed.

# Should not be set manually, use get_final_context/enter_final_context instead.

# NOTE: we use the context manager to avoid "threading" an additional `is_final_def`

# argument through various `checker` and `checkmember` functions.

self._is_final_def = False

# Track when we enter an overload implementation. Some checks should not be applied

# to the implementation signature when specific overloads are available.

# Use `enter_overload_impl` to modify.

self.overload_impl_stack: list[OverloadPart] = []

# This flag is set when we run type-check or attribute access check for the purpose

# of giving a note on possibly missing "await". It is used to avoid infinite recursion.

self.checking_missing_await = False

# While this is True, allow passing an abstract class where Type[T] is expected.

# although this is technically unsafe, this is desirable in some context, for

# example when type-checking class decorators.

self.allow_abstract_call = False

# Child checker objects for specific AST node types

self._expr_checker = mypy.checkexpr.ExpressionChecker(

self, self.msg, self.plugin, per_line_checking_time_ns

)

self.pattern_checker = PatternChecker(self, self.msg, self.plugin, options)

self._unique_id = 0

self._variance_dummy_type = None

# Assignment expression is the only *expression* that can have externally

# visible effects via binder. We bump this whenever this happens to handle

# situations when some expressions are accepted multiple times.

self.assignment_expression_effect = 0

@property

def expr_checker(self) -> mypy.checkexpr.ExpressionChecker:

return self._expr_checker

@property

def type_context(self) -> list[Type | None]:

return self._expr_checker.type_context

def reset(self) -> None:

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

This allows us to reuse TypeChecker objects in fine-grained

incremental mode.

"""

# TODO: verify this is still actually worth it over creating new checkers

self.partial_reported.clear()

self.module_refs.clear()

self.binder = ConditionalTypeBinder(self.options)

self._type_maps[1:] = []

self._type_maps[0].clear()

self.expr_checker.reset()

self.deferred_nodes = []

self.partial_types = []

self.inferred_attribute_types = None

self.scope = CheckerScope(self.tree)

self.globals_unreachable.clear()

def mark_unreachable(self, block: list[Statement], after: Statement) -> None:

"""Marks all statements in block after a given one (inclusive) as unreachable."""

last_line = (last := block[-1]).end_line or last.line

self.globals_unreachable.update(range(after.line, last_line + 1))

def check_first_pass(self, recurse_into_functions: bool = True) -> None:

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

"""

self.recurse_into_functions = recurse_into_functions

with state.strict_optional_set(self.options.strict_optional), checker_state.set(self):

self.errors.set_file(

self.path, self.tree.fullname, scope=self.tscope, options=self.options

)

with self.tscope.module_scope(self.tree.fullname):

with self.enter_partial_types(), self.binder.top_frame_context():

marked_unreachable = False

for d in self.tree.defs:

if self.binder.is_unreachable():

if not marked_unreachable:

self.mark_unreachable(self.tree.defs, after=d)

marked_unreachable = True

if not self.should_report_unreachable_issues():

break

if not self.is_noop_for_reachability(d):

self.msg.unreachable_statement(d)

break

else:

self.accept(d)

assert not self.current_node_deferred

all_ = self.globals.get("__all__")

if all_ is not None and all_.type is not None:

all_node = all_.node

assert all_node is not None

seq_str = self.named_generic_type(

"typing.Sequence", [self.named_type("builtins.str")]

)

if not is_subtype(all_.type, seq_str):

str_seq_s, all_s = format_type_distinctly(

seq_str, all_.type, options=self.options

)

self.fail(

message_registry.ALL_MUST_BE_SEQ_STR.format(str_seq_s, all_s), all_node

)

def check_second_pass(

self,

todo: Sequence[DeferredNode | FineGrainedDeferredNode] | None = None,

*,

allow_constructor_cache: bool = True,

recurse_into_functions: bool = True,

impl_only: bool = False,

) -> bool:

"""Run second or following pass of type checking.

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

"""

self.allow_constructor_cache = allow_constructor_cache

self.recurse_into_functions = recurse_into_functions

with state.strict_optional_set(self.options.strict_optional), checker_state.set(self):

if not todo and not self.deferred_nodes:

return False

self.errors.set_file(

self.path, self.tree.fullname, scope=self.tscope, options=self.options

)

with self.tscope.module_scope(self.tree.fullname):

self.pass_num += 1

if not todo:

todo = self.deferred_nodes

else:

assert not self.deferred_nodes

self.deferred_nodes = []

done: set[DeferredNodeType | FineGrainedDeferredNodeType] = set()

for node, active_typeinfo in todo:

if node in done:

continue

# This is useful for debugging:

# print("XXX in pass %d, class %s, function %s" %

# (self.pass_num, type_name, node.fullname or node.name))

done.add(node)

with ExitStack() as stack:

if active_typeinfo:

stack.enter_context(self.tscope.class_scope(active_typeinfo))

stack.enter_context(self.scope.push_class(active_typeinfo))

self.check_partial(node, impl_only=impl_only)

return True

def check_partial(

self, node: DeferredNodeType | FineGrainedDeferredNodeType, impl_only: bool

) -> None:

self.widened_vars = []

if isinstance(node, MypyFile):

self.check_top_level(node)

else:

with self.binder.top_frame_context():

# TODO: use impl_only in the daemon as well.

if not impl_only:

self.accept(node)

return

if node.line in self.globals_unreachable:

return

if isinstance(node, (FuncDef, Decorator)):

self.check_partial_impl(node)

else:

# Overloads need some special logic, since settable

# properties are stored as overloads.

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

# Setter and/or deleter can technically be empty.

allow_empty = not node.is_property or i > 0

assert isinstance(item, Decorator)

# Although the actual bodies of overload items are empty, we

# still need to execute some logic that doesn't affect signature.

with self.tscope.function_scope(item.func):

self.check_func_item(

item.func, name=node.name, allow_empty=allow_empty

)

if node.impl is not None:

# Handle the implementation as a regular function.

with self.enter_overload_impl(node.impl):

self.check_partial_impl(node.impl)

def check_partial_impl(self, impl: FuncDef | Decorator) -> None:

"""Check only the body (not the signature) of a non-overloaded function."""

if isinstance(impl, FuncDef):

self.visit_func_def_impl(impl)

else:

if any(refers_to_fullname(d, "typing.no_type_check") for d in impl.decorators):

return

with self.tscope.function_scope(impl.func):

self.check_func_item(impl.func, name=impl.func.name)

def check_top_level(self, node: MypyFile) -> None:

"""Check only the top-level of a module, skipping function definitions."""

with self.enter_partial_types():

with self.binder.top_frame_context():

for d in node.defs:

d.accept(self)

assert not self.current_node_deferred

# TODO: Handle __all__

def defer_node(self, node: DeferredNodeType, enclosing_class: TypeInfo | None) -> None:

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

"""

# We don't freeze the entire scope since only top-level functions and methods

# can be deferred. Only module/class level scope information is needed.

# Module-level scope information is preserved in the TypeChecker instance.

self.deferred_nodes.append(DeferredNode(node, enclosing_class))

def handle_cannot_determine_type(self, name: str, context: Context) -> None:

node = self.scope.top_level_function()

if self.pass_num < self.last_pass and isinstance(node, FuncDef):

# Don't report an error yet. Just defer. Note that we don't defer

# lambdas because they are coupled to the surrounding function

# through the binder and the inferred type of the lambda, so it

# would get messy.

enclosing_class = self.scope.enclosing_class(node)

self.defer_node(node, enclosing_class)

# Set a marker so that we won't infer additional types in this

# function. Any inferred types could be bogus, because there's at

# least one type that we don't know.

self.current_node_deferred = True

else:

self.msg.cannot_determine_type(name, context)

def accept(self, stmt: Statement) -> None:

"""Type check a node in the given type context."""

try:

stmt.accept(self)

except Exception as err:

report_internal_error(err, self.errors.file, stmt.line, self.errors, self.options)

def accept_loop(

self,

body: Statement,

else_body: Statement | None = None,

*,

exit_condition: Expression | None = None,

on_enter_body: Callable[[], None] | None = None,

) -> None:

"""Repeatedly type check a loop body until the frame doesn't change."""

# The outer frame accumulates the results of all iterations:

with self.binder.frame_context(can_skip=False, conditional_frame=True):

# Check for potential decreases in the number of partial types so as not to stop the

# iteration too early:

partials_old = sum(len(pts.map) for pts in self.partial_types)

# Check if assignment widened the inferred type of a variable; in this case we

# need to iterate again (we only do one extra iteration, since this could go

# on without bound otherwise)

widened_old = len(self.widened_vars)

iter_errors = IterationDependentErrors()

iter = 1

while True:

with self.binder.frame_context(can_skip=True, break_frame=2, continue_frame=1):

if on_enter_body is not None:

on_enter_body()

with IterationErrorWatcher(self.msg.errors, iter_errors):

self.accept(body)

partials_new = sum(len(pts.map) for pts in self.partial_types)

widened_new = len(self.widened_vars)

# Perform multiple iterations if something changed that might affect

# inferred types. Also limit the number of iterations. The limits are

# somewhat arbitrary, but they were chosen to 1) avoid slowdown from

# multiple iterations in common cases and 2) support common, valid use

# cases. Limits are needed since otherwise we could infer infinitely

# complex types.

if (

(partials_new == partials_old)

and (not self.binder.last_pop_changed or iter > 3)

and (widened_new == widened_old or iter > 1)

):

break

partials_old = partials_new

widened_old = widened_new

iter += 1

if iter == 20:

raise RuntimeError("Too many iterations when checking a loop")

self.msg.iteration_dependent_errors(iter_errors)

# If exit_condition is set, assume it must be False on exit from the loop:

if exit_condition:

_, else_map = self.find_isinstance_check(exit_condition)

self.push_type_map(else_map)

# Check the else body:

if else_body:

self.accept(else_body)

#

# Definitions

#

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

# We always process overload as part of the top-level to infer various

# externally visible properties like its type, similar to visit_decorator().

# Only the body of the implementation is checked as a function-level target.

# TODO: clean-up deferral logic and the daemon to avoid unnecessary work.

with self.tscope.function_scope(defn):

self._visit_overloaded_func_def(defn)

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

num_abstract = 0

if not defn.items:

# In this case we have already complained about none of these being

# valid overloads.

return

if len(defn.items) == 1:

self.fail(message_registry.MULTIPLE_OVERLOADS_REQUIRED, defn)

if defn.is_property:

# HACK: Infer the type of the property.

assert isinstance(defn.items[0], Decorator)

self.visit_decorator(defn.items[0])

if defn.items[0].var.is_settable_property:

# Perform a reduced visit just to infer the actual setter type.

self.visit_decorator_inner(defn.setter, skip_first_item=True)

setter_type = defn.setter.var.type

# Check if the setter can accept two positional arguments.

any_type = AnyType(TypeOfAny.special_form)

fallback_setter_type = CallableType(

arg_types=[any_type, any_type],

arg_kinds=[ARG_POS, ARG_POS],

arg_names=[None, None],

ret_type=any_type,

fallback=self.named_type("builtins.function"),

)

if setter_type and not is_subtype(setter_type, fallback_setter_type):

self.fail("Invalid property setter signature", defn.setter.func)

setter_type = self.extract_callable_type(setter_type, defn)

if not isinstance(setter_type, CallableType) or len(setter_type.arg_types) != 2:

# TODO: keep precise type for callables with tricky but valid signatures.

setter_type = fallback_setter_type

defn.items[0].var.setter_type = setter_type

if isinstance(defn.type, Overloaded):

# Update legacy property type for decorated properties.

getter_type = self.extract_callable_type(defn.items[0].var.type, defn)

if getter_type is not None:

getter_type.definition = defn.items[0]

defn.type.items[0] = getter_type

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

assert isinstance(fdef, Decorator)

if defn.is_property:

assert isinstance(defn.items[0], Decorator)

settable = defn.items[0].var.is_settable_property

# Do not visit the second time the items we checked above.

if (settable and i > 1) or (not settable and i > 0):

# Type check initialization expressions.

# TODO: initializers can infer types if they contain a walrus,

# it may be not safe to optimize them away completely.

if not self.can_skip_diagnostics:

self.check_default_params(fdef.func)

if self.recurse_into_functions or fdef.func.def_or_infer_vars:

with (

self.tscope.function_scope(fdef.func),

self.set_recurse_into_functions(),

):

self.check_func_item(fdef.func, name=fdef.func.name, allow_empty=True)

else:

# Perform full check for real overloads to infer type of all decorated

# overload variants.

self.visit_decorator_inner(fdef, allow_empty=True)

if fdef.func.abstract_status in (IS_ABSTRACT, IMPLICITLY_ABSTRACT):

num_abstract += 1

if num_abstract not in (0, len(defn.items)):

self.fail(message_registry.INCONSISTENT_ABSTRACT_OVERLOAD, defn)

if defn.impl:

with self.enter_overload_impl(defn.impl):

defn.impl.accept(self)

if not defn.is_property:

self.check_overlapping_overloads(defn)

if defn.type is None:

item_types = []

for item in defn.items:

assert isinstance(item, Decorator)

item_type = self.extract_callable_type(item.var.type, item)

if item_type is not None:

item_type.definition = item

item_types.append(item_type)

if item_types:

defn.type = Overloaded(item_types)

elif defn.type is None:

# We store the getter type as an overall overload type, as some

# code paths are getting property type this way.

assert isinstance(defn.items[0], Decorator)

var_type = self.extract_callable_type(defn.items[0].var.type, defn)

if not isinstance(var_type, CallableType):

# Construct a fallback type, invalid types should be already reported.

any_type = AnyType(TypeOfAny.special_form)

var_type = CallableType(

arg_types=[any_type],

arg_kinds=[ARG_POS],

arg_names=[None],

ret_type=any_type,

fallback=self.named_type("builtins.function"),

)

defn.type = Overloaded([var_type])

# Check override validity after we analyzed current definition.

if not self.can_skip_diagnostics and defn.info:

found_method_base_classes = self.check_method_override(defn)

if (

defn.is_explicit_override

and not found_method_base_classes

and found_method_base_classes is not None

# If the class has Any fallback, we can't be certain that a method

# is really missing - it might come from unfollowed import.

and not defn.info.fallback_to_any

):

self.msg.no_overridable_method(defn.name, defn)

self.check_explicit_override_decorator(defn, found_method_base_classes, defn.impl)

self.check_inplace_operator_method(defn)

@contextmanager

def enter_overload_impl(self, impl: OverloadPart) -> Iterator[None]:

self.overload_impl_stack.append(impl)

try:

yield

finally:

assert self.overload_impl_stack.pop() == impl

def extract_callable_type(self, inner_type: Type | None, ctx: Context) -> CallableType | None:

"""Get type as seen by an overload item caller."""

inner_type = get_proper_type(inner_type)

outer_type: FunctionLike | None = None

if inner_type is None or isinstance(inner_type, AnyType):

return None

if isinstance(inner_type, TypeVarLikeType):

inner_type = get_proper_type(inner_type.upper_bound)

if isinstance(inner_type, TypeType):

inner_type = get_proper_type(

self.expr_checker.analyze_type_type_callee(inner_type.item, ctx)

)

if isinstance(inner_type, FunctionLike):

outer_type = inner_type

elif isinstance(inner_type, Instance):

inner_call = get_proper_type(

analyze_member_access(

name="__call__",

typ=inner_type,

context=ctx,

is_lvalue=False,

is_super=False,

is_operator=True,

original_type=inner_type,

chk=self,

)

)

if isinstance(inner_call, FunctionLike):

outer_type = inner_call

elif isinstance(inner_type, UnionType):

union_type = make_simplified_union(inner_type.items)

if isinstance(union_type, UnionType):

items = []

for item in union_type.items:

callable_item = self.extract_callable_type(item, ctx)

if callable_item is None:

break

items.append(callable_item)

else: