"""Mypy type checker."""

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_erased_types, 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,

)

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(NamedTuple):

map: dict[Var, Context]

is_function: bool

is_local: bool

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

# Innermost enclosing type

type: TypeInfo | None

# 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]

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 = tree.names

self.type = None

self.return_types = []

self.dynamic_funcs = []

self.partial_types = []

self.partial_reported = set()

self.var_decl_frames = {}

self.deferred_nodes = []

self.widened_vars = []

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

@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)

def check_first_pass(self) -> 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 = True

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():

for d in self.tree.defs:

if self.binder.is_unreachable():

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,

) -> 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 = True

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)

return True

def check_partial(self, node: DeferredNodeType | FineGrainedDeferredNodeType) -> None:

self.widened_vars = []

if isinstance(node, MypyFile):

self.check_top_level(node)

else:

self.recurse_into_functions = True

with self.binder.top_frame_context():

self.accept(node)

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

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

self.recurse_into_functions = False

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:

# If a function/method can infer variable types, it should be processed as part

# of the module top level (i.e. module interface).

if not self.recurse_into_functions and not defn.def_or_infer_vars:

return

with self.tscope.function_scope(defn), self.set_recurse_into_functions():

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):

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:

joined_type = get_proper_type(join.join_type_list(items))

if isinstance(joined_type, FunctionLike):

outer_type = joined_type

else:

return self.extract_callable_type(union_type, ctx)

if outer_type is None:

self.msg.not_callable(inner_type, ctx)

return None

if isinstance(outer_type, Overloaded):

return None

assert isinstance(outer_type, CallableType)

return outer_type

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

# At this point we should have set the impl already, and all remaining

# items are decorators

if self.can_skip_diagnostics:

return

# Compute some info about the implementation (if it exists) for use below

impl_type: CallableType | None = None

if defn.impl:

if isinstance(defn.impl, FuncDef):

inner_type: Type | None = defn.impl.type

elif isinstance(defn.impl, Decorator):

inner_type = defn.impl.var.type

else:

assert False, "Impl isn't the right type"

# This can happen if we've got an overload with a different

# decorator or if the implementation is untyped -- we gave up on the types.

impl_type = self.extract_callable_type(inner_type, defn.impl)

is_descriptor_get = defn.info and defn.name == "__get__"

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

assert isinstance(item, Decorator)

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

if sig1 is None:

continue

for j, item2 in enumerate(defn.items[i + 1 :]):

assert isinstance(item2, Decorator)

sig2 = self.extract_callable_type(item2.var.type, item2)

if sig2 is None:

continue

if not are_argument_counts_overlapping(sig1, sig2):

continue

if overload_can_never_match(sig1, sig2):

self.msg.overloaded_signature_will_never_match(i + 1, i + j + 2, item2.func)

elif not is_descriptor_get:

# Note: we force mypy to check overload signatures in strict-optional mode

# so we don't incorrectly report errors when a user tries typing an overload

# that happens to have a 'if the argument is None' fallback.

#

# For example, the following is fine in strict-optional mode but would throw

# the unsafe overlap error when strict-optional is disabled:

#

# @overload

# def foo(x: None) -> int: ...

# @overload

# def foo(x: str) -> str: ...

#

# See Python 2's map function for a concrete example of this kind of overload.

current_class = self.scope.active_class()

type_vars = current_class.defn.type_vars if current_class else []

with state.strict_optional_set(True):

if is_unsafe_overlapping_overload_signatures(sig1, sig2, type_vars):

flip_note = (

j == 0

and not is_unsafe_overlapping_overload_signatures(

sig2, sig1, type_vars

)

and not overload_can_never_match(sig2, sig1)

)

self.msg.overloaded_signatures_overlap(

i + 1, i + j + 2, flip_note, item.func

)

if impl_type is not None:

assert defn.impl is not None

# This is what we want from implementation, it should accept all arguments

# of an overload, but the return types should go the opposite way.

if is_callable_compatible(

impl_type,

sig1,

is_compat=is_subtype,

is_proper_subtype=False,

is_compat_return=lambda l, r: is_subtype(r, l),

):

continue

# If the above check didn't work, we repeat some key steps in

# is_callable_compatible() to give a better error message.

# We perform a unification step that's very similar to what

# 'is_callable_compatible' does -- the only difference is that

# we check and see if the impl_type's return value is a

# *supertype* of the overload alternative, not a *subtype*.

#

# This is to match the direction the implementation's return

# needs to be compatible in.

if impl_type.variables:

impl: CallableType | None = unify_generic_callable(

# Normalize both before unifying

impl_type.with_unpacked_kwargs(),

sig1.with_unpacked_kwargs(),

ignore_return=False,

return_constraint_direction=SUPERTYPE_OF,

)

if impl is None:

self.msg.overloaded_signatures_typevar_specific(i + 1, defn.impl)

continue

else:

impl = impl_type

# Prevent extra noise from inconsistent use of @classmethod by copying

# the first arg from the method being checked against.

if sig1.arg_types and defn.info:

impl = impl.copy_modified(arg_types=[sig1.arg_types[0]] + impl.arg_types[1:])