"""Expression type checker. This file is conceptually part of TypeChecker."""

from __future__ import annotations

import enum

import itertools

import time

from collections import defaultdict

from contextlib import contextmanager

from typing import Callable, ClassVar, Final, Iterable, Iterator, List, Optional, Sequence, cast

from typing_extensions import TypeAlias as _TypeAlias, assert_never, overload

import mypy.checker

import mypy.errorcodes as codes

from mypy import applytype, erasetype, join, message_registry, nodes, operators, types

from mypy.argmap import ArgTypeExpander, map_actuals_to_formals, map_formals_to_actuals

from mypy.checkmember import analyze_member_access, freeze_all_type_vars, type_object_type

from mypy.checkstrformat import StringFormatterChecker

from mypy.erasetype import erase_type, remove_instance_last_known_values, replace_meta_vars

from mypy.errors import ErrorWatcher, report_internal_error

from mypy.expandtype import (

expand_type,

expand_type_by_instance,

freshen_all_functions_type_vars,

freshen_function_type_vars,

)

from mypy.infer import ArgumentInferContext, infer_function_type_arguments, infer_type_arguments

from mypy.literals import literal

from mypy.maptype import map_instance_to_supertype

from mypy.meet import is_overlapping_types, narrow_declared_type

from mypy.message_registry import ErrorMessage

from mypy.messages import MessageBuilder, format_type

from mypy.nodes import (

ARG_NAMED,

ARG_POS,

ARG_STAR,

ARG_STAR2,

IMPLICITLY_ABSTRACT,

LITERAL_TYPE,

REVEAL_LOCALS,

REVEAL_TYPE,

ArgKind,

AssertTypeExpr,

AssignmentExpr,

AwaitExpr,

BytesExpr,

CallExpr,

CastExpr,

ComparisonExpr,

ComplexExpr,

ConditionalExpr,

Context,

Decorator,

DictExpr,

DictionaryComprehension,

EllipsisExpr,

EnumCallExpr,

Expression,

FloatExpr,

FuncDef,

GeneratorExpr,

IndexExpr,

IntExpr,

LambdaExpr,

ListComprehension,

ListExpr,

MemberExpr,

MypyFile,

NamedTupleExpr,

NameExpr,

NewTypeExpr,

OpExpr,

OverloadedFuncDef,

ParamSpecExpr,

PlaceholderNode,

PromoteExpr,

RefExpr,

RevealExpr,

SetComprehension,

SetExpr,

SliceExpr,

StarExpr,

StrExpr,

SuperExpr,

SymbolNode,

TempNode,

TupleExpr,

TypeAlias,

TypeAliasExpr,

TypeApplication,

TypedDictExpr,

TypeInfo,

TypeVarExpr,

TypeVarTupleExpr,

UnaryExpr,

Var,

YieldExpr,

YieldFromExpr,

)

from mypy.options import PRECISE_TUPLE_TYPES

from mypy.plugin import (

FunctionContext,

FunctionSigContext,

MethodContext,

MethodSigContext,

Plugin,

)

from mypy.semanal_enum import ENUM_BASES

from mypy.state import state

from mypy.subtypes import (

find_member,

is_equivalent,

is_same_type,

is_subtype,

non_method_protocol_members,

)

from mypy.traverser import has_await_expression

from mypy.type_visitor import TypeTranslator

from mypy.typeanal import (

check_for_explicit_any,

fix_instance,

has_any_from_unimported_type,

instantiate_type_alias,

make_optional_type,

set_any_tvars,

validate_instance,

)

from mypy.typeops import (

callable_type,

custom_special_method,

erase_to_union_or_bound,

false_only,

fixup_partial_type,

function_type,

get_all_type_vars,

get_type_vars,

is_literal_type_like,

make_simplified_union,

simple_literal_type,

true_only,

try_expanding_sum_type_to_union,

try_getting_str_literals,

tuple_fallback,

)

from mypy.types import (

LITERAL_TYPE_NAMES,

TUPLE_LIKE_INSTANCE_NAMES,

AnyType,

CallableType,

DeletedType,

ErasedType,

ExtraAttrs,

FunctionLike,

Instance,

LiteralType,

LiteralValue,

NoneType,

Overloaded,

Parameters,

ParamSpecFlavor,

ParamSpecType,

PartialType,

ProperType,

TupleType,

Type,

TypeAliasType,

TypedDictType,

TypeOfAny,

TypeType,

TypeVarLikeType,

TypeVarTupleType,

TypeVarType,

UnboundType,

UninhabitedType,

UnionType,

UnpackType,

find_unpack_in_list,

flatten_nested_tuples,

flatten_nested_unions,

get_proper_type,

get_proper_types,

has_recursive_types,

is_named_instance,

remove_dups,

split_with_prefix_and_suffix,

)

from mypy.types_utils import (

is_generic_instance,

is_overlapping_none,

is_self_type_like,

remove_optional,

)

from mypy.typestate import type_state

from mypy.typevars import fill_typevars

from mypy.util import split_module_names

from mypy.visitor import ExpressionVisitor

# Type of callback user for checking individual function arguments. See

# check_args() below for details.

ArgChecker: _TypeAlias = Callable[

[Type, Type, ArgKind, Type, int, int, CallableType, Optional[Type], Context, Context], None

]

# Maximum nesting level for math union in overloads, setting this to large values

# may cause performance issues. The reason is that although union math algorithm we use

# nicely captures most corner cases, its worst case complexity is exponential,

# see https://github.com/python/mypy/pull/5255#discussion_r196896335 for discussion.

MAX_UNIONS: Final = 5

# Types considered safe for comparisons with --strict-equality due to known behaviour of __eq__.

# NOTE: All these types are subtypes of AbstractSet.

OVERLAPPING_TYPES_ALLOWLIST: Final = [

"builtins.set",

"builtins.frozenset",

"typing.KeysView",

"typing.ItemsView",

"builtins._dict_keys",

"builtins._dict_items",

"_collections_abc.dict_keys",

"_collections_abc.dict_items",

]

OVERLAPPING_BYTES_ALLOWLIST: Final = {

"builtins.bytes",

"builtins.bytearray",

"builtins.memoryview",

}

class TooManyUnions(Exception):

"""Indicates that we need to stop splitting unions in an attempt

to match an overload in order to save performance.

"""

def allow_fast_container_literal(t: Type) -> bool:

if isinstance(t, TypeAliasType) and t.is_recursive:

return False

t = get_proper_type(t)

return isinstance(t, Instance) or (

isinstance(t, TupleType) and all(allow_fast_container_literal(it) for it in t.items)

)

def extract_refexpr_names(expr: RefExpr) -> set[str]:

"""Recursively extracts all module references from a reference expression.

Note that currently, the only two subclasses of RefExpr are NameExpr and

MemberExpr."""

output: set[str] = set()

while isinstance(expr.node, MypyFile) or expr.fullname:

if isinstance(expr.node, MypyFile) and expr.fullname:

# If it's None, something's wrong (perhaps due to an

# import cycle or a suppressed error). For now we just

# skip it.

output.add(expr.fullname)

if isinstance(expr, NameExpr):

is_suppressed_import = isinstance(expr.node, Var) and expr.node.is_suppressed_import

if isinstance(expr.node, TypeInfo):

# Reference to a class or a nested class

output.update(split_module_names(expr.node.module_name))

elif "." in expr.fullname and not is_suppressed_import:

# Everything else (that is not a silenced import within a class)

output.add(expr.fullname.rsplit(".", 1)[0])

break

elif isinstance(expr, MemberExpr):

if isinstance(expr.expr, RefExpr):

expr = expr.expr

else:

break

else:

raise AssertionError(f"Unknown RefExpr subclass: {type(expr)}")

return output

class Finished(Exception):

"""Raised if we can terminate overload argument check early (no match)."""

@enum.unique

class UseReverse(enum.Enum):

"""Used in `visit_op_expr` to enable or disable reverse method checks."""

DEFAULT = 0

ALWAYS = 1

NEVER = 2

USE_REVERSE_DEFAULT: Final = UseReverse.DEFAULT

USE_REVERSE_ALWAYS: Final = UseReverse.ALWAYS

USE_REVERSE_NEVER: Final = UseReverse.NEVER

class ExpressionChecker(ExpressionVisitor[Type]):

"""Expression type checker.

This class works closely together with checker.TypeChecker.

"""

# Some services are provided by a TypeChecker instance.

chk: mypy.checker.TypeChecker

# This is shared with TypeChecker, but stored also here for convenience.

msg: MessageBuilder

# Type context for type inference

type_context: list[Type | None]

# cache resolved types in some cases

resolved_type: dict[Expression, ProperType]

strfrm_checker: StringFormatterChecker

plugin: Plugin

def __init__(

self,

chk: mypy.checker.TypeChecker,

msg: MessageBuilder,

plugin: Plugin,

per_line_checking_time_ns: dict[int, int],

) -> None:

"""Construct an expression type checker."""

self.chk = chk

self.msg = msg

self.plugin = plugin

self.per_line_checking_time_ns = per_line_checking_time_ns

self.collect_line_checking_stats = chk.options.line_checking_stats is not None

# Are we already visiting some expression? This is used to avoid double counting

# time for nested expressions.

self.in_expression = False

self.type_context = [None]

# Temporary overrides for expression types. This is currently

# used by the union math in overloads.

# TODO: refactor this to use a pattern similar to one in

# multiassign_from_union, or maybe even combine the two?

self.type_overrides: dict[Expression, Type] = {}

self.strfrm_checker = StringFormatterChecker(self, self.chk, self.msg)

self.resolved_type = {}

# Callee in a call expression is in some sense both runtime context and

# type context, because we support things like C[int](...). Store information

# on whether current expression is a callee, to give better error messages

# related to type context.

self.is_callee = False

type_state.infer_polymorphic = not self.chk.options.old_type_inference

def reset(self) -> None:

self.resolved_type = {}

def visit_name_expr(self, e: NameExpr) -> Type:

"""Type check a name expression.

It can be of any kind: local, member or global.

"""

self.chk.module_refs.update(extract_refexpr_names(e))

result = self.analyze_ref_expr(e)

return self.narrow_type_from_binder(e, result)

def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:

result: Type | None = None

node = e.node

if isinstance(e, NameExpr) and e.is_special_form:

# A special form definition, nothing to check here.

return AnyType(TypeOfAny.special_form)

if isinstance(node, Var):

# Variable reference.

result = self.analyze_var_ref(node, e)

if isinstance(result, PartialType):

result = self.chk.handle_partial_var_type(result, lvalue, node, e)

elif isinstance(node, FuncDef):

# Reference to a global function.

result = function_type(node, self.named_type("builtins.function"))

elif isinstance(node, OverloadedFuncDef):

if node.type is None:

if self.chk.in_checked_function() and node.items:

self.chk.handle_cannot_determine_type(node.name, e)

result = AnyType(TypeOfAny.from_error)

else:

result = node.type

elif isinstance(node, TypeInfo):

# Reference to a type object.

if node.typeddict_type:

# We special-case TypedDict, because they don't define any constructor.

result = self.typeddict_callable(node)

elif node.fullname == "types.NoneType":

# We special case NoneType, because its stub definition is not related to None.

result = TypeType(NoneType())

else:

result = type_object_type(node, self.named_type)

if isinstance(result, CallableType) and isinstance( # type: ignore[misc]

result.ret_type, Instance

):

# We need to set correct line and column

# TODO: always do this in type_object_type by passing the original context

result.ret_type.line = e.line

result.ret_type.column = e.column

if isinstance(get_proper_type(self.type_context[-1]), TypeType):

# This is the type in a Type[] expression, so substitute type

# variables with Any.

result = erasetype.erase_typevars(result)

elif isinstance(node, MypyFile):

# Reference to a module object.

result = self.module_type(node)

elif isinstance(node, Decorator):

result = self.analyze_var_ref(node.var, e)

elif isinstance(node, TypeAlias):

# Something that refers to a type alias appears in runtime context.

# Note that we suppress bogus errors for alias redefinitions,

# they are already reported in semanal.py.

result = self.alias_type_in_runtime_context(

node, ctx=e, alias_definition=e.is_alias_rvalue or lvalue

)

elif isinstance(node, (TypeVarExpr, ParamSpecExpr, TypeVarTupleExpr)):

result = self.object_type()

else:

if isinstance(node, PlaceholderNode):

assert False, f"PlaceholderNode {node.fullname!r} leaked to checker"

# Unknown reference; use any type implicitly to avoid

# generating extra type errors.

result = AnyType(TypeOfAny.from_error)

assert result is not None

return result

def analyze_var_ref(self, var: Var, context: Context) -> Type:

if var.type:

var_type = get_proper_type(var.type)

if isinstance(var_type, Instance):

if self.is_literal_context() and var_type.last_known_value is not None:

return var_type.last_known_value

if var.name in {"True", "False"}:

return self.infer_literal_expr_type(var.name == "True", "builtins.bool")

return var.type

else:

if not var.is_ready and self.chk.in_checked_function():

self.chk.handle_cannot_determine_type(var.name, context)

# Implicit 'Any' type.

return AnyType(TypeOfAny.special_form)

def module_type(self, node: MypyFile) -> Instance:

try:

result = self.named_type("types.ModuleType")

except KeyError:

# In test cases might 'types' may not be available.

# Fall back to a dummy 'object' type instead to

# avoid a crash.

result = self.named_type("builtins.object")

module_attrs = {}

immutable = set()

for name, n in node.names.items():

if not n.module_public:

continue

if isinstance(n.node, Var) and n.node.is_final:

immutable.add(name)

typ = self.chk.determine_type_of_member(n)

if typ:

module_attrs[name] = typ

else:

# TODO: what to do about nested module references?

# They are non-trivial because there may be import cycles.

module_attrs[name] = AnyType(TypeOfAny.special_form)

result.extra_attrs = ExtraAttrs(module_attrs, immutable, node.fullname)

return result

def visit_call_expr(self, e: CallExpr, allow_none_return: bool = False) -> Type:

"""Type check a call expression."""

if e.analyzed:

if isinstance(e.analyzed, NamedTupleExpr) and not e.analyzed.is_typed:

# Type check the arguments, but ignore the results. This relies

# on the typeshed stubs to type check the arguments.

self.visit_call_expr_inner(e)

# It's really a special form that only looks like a call.

return self.accept(e.analyzed, self.type_context[-1])

return self.visit_call_expr_inner(e, allow_none_return=allow_none_return)

def refers_to_typeddict(self, base: Expression) -> bool:

if not isinstance(base, RefExpr):

return False

if isinstance(base.node, TypeInfo) and base.node.typeddict_type is not None:

# Direct reference.

return True

return isinstance(base.node, TypeAlias) and isinstance(

get_proper_type(base.node.target), TypedDictType

)

def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) -> Type:

if (

self.refers_to_typeddict(e.callee)

or isinstance(e.callee, IndexExpr)

and self.refers_to_typeddict(e.callee.base)

):

typeddict_callable = get_proper_type(self.accept(e.callee, is_callee=True))

if isinstance(typeddict_callable, CallableType):

typeddict_type = get_proper_type(typeddict_callable.ret_type)

assert isinstance(typeddict_type, TypedDictType)

return self.check_typeddict_call(

typeddict_type, e.arg_kinds, e.arg_names, e.args, e, typeddict_callable

)

if (

isinstance(e.callee, NameExpr)

and e.callee.name in ("isinstance", "issubclass")

and len(e.args) == 2

):

for typ in mypy.checker.flatten(e.args[1]):

node = None

if isinstance(typ, NameExpr):

try:

node = self.chk.lookup_qualified(typ.name)

except KeyError:

# Undefined names should already be reported in semantic analysis.

pass

if is_expr_literal_type(typ):

self.msg.cannot_use_function_with_type(e.callee.name, "Literal", e)

continue

if node and isinstance(node.node, TypeAlias):

target = get_proper_type(node.node.target)

if isinstance(target, AnyType):

self.msg.cannot_use_function_with_type(e.callee.name, "Any", e)

continue

if isinstance(target, NoneType):

continue

if (

isinstance(typ, IndexExpr)

and isinstance(typ.analyzed, (TypeApplication, TypeAliasExpr))

) or (

isinstance(typ, NameExpr)

and node

and isinstance(node.node, TypeAlias)

and not node.node.no_args

):

self.msg.type_arguments_not_allowed(e)

if isinstance(typ, RefExpr) and isinstance(typ.node, TypeInfo):

if typ.node.typeddict_type:

self.msg.cannot_use_function_with_type(e.callee.name, "TypedDict", e)

elif typ.node.is_newtype:

self.msg.cannot_use_function_with_type(e.callee.name, "NewType", e)

self.try_infer_partial_type(e)

type_context = None

if isinstance(e.callee, LambdaExpr):

formal_to_actual = map_actuals_to_formals(

e.arg_kinds,

e.arg_names,

e.callee.arg_kinds,

e.callee.arg_names,

lambda i: self.accept(e.args[i]),

)

arg_types = [

join.join_type_list([self.accept(e.args[j]) for j in formal_to_actual[i]])

for i in range(len(e.callee.arg_kinds))

]

type_context = CallableType(

arg_types,

e.callee.arg_kinds,

e.callee.arg_names,

ret_type=self.object_type(),

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

)

callee_type = get_proper_type(

self.accept(e.callee, type_context, always_allow_any=True, is_callee=True)

)

# Figure out the full name of the callee for plugin lookup.

object_type = None

member = None

fullname = None

if isinstance(e.callee, RefExpr):

# There are two special cases where plugins might act:

# * A "static" reference/alias to a class or function;

# get_function_hook() will be invoked for these.

fullname = e.callee.fullname or None

if isinstance(e.callee.node, TypeAlias):

target = get_proper_type(e.callee.node.target)

if isinstance(target, Instance):

fullname = target.type.fullname

# * Call to a method on object that has a full name (see

# method_fullname() for details on supported objects);

# get_method_hook() and get_method_signature_hook() will

# be invoked for these.

if (

not fullname

and isinstance(e.callee, MemberExpr)

and self.chk.has_type(e.callee.expr)

):

member = e.callee.name

object_type = self.chk.lookup_type(e.callee.expr)

if (

self.chk.options.disallow_untyped_calls

and self.chk.in_checked_function()

and isinstance(callee_type, CallableType)

and callee_type.implicit

):

if fullname is None and member is not None:

assert object_type is not None

fullname = self.method_fullname(object_type, member)

if not fullname or not any(

fullname == p or fullname.startswith(f"{p}.")

for p in self.chk.options.untyped_calls_exclude

):

self.msg.untyped_function_call(callee_type, e)

ret_type = self.check_call_expr_with_callee_type(

callee_type, e, fullname, object_type, member

)

if isinstance(e.callee, RefExpr) and len(e.args) == 2:

if e.callee.fullname in ("builtins.isinstance", "builtins.issubclass"):

self.check_runtime_protocol_test(e)

if e.callee.fullname == "builtins.issubclass":

self.check_protocol_issubclass(e)

if isinstance(e.callee, MemberExpr) and e.callee.name == "format":

self.check_str_format_call(e)

ret_type = get_proper_type(ret_type)

if isinstance(ret_type, UnionType):

ret_type = make_simplified_union(ret_type.items)

if isinstance(ret_type, UninhabitedType) and not ret_type.ambiguous:

self.chk.binder.unreachable()

# Warn on calls to functions that always return None. The check

# of ret_type is both a common-case optimization and prevents reporting

# the error in dynamic functions (where it will be Any).

if (

not allow_none_return

and isinstance(ret_type, NoneType)

and self.always_returns_none(e.callee)

):

self.chk.msg.does_not_return_value(callee_type, e)

return AnyType(TypeOfAny.from_error)

return ret_type

def check_str_format_call(self, e: CallExpr) -> None:

"""More precise type checking for str.format() calls on literals."""

assert isinstance(e.callee, MemberExpr)

format_value = None

if isinstance(e.callee.expr, StrExpr):

format_value = e.callee.expr.value

elif self.chk.has_type(e.callee.expr):

typ = get_proper_type(self.chk.lookup_type(e.callee.expr))

if (

isinstance(typ, Instance)

and typ.type.is_enum

and isinstance(typ.last_known_value, LiteralType)

and isinstance(typ.last_known_value.value, str)

):

value_type = typ.type.names[typ.last_known_value.value].type

if isinstance(value_type, Type):

typ = get_proper_type(value_type)

base_typ = try_getting_literal(typ)

if isinstance(base_typ, LiteralType) and isinstance(base_typ.value, str):

format_value = base_typ.value

if format_value is not None:

self.strfrm_checker.check_str_format_call(e, format_value)

def method_fullname(self, object_type: Type, method_name: str) -> str | None:

"""Convert a method name to a fully qualified name, based on the type of the object that

it is invoked on. Return `None` if the name of `object_type` cannot be determined.

"""

object_type = get_proper_type(object_type)

if isinstance(object_type, CallableType) and object_type.is_type_obj():

# For class method calls, object_type is a callable representing the class object.

# We "unwrap" it to a regular type, as the class/instance method difference doesn't

# affect the fully qualified name.

object_type = get_proper_type(object_type.ret_type)

elif isinstance(object_type, TypeType):

object_type = object_type.item

type_name = None

if isinstance(object_type, Instance):

type_name = object_type.type.fullname

elif isinstance(object_type, (TypedDictType, LiteralType)):

info = object_type.fallback.type.get_containing_type_info(method_name)

type_name = info.fullname if info is not None else None

elif isinstance(object_type, TupleType):

type_name = tuple_fallback(object_type).type.fullname

if type_name:

return f"{type_name}.{method_name}"

else:

return None

def always_returns_none(self, node: Expression) -> bool:

"""Check if `node` refers to something explicitly annotated as only returning None."""

if isinstance(node, RefExpr):

if self.defn_returns_none(node.node):

return True

if isinstance(node, MemberExpr) and node.node is None: # instance or class attribute

typ = get_proper_type(self.chk.lookup_type(node.expr))

if isinstance(typ, Instance):

info = typ.type

elif isinstance(typ, CallableType) and typ.is_type_obj():

ret_type = get_proper_type(typ.ret_type)

if isinstance(ret_type, Instance):

info = ret_type.type

else:

return False

else:

return False

sym = info.get(node.name)

if sym and self.defn_returns_none(sym.node):

return True

return False

def defn_returns_none(self, defn: SymbolNode | None) -> bool:

"""Check if `defn` can _only_ return None."""

if isinstance(defn, FuncDef):

return isinstance(defn.type, CallableType) and isinstance(

get_proper_type(defn.type.ret_type), NoneType

)

if isinstance(defn, OverloadedFuncDef):

return all(self.defn_returns_none(item) for item in defn.items)

if isinstance(defn, Var):

typ = get_proper_type(defn.type)

if (

not defn.is_inferred

and isinstance(typ, CallableType)

and isinstance(get_proper_type(typ.ret_type), NoneType)

):

return True

if isinstance(typ, Instance):

sym = typ.type.get("__call__")

if sym and self.defn_returns_none(sym.node):

return True

return False

def check_runtime_protocol_test(self, e: CallExpr) -> None:

for expr in mypy.checker.flatten(e.args[1]):

tp = get_proper_type(self.chk.lookup_type(expr))

if (

isinstance(tp, FunctionLike)

and tp.is_type_obj()

and tp.type_object().is_protocol

and not tp.type_object().runtime_protocol

):

self.chk.fail(message_registry.RUNTIME_PROTOCOL_EXPECTED, e)

def check_protocol_issubclass(self, e: CallExpr) -> None:

for expr in mypy.checker.flatten(e.args[1]):

tp = get_proper_type(self.chk.lookup_type(expr))

if isinstance(tp, FunctionLike) and tp.is_type_obj() and tp.type_object().is_protocol:

attr_members = non_method_protocol_members(tp.type_object())

if attr_members:

self.chk.msg.report_non_method_protocol(tp.type_object(), attr_members, e)

def check_typeddict_call(

self,

callee: TypedDictType,

arg_kinds: list[ArgKind],

arg_names: Sequence[str | None],

args: list[Expression],

context: Context,

orig_callee: Type | None,

) -> Type:

if args and all(ak in (ARG_NAMED, ARG_STAR2) for ak in arg_kinds):

# ex: Point(x=42, y=1337, **extras)

# This is a bit ugly, but this is a price for supporting all possible syntax

# variants for TypedDict constructors.

kwargs = zip([StrExpr(n) if n is not None else None for n in arg_names], args)

result = self.validate_typeddict_kwargs(kwargs=kwargs, callee=callee)

if result is not None:

validated_kwargs, always_present_keys = result

return self.check_typeddict_call_with_kwargs(

callee, validated_kwargs, context, orig_callee, always_present_keys

)

return AnyType(TypeOfAny.from_error)

if len(args) == 1 and arg_kinds[0] == ARG_POS:

unique_arg = args[0]

if isinstance(unique_arg, DictExpr):

# ex: Point({'x': 42, 'y': 1337, **extras})

return self.check_typeddict_call_with_dict(

callee, unique_arg.items, context, orig_callee

)

if isinstance(unique_arg, CallExpr) and isinstance(unique_arg.analyzed, DictExpr):

# ex: Point(dict(x=42, y=1337, **extras))

return self.check_typeddict_call_with_dict(

callee, unique_arg.analyzed.items, context, orig_callee

)

if not args:

# ex: EmptyDict()

return self.check_typeddict_call_with_kwargs(callee, {}, context, orig_callee, set())

self.chk.fail(message_registry.INVALID_TYPEDDICT_ARGS, context)

return AnyType(TypeOfAny.from_error)

def validate_typeddict_kwargs(

self, kwargs: Iterable[tuple[Expression | None, Expression]], callee: TypedDictType

) -> tuple[dict[str, list[Expression]], set[str]] | None:

# All (actual or mapped from ** unpacks) expressions that can match given key.

result = defaultdict(list)

# Keys that are guaranteed to be present no matter what (e.g. for all items of a union)

always_present_keys = set()

# Indicates latest encountered ** unpack among items.

last_star_found = None

for item_name_expr, item_arg in kwargs:

if item_name_expr:

key_type = self.accept(item_name_expr)

values = try_getting_str_literals(item_name_expr, key_type)

literal_value = None

if values and len(values) == 1:

literal_value = values[0]

if literal_value is None:

key_context = item_name_expr or item_arg

self.chk.fail(

message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL,

key_context,

code=codes.LITERAL_REQ,

)

return None

else:

# A directly present key unconditionally shadows all previously found

# values from ** items.

# TODO: for duplicate keys, type-check all values.

result[literal_value] = [item_arg]

always_present_keys.add(literal_value)

else:

last_star_found = item_arg

if not self.validate_star_typeddict_item(

item_arg, callee, result, always_present_keys

):

return None

if self.chk.options.extra_checks and last_star_found is not None:

absent_keys = []

for key in callee.items:

if key not in callee.required_keys and key not in result:

absent_keys.append(key)

if absent_keys:

# Having an optional key not explicitly declared by a ** unpacked

# TypedDict is unsafe, it may be an (incompatible) subtype at runtime.

# TODO: catch the cases where a declared key is overridden by a subsequent

# ** item without it (and not again overriden with complete ** item).

self.msg.non_required_keys_absent_with_star(absent_keys, last_star_found)

return result, always_present_keys

def validate_star_typeddict_item(

self,

item_arg: Expression,

callee: TypedDictType,

result: dict[str, list[Expression]],

always_present_keys: set[str],

) -> bool:

"""Update keys/expressions from a ** expression in TypedDict constructor.

Note `result` and `always_present_keys` are updated in place. Return true if the

expression `item_arg` may valid in `callee` TypedDict context.

"""

inferred = get_proper_type(self.accept(item_arg, type_context=callee))

possible_tds = []

if isinstance(inferred, TypedDictType):

possible_tds = [inferred]

elif isinstance(inferred, UnionType):

for item in get_proper_types(inferred.relevant_items()):

if isinstance(item, TypedDictType):

possible_tds.append(item)

elif not self.valid_unpack_fallback_item(item):

self.msg.unsupported_target_for_star_typeddict(item, item_arg)

return False

elif not self.valid_unpack_fallback_item(inferred):

self.msg.unsupported_target_for_star_typeddict(inferred, item_arg)

return False

all_keys: set[str] = set()

for td in possible_tds:

all_keys |= td.items.keys()

for key in all_keys:

arg = TempNode(

UnionType.make_union([td.items[key] for td in possible_tds if key in td.items])

)

arg.set_line(item_arg)

if all(key in td.required_keys for td in possible_tds):

always_present_keys.add(key)

# Always present keys override previously found values. This is done

# to support use cases like `Config({**defaults, **overrides})`, where

# some `overrides` types are narrower that types in `defaults`, and

# former are too wide for `Config`.

if result[key]:

first = result[key][0]

if not isinstance(first, TempNode):

# We must always preserve any non-synthetic values, so that

# we will accept them even if they are shadowed.

result[key] = [first, arg]

else:

result[key] = [arg]

else:

result[key] = [arg]

else:

# If this key is not required at least in some item of a union

# it may not shadow previous item, so we need to type check both.

result[key].append(arg)

return True

def valid_unpack_fallback_item(self, typ: ProperType) -> bool:

if isinstance(typ, AnyType):

return True

if not isinstance(typ, Instance) or not typ.type.has_base("typing.Mapping"):

return False

mapped = map_instance_to_supertype(typ, self.chk.lookup_typeinfo("typing.Mapping"))

return all(isinstance(a, AnyType) for a in get_proper_types(mapped.args))

def match_typeddict_call_with_dict(

self,

callee: TypedDictType,

kwargs: list[tuple[Expression | None, Expression]],

context: Context,

) -> bool:

result = self.validate_typeddict_kwargs(kwargs=kwargs, callee=callee)

if result is not None:

validated_kwargs, _ = result

return callee.required_keys <= set(validated_kwargs.keys()) <= set(callee.items.keys())

else:

return False

def check_typeddict_call_with_dict(

self,

callee: TypedDictType,

kwargs: list[tuple[Expression | None, Expression]],

context: Context,

orig_callee: Type | None,

) -> Type:

result = self.validate_typeddict_kwargs(kwargs=kwargs, callee=callee)

if result is not None:

validated_kwargs, always_present_keys = result

return self.check_typeddict_call_with_kwargs(

callee,

kwargs=validated_kwargs,

context=context,

orig_callee=orig_callee,

always_present_keys=always_present_keys,

)

else:

return AnyType(TypeOfAny.from_error)

def typeddict_callable(self, info: TypeInfo) -> CallableType:

"""Construct a reasonable type for a TypedDict type in runtime context.

If it appears as a callee, it will be special-cased anyway, e.g. it is

also allowed to accept a single positional argument if it is a dict literal.

Note it is not safe to move this to type_object_type() since it will crash

on plugin-generated TypedDicts, that may not have the special_alias.

"""

assert info.special_alias is not None

target = info.special_alias.target

assert isinstance(target, ProperType) and isinstance(target, TypedDictType)

expected_types = list(target.items.values())

kinds = [ArgKind.ARG_NAMED] * len(expected_types)

names = list(target.items.keys())

return CallableType(

expected_types,

kinds,

names,

target,

self.named_type("builtins.type"),

variables=info.defn.type_vars,

)

def typeddict_callable_from_context(self, callee: TypedDictType) -> CallableType:

return CallableType(

list(callee.items.values()),

[

ArgKind.ARG_NAMED if name in callee.required_keys else ArgKind.ARG_NAMED_OPT

for name in callee.items

],

list(callee.items.keys()),

callee,

self.named_type("builtins.type"),

)

def check_typeddict_call_with_kwargs(

self,

callee: TypedDictType,

kwargs: dict[str, list[Expression]],

context: Context,

orig_callee: Type | None,

always_present_keys: set[str],

) -> Type:

actual_keys = kwargs.keys()

if not (

callee.required_keys <= always_present_keys and actual_keys <= callee.items.keys()

):

if not (actual_keys <= callee.items.keys()):

self.msg.unexpected_typeddict_keys(

callee,

expected_keys=[

key

for key in callee.items.keys()

if key in callee.required_keys or key in actual_keys

],

actual_keys=list(actual_keys),

context=context,

)

if not (callee.required_keys <= always_present_keys):

self.msg.unexpected_typeddict_keys(

callee,

expected_keys=[

key for key in callee.items.keys() if key in callee.required_keys

],

actual_keys=[