"""Mypy type checker."""

from __future__ import annotations

import itertools

from collections import defaultdict

from contextlib import ExitStack, contextmanager

from typing import (

AbstractSet,

Callable,

Dict,

Final,

Generic,

Iterable,

Iterator,

Mapping,

NamedTuple,

Optional,

Sequence,

Tuple,

TypeVar,

Union,

cast,

overload,

)

from typing_extensions import TypeAlias as _TypeAlias

import mypy.checkexpr

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

from mypy.binder import ConditionalTypeBinder, Frame, get_declaration

from mypy.checkmember import (

MemberContext,

analyze_decorator_or_funcbase_access,

analyze_descriptor_access,

analyze_member_access,

type_object_type,

)

from mypy.checkpattern import PatternChecker

from mypy.constraints import SUPERTYPE_OF

from mypy.erasetype import erase_type, erase_typevars, remove_instance_last_known_values

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

from mypy.errors import Errors, ErrorWatcher, report_internal_error

from mypy.expandtype import expand_self_type, expand_type, expand_type_by_instance

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,

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,

AssertStmt,

AssignmentExpr,

AssignmentStmt,

Block,

BreakStmt,

BytesExpr,

CallExpr,

ClassDef,

ComparisonExpr,

Context,

ContinueStmt,

Decorator,

DelStmt,

EllipsisExpr,

Expression,

ExpressionStmt,

FloatExpr,

ForStmt,

FuncBase,

FuncDef,

FuncItem,

IfStmt,

Import,

ImportAll,

ImportBase,

ImportFrom,

IndexExpr,

IntExpr,

LambdaExpr,

ListExpr,

Lvalue,

MatchStmt,

MemberExpr,

MypyFile,

NameExpr,

Node,

OperatorAssignmentStmt,

OpExpr,

OverloadedFuncDef,

PassStmt,

PromoteExpr,

RaiseStmt,

RefExpr,

ReturnStmt,

StarExpr,

Statement,

StrExpr,

SymbolNode,

SymbolTable,

SymbolTableNode,

TempNode,

TryStmt,

TupleExpr,

TypeAlias,

TypeInfo,

TypeVarExpr,

UnaryExpr,

Var,

WhileStmt,

WithStmt,

YieldExpr,

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 CheckerPluginInterface, 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.sharedparse import BINARY_MAGIC_METHODS

from mypy.state import state

from mypy.subtypes import (

find_member,

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,

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,

get_type_vars,

is_literal_type_like,

is_singleton_type,

make_simplified_union,

map_type_from_supertype,

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,

)

from mypy.types import (

ANY_STRATEGY,

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

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 = 1 # 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 = Union[FuncDef, LambdaExpr, OverloadedFuncDef, Decorator]

FineGrainedDeferredNodeType: _TypeAlias = Union[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)

# and 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 = Optional[Dict[Expression, Type]]

# An object that represents either a precise type or a type with an upper bound;

# it is important for correct type inference with isinstance.

class TypeRange(NamedTuple):

item: Type

is_upper_bound: bool # False => precise 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 TypeChecker(NodeVisitor[None], CheckerPluginInterface):

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

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

# The set of all dependencies (suppressed or not) that this module accesses, either

# directly or indirectly.

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

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

self.globals = tree.names

self.return_types = []

self.dynamic_funcs = []

self.partial_types = []

self.partial_reported = set()

self.var_decl_frames = {}

self.deferred_nodes = []

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

# 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

# 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

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

@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._type_maps[1:] = []

self._type_maps[0].clear()

self.temp_type_map = None

self.expr_checker.reset()

assert self.inferred_attribute_types is None

assert self.partial_types == []

assert self.deferred_nodes == []

assert len(self.scope.stack) == 1

assert self.partial_types == []

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

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

) -> bool:

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

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

"""

self.recurse_into_functions = True

with state.strict_optional_set(self.options.strict_optional):

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:

if isinstance(node, MypyFile):

self.check_top_level(node)

else:

self.recurse_into_functions = True

if isinstance(node, LambdaExpr):

self.expr_checker.accept(node)

else:

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

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,

) -> None:

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

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

Then check the else_body.

"""

# The outer frame accumulates the results of all iterations

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

while True:

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

self.accept(body)

if not self.binder.last_pop_changed:

break

if exit_condition:

_, else_map = self.find_isinstance_check(exit_condition)

self.push_type_map(else_map)

if else_body:

self.accept(else_body)

#

# Definitions

#

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

if not self.recurse_into_functions:

return

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

for fdef in defn.items:

assert isinstance(fdef, Decorator)

if defn.is_property:

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:

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_types.append(item_type)

if item_types:

defn.type = Overloaded(item_types)

# Check override validity after we analyzed current definition.

if 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

):

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)

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: CallableType | None = None

if inner_type is not None and not isinstance(inner_type, AnyType):

if isinstance(inner_type, CallableType):

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,

msg=self.msg,

original_type=inner_type,

chk=self,

)

)

if isinstance(inner_call, CallableType):

outer_type = inner_call

if outer_type is None:

self.msg.not_callable(inner_type, ctx)

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.msg.errors.file in self.msg.errors.ignored_files or (

self.is_typeshed_stub and self.options.test_env

):

# This is a little hacky, however, the quadratic check here is really expensive, this

# method has no side effects, so we should skip it if we aren't going to report

# anything. In some other places we swallow errors in stubs, but this error is very

# useful for stubs!

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

self.msg.overloaded_signatures_overlap(i + 1, i + j + 2, item.func)

if impl_type is not None:

assert defn.impl is not None

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

# 'is_callable_compatible' would have done if we had set

# 'unify_generics' to True -- 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:])

# Is the overload alternative's arguments subtypes of the implementation's?

if not is_callable_compatible(

impl, sig1, is_compat=is_subtype, is_proper_subtype=False, ignore_return=True

):

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

# Is the overload alternative's return type a subtype of the implementation's?

if not (

is_subtype(sig1.ret_type, impl.ret_type)

or is_subtype(impl.ret_type, sig1.ret_type)

):

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

# Here's the scoop about generators and coroutines.

#

# There are two kinds of generators: classic generators (functions

# with `yield` or `yield from` in the body) and coroutines

# (functions declared with `async def`). The latter are specified

# in PEP 492 and only available in Python >= 3.5.

#

# Classic generators can be parameterized with three types:

# - ty is the Yield type (the type of y in `yield y`)

# - tc is the type reCeived by yield (the type of c in `c = yield`).

# - tr is the Return type (the type of r in `return r`)

#

# A classic generator must define a return type that's either

# `Generator[ty, tc, tr]`, Iterator[ty], or Iterable[ty] (or

# object or Any). If tc/tr are not given, both are None.

#

# A coroutine must define a return type corresponding to tr; the

# other two are unconstrained. The "external" return type (seen

# by the caller) is Awaitable[tr].

#

# In addition, there's the synthetic type AwaitableGenerator: it

# inherits from both Awaitable and Generator and can be used both

# in `yield from` and in `await`. This type is set automatically

# for functions decorated with `@types.coroutine` or

# `@asyncio.coroutine`. Its single parameter corresponds to tr.

#

# PEP 525 adds a new type, the asynchronous generator, which was

# first released in Python 3.6. Async generators are `async def`

# functions that can also `yield` values. They can be parameterized

# with two types, ty and tc, because they cannot return a value.

#

# There are several useful methods, each taking a type t and a

# flag c indicating whether it's for a generator or coroutine:

#

# - is_generator_return_type(t, c) returns whether t is a Generator,

# Iterator, Iterable (if not c), or Awaitable (if c), or

# AwaitableGenerator (regardless of c).

# - is_async_generator_return_type(t) returns whether t is an

# AsyncGenerator.

# - get_generator_yield_type(t, c) returns ty.

# - get_generator_receive_type(t, c) returns tc.

# - get_generator_return_type(t, c) returns tr.

def is_generator_return_type(self, typ: Type, is_coroutine: bool) -> bool:

"""Is `typ` a valid type for a generator/coroutine?

True if `typ` is a *supertype* of Generator or Awaitable.

Also true it it's *exactly* AwaitableGenerator (modulo type parameters).

"""

typ = get_proper_type(typ)

if is_coroutine:

# This means we're in Python 3.5 or later.

at = self.named_generic_type("typing.Awaitable", [AnyType(TypeOfAny.special_form)])

if is_subtype(at, typ):

return True

else:

any_type = AnyType(TypeOfAny.special_form)

gt = self.named_generic_type("typing.Generator", [any_type, any_type, any_type])

if is_subtype(gt, typ):

return True

return isinstance(typ, Instance) and typ.type.fullname == "typing.AwaitableGenerator"

def is_async_generator_return_type(self, typ: Type) -> bool:

"""Is `typ` a valid type for an async generator?

True if `typ` is a supertype of AsyncGenerator.

"""

try:

any_type = AnyType(TypeOfAny.special_form)

agt = self.named_generic_type("typing.AsyncGenerator", [any_type, any_type])

except KeyError:

# we're running on a version of typing that doesn't have AsyncGenerator yet

return False

return is_subtype(agt, typ)

def get_generator_yield_type(self, return_type: Type, is_coroutine: bool) -> Type:

"""Given the declared return type of a generator (t), return the type it yields (ty)."""

return_type = get_proper_type(return_type)

if isinstance(return_type, AnyType):

return AnyType(TypeOfAny.from_another_any, source_any=return_type)

elif isinstance(return_type, UnionType):

return make_simplified_union(

[self.get_generator_yield_type(item, is_coroutine) for item in return_type.items]

)

elif not self.is_generator_return_type(

return_type, is_coroutine

) and not self.is_async_generator_return_type(return_type):

# If the function doesn't have a proper Generator (or

# Awaitable) return type, anything is permissible.

return AnyType(TypeOfAny.from_error)

elif not isinstance(return_type, Instance):

# Same as above, but written as a separate branch so the typechecker can understand.

return AnyType(TypeOfAny.from_error)

elif return_type.type.fullname == "typing.Awaitable":

# Awaitable: ty is Any.

return AnyType(TypeOfAny.special_form)

elif return_type.args:

# AwaitableGenerator, Generator, AsyncGenerator, Iterator, or Iterable; ty is args[0].

ret_type = return_type.args[0]

# TODO not best fix, better have dedicated yield token

return ret_type

else:

# If the function's declared supertype of Generator has no type

# parameters (i.e. is `object`), then the yielded values can't

# be accessed so any type is acceptable. IOW, ty is Any.

# (However, see https://github.com/python/mypy/issues/1933)

return AnyType(TypeOfAny.special_form)

def get_generator_receive_type(self, return_type: Type, is_coroutine: bool) -> Type:

"""Given a declared generator return type (t), return the type its yield receives (tc)."""

return_type = get_proper_type(return_type)

if isinstance(return_type, AnyType):

return AnyType(TypeOfAny.from_another_any, source_any=return_type)

elif isinstance(return_type, UnionType):

return make_simplified_union(

[self.get_generator_receive_type(item, is_coroutine) for item in return_type.items]

)

elif not self.is_generator_return_type(

return_type, is_coroutine

) and not self.is_async_generator_return_type(return_type):

# If the function doesn't have a proper Generator (or

# Awaitable) return type, anything is permissible.

return AnyType(TypeOfAny.from_error)

elif not isinstance(return_type, Instance):

# Same as above, but written as a separate branch so the typechecker can understand.

return AnyType(TypeOfAny.from_error)

elif return_type.type.fullname == "typing.Awaitable":

# Awaitable, AwaitableGenerator: tc is Any.

return AnyType(TypeOfAny.special_form)

elif (

return_type.type.fullname in ("typing.Generator", "typing.AwaitableGenerator")

and len(return_type.args) >= 3

):

# Generator: tc is args[1].

return return_type.args[1]

elif return_type.type.fullname == "typing.AsyncGenerator" and len(return_type.args) >= 2:

return return_type.args[1]

else:

# `return_type` is a supertype of Generator, so callers won't be able to send it

# values. IOW, tc is None.

return NoneType()

def get_coroutine_return_type(self, return_type: Type) -> Type:

return_type = get_proper_type(return_type)

if isinstance(return_type, AnyType):

return AnyType(TypeOfAny.from_another_any, source_any=return_type)

assert isinstance(return_type, Instance), "Should only be called on coroutine functions."

# Note: return type is the 3rd type parameter of Coroutine.

return return_type.args[2]

def get_generator_return_type(self, return_type: Type, is_coroutine: bool) -> Type:

"""Given the declared return type of a generator (t), return the type it returns (tr)."""

return_type = get_proper_type(return_type)

if isinstance(return_type, AnyType):

return AnyType(TypeOfAny.from_another_any, source_any=return_type)

elif isinstance(return_type, UnionType):

return make_simplified_union(

[self.get_generator_return_type(item, is_coroutine) for item in return_type.items]

)

elif not self.is_generator_return_type(return_type, is_coroutine):

# If the function doesn't have a proper Generator (or

# Awaitable) return type, anything is permissible.

return AnyType(TypeOfAny.from_error)

elif not isinstance(return_type, Instance):

# Same as above, but written as a separate branch so the typechecker can understand.

return AnyType(TypeOfAny.from_error)

elif return_type.type.fullname == "typing.Awaitable" and len(return_type.args) == 1:

# Awaitable: tr is args[0].

return return_type.args[0]

elif (

return_type.type.fullname in ("typing.Generator", "typing.AwaitableGenerator")

and len(return_type.args) >= 3

):

# AwaitableGenerator, Generator: tr is args[2].

return return_type.args[2]

else:

# We have a supertype of Generator (Iterator, Iterable, object)

# Treat `Iterator[X]` as a shorthand for `Generator[X, Any, None]`.

return NoneType()

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

if not self.recurse_into_functions:

return

with self.tscope.function_scope(defn):

self._visit_func_def(defn)