"""Facilities for generating error messages during type checking.

Don't add any non-trivial message construction logic to the type

checker, as it can compromise clarity and make messages less

consistent. Add such logic to this module instead. Literal messages, including those

with format args, should be defined as constants in mypy.message_registry.

Historically we tried to avoid all message string literals in the type

checker but we are moving away from this convention.

"""

from __future__ import annotations

import difflib

import itertools

import re

from contextlib import contextmanager

from textwrap import dedent

from typing import Any, Callable, Collection, Final, Iterable, Iterator, List, Sequence, cast

import mypy.typeops

from mypy import errorcodes as codes, message_registry

from mypy.erasetype import erase_type

from mypy.errorcodes import ErrorCode

from mypy.errors import ErrorInfo, Errors, ErrorWatcher

from mypy.nodes import (

ARG_NAMED,

ARG_NAMED_OPT,

ARG_OPT,

ARG_POS,

ARG_STAR,

ARG_STAR2,

CONTRAVARIANT,

COVARIANT,

SYMBOL_FUNCBASE_TYPES,

ArgKind,

CallExpr,

ClassDef,

Context,

Expression,

FuncDef,

IndexExpr,

MypyFile,

NameExpr,

ReturnStmt,

StrExpr,

SymbolNode,

SymbolTable,

TypeInfo,

Var,

reverse_builtin_aliases,

)

from mypy.operators import op_methods, op_methods_to_symbols

from mypy.options import Options

from mypy.subtypes import (

IS_CLASS_OR_STATIC,

IS_CLASSVAR,

IS_SETTABLE,

IS_VAR,

find_member,

get_member_flags,

is_same_type,

is_subtype,

)

from mypy.typeops import separate_union_literals

from mypy.types import (

AnyType,

CallableType,

DeletedType,

FunctionLike,

Instance,

LiteralType,

NoneType,

Overloaded,

Parameters,

ParamSpecType,

PartialType,

ProperType,

TupleType,

Type,

TypeAliasType,

TypedDictType,

TypeOfAny,

TypeStrVisitor,

TypeType,

TypeVarTupleType,

TypeVarType,

UnboundType,

UninhabitedType,

UnionType,

UnpackType,

get_proper_type,

get_proper_types,

)

from mypy.typetraverser import TypeTraverserVisitor

from mypy.util import plural_s, unmangle

TYPES_FOR_UNIMPORTED_HINTS: Final = {

"typing.Any",

"typing.Callable",

"typing.Dict",

"typing.Iterable",

"typing.Iterator",

"typing.List",

"typing.Optional",

"typing.Set",

"typing.Tuple",

"typing.TypeVar",

"typing.Union",

"typing.cast",

}

ARG_CONSTRUCTOR_NAMES: Final = {

ARG_POS: "Arg",

ARG_OPT: "DefaultArg",

ARG_NAMED: "NamedArg",

ARG_NAMED_OPT: "DefaultNamedArg",

ARG_STAR: "VarArg",

ARG_STAR2: "KwArg",

}

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

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

# generating better error messages when running mypy tests only.

SUGGESTED_TEST_FIXTURES: Final = {

"builtins.set": "set.pyi",

"builtins.tuple": "tuple.pyi",

"builtins.bool": "bool.pyi",

"builtins.Exception": "exception.pyi",

"builtins.BaseException": "exception.pyi",

"builtins.isinstance": "isinstancelist.pyi",

"builtins.property": "property.pyi",

"builtins.classmethod": "classmethod.pyi",

"typing._SpecialForm": "typing-medium.pyi",

}

UNSUPPORTED_NUMBERS_TYPES: Final = {

"numbers.Number",

"numbers.Complex",

"numbers.Real",

"numbers.Rational",

"numbers.Integral",

}

class MessageBuilder:

"""Helper class for reporting type checker error messages with parameters.

The methods of this class need to be provided with the context within a

file; the errors member manages the wider context.

IDEA: Support a 'verbose mode' that includes full information about types

in error messages and that may otherwise produce more detailed error

messages.

"""

# Report errors using this instance. It knows about the current file and

# import context.

errors: Errors

modules: dict[str, MypyFile]

# Hack to deduplicate error messages from union types

_disable_type_names: list[bool]

def __init__(self, errors: Errors, modules: dict[str, MypyFile]) -> None:

self.errors = errors

self.options = errors.options

self.modules = modules

self._disable_type_names = []

#

# Helpers

#

def filter_errors(

self,

*,

filter_errors: bool | Callable[[str, ErrorInfo], bool] = True,

save_filtered_errors: bool = False,

) -> ErrorWatcher:

return ErrorWatcher(

self.errors, filter_errors=filter_errors, save_filtered_errors=save_filtered_errors

)

def add_errors(self, errors: list[ErrorInfo]) -> None:

"""Add errors in messages to this builder."""

for info in errors:

self.errors.add_error_info(info)

@contextmanager

def disable_type_names(self) -> Iterator[None]:

self._disable_type_names.append(True)

try:

yield

finally:

self._disable_type_names.pop()

def are_type_names_disabled(self) -> bool:

return len(self._disable_type_names) > 0 and self._disable_type_names[-1]

def prefer_simple_messages(self) -> bool:

"""Should we generate simple/fast error messages?

If errors aren't shown to the user, we don't want to waste cyles producing

complex error messages.

"""

return self.errors.prefer_simple_messages()

def report(

self,

msg: str,

context: Context | None,

severity: str,

*,

code: ErrorCode | None = None,

file: str | None = None,

origin: Context | None = None,

offset: int = 0,

allow_dups: bool = False,

secondary_context: Context | None = None,

) -> None:

"""Report an error or note (unless disabled).

Note that context controls where error is reported, while origin controls

where # type: ignore comments have effect.

"""

def span_from_context(ctx: Context) -> Iterable[int]:

"""This determines where a type: ignore for a given context has effect.

Current logic is a bit tricky, to keep as much backwards compatibility as

possible. We may reconsider this to always be a single line (or otherwise

simplify it) when we drop Python 3.7.

TODO: address this in follow up PR

"""

if isinstance(ctx, (ClassDef, FuncDef)):

return range(ctx.deco_line or ctx.line, ctx.line + 1)

elif not isinstance(ctx, Expression):

return [ctx.line]

else:

return range(ctx.line, (ctx.end_line or ctx.line) + 1)

origin_span: Iterable[int] | None

if origin is not None:

origin_span = span_from_context(origin)

elif context is not None:

origin_span = span_from_context(context)

else:

origin_span = None

if secondary_context is not None:

assert origin_span is not None

origin_span = itertools.chain(origin_span, span_from_context(secondary_context))

end_line = context.end_line if context else -1

end_column = context.end_column if context else -1

# set end line and column to same as start of context for function definitions

# this avoids errors being reported in IDEs for the whole function

# TODO: figure out if it's possible to find the end of the function definition line

if isinstance(context, FuncDef):

end_line = context.def_end_line

# column is 1-based, see also format_messages in errors.py

end_column = (

context.def_end_column + 1 if context.def_end_column is not None else end_column

)

self.errors.report(

context.line if context else -1,

context.column if context else -1,

msg,

severity=severity,

file=file,

offset=offset,

origin_span=origin_span,

end_line=end_line,

end_column=end_column,

code=code,

allow_dups=allow_dups,

)

def fail(

self,

msg: str,

context: Context | None,

*,

code: ErrorCode | None = None,

file: str | None = None,

allow_dups: bool = False,

secondary_context: Context | None = None,

) -> None:

"""Report an error message (unless disabled)."""

self.report(

msg,

context,

"error",

code=code,

file=file,

allow_dups=allow_dups,

secondary_context=secondary_context,

)

def note(

self,

msg: str,

context: Context,

file: str | None = None,

origin: Context | None = None,

offset: int = 0,

allow_dups: bool = False,

*,

code: ErrorCode | None = None,

secondary_context: Context | None = None,

) -> None:

"""Report a note (unless disabled)."""

self.report(

msg,

context,

"note",

file=file,

origin=origin,

offset=offset,

allow_dups=allow_dups,

code=code,

secondary_context=secondary_context,

)

def note_multiline(

self,

messages: str,

context: Context,

file: str | None = None,

offset: int = 0,

allow_dups: bool = False,

code: ErrorCode | None = None,

*,

secondary_context: Context | None = None,

) -> None:

"""Report as many notes as lines in the message (unless disabled)."""

for msg in messages.splitlines():

self.report(

msg,

context,

"note",

file=file,

offset=offset,

allow_dups=allow_dups,

code=code,

secondary_context=secondary_context,

)

#

# Specific operations

#

# The following operations are for generating specific error messages. They

# get some information as arguments, and they build an error message based

# on them.

def has_no_attr(

self,

original_type: Type,

typ: Type,

member: str,

context: Context,

module_symbol_table: SymbolTable | None = None,

) -> ErrorCode | None:

"""Report a missing or non-accessible member.

original_type is the top-level type on which the error occurred.

typ is the actual type that is missing the member. These can be

different, e.g., in a union, original_type will be the union and typ

will be the specific item in the union that does not have the member

attribute.

'module_symbol_table' is passed to this function if the type for which we

are trying to get a member was originally a module. The SymbolTable allows

us to look up and suggests attributes of the module since they are not

directly available on original_type

If member corresponds to an operator, use the corresponding operator

name in the messages. Return the error code that was produced, if any.

"""

original_type = get_proper_type(original_type)

typ = get_proper_type(typ)

if isinstance(original_type, Instance) and original_type.type.has_readable_member(member):

self.fail(f'Member "{member}" is not assignable', context)

return None

elif member == "__contains__":

self.fail(

f"Unsupported right operand type for in ({format_type(original_type, self.options)})",

context,

code=codes.OPERATOR,

)

return codes.OPERATOR

elif member in op_methods.values():

# Access to a binary operator member (e.g. _add). This case does

# not handle indexing operations.

for op, method in op_methods.items():

if method == member:

self.unsupported_left_operand(op, original_type, context)

return codes.OPERATOR

elif member == "__neg__":

self.fail(

f"Unsupported operand type for unary - ({format_type(original_type, self.options)})",

context,

code=codes.OPERATOR,

)

return codes.OPERATOR

elif member == "__pos__":

self.fail(

f"Unsupported operand type for unary + ({format_type(original_type, self.options)})",

context,

code=codes.OPERATOR,

)

return codes.OPERATOR

elif member == "__invert__":

self.fail(

f"Unsupported operand type for ~ ({format_type(original_type, self.options)})",

context,

code=codes.OPERATOR,

)

return codes.OPERATOR

elif member == "__getitem__":

# Indexed get.

# TODO: Fix this consistently in format_type

if isinstance(original_type, FunctionLike) and original_type.is_type_obj():

self.fail(

"The type {} is not generic and not indexable".format(

format_type(original_type, self.options)

),

context,

)

return None

else:

self.fail(

f"Value of type {format_type(original_type, self.options)} is not indexable",

context,

code=codes.INDEX,

)

return codes.INDEX

elif member == "__setitem__":

# Indexed set.

self.fail(

"Unsupported target for indexed assignment ({})".format(

format_type(original_type, self.options)

),

context,

code=codes.INDEX,

)

return codes.INDEX

elif member == "__call__":

if isinstance(original_type, Instance) and (

original_type.type.fullname == "builtins.function"

):

# "'function' not callable" is a confusing error message.

# Explain that the problem is that the type of the function is not known.

self.fail("Cannot call function of unknown type", context, code=codes.OPERATOR)

return codes.OPERATOR

else:

self.fail(

message_registry.NOT_CALLABLE.format(format_type(original_type, self.options)),

context,

code=codes.OPERATOR,

)

return codes.OPERATOR

else:

# The non-special case: a missing ordinary attribute.

extra = ""

if member == "__iter__":

extra = " (not iterable)"

elif member == "__aiter__":

extra = " (not async iterable)"

if not self.are_type_names_disabled():

failed = False

if isinstance(original_type, Instance) and original_type.type.names:

if (

module_symbol_table is not None

and member in module_symbol_table

and not module_symbol_table[member].module_public

):

self.fail(

f"{format_type(original_type, self.options, module_names=True)} does not "

f'explicitly export attribute "{member}"',

context,

code=codes.ATTR_DEFINED,

)

failed = True

else:

alternatives = set(original_type.type.names.keys())

if module_symbol_table is not None:

alternatives |= {

k for k, v in module_symbol_table.items() if v.module_public

}

# Rare but possible, see e.g. testNewAnalyzerCyclicDefinitionCrossModule

alternatives.discard(member)

matches = [m for m in COMMON_MISTAKES.get(member, []) if m in alternatives]

matches.extend(best_matches(member, alternatives, n=3))

if member == "__aiter__" and matches == ["__iter__"]:

matches = [] # Avoid misleading suggestion

if matches:

self.fail(

'{} has no attribute "{}"; maybe {}?{}'.format(

format_type(original_type, self.options),

member,

pretty_seq(matches, "or"),

extra,

),

context,

code=codes.ATTR_DEFINED,

)

failed = True

if not failed:

self.fail(

'{} has no attribute "{}"{}'.format(

format_type(original_type, self.options), member, extra

),

context,

code=codes.ATTR_DEFINED,

)

return codes.ATTR_DEFINED

elif isinstance(original_type, UnionType):

# The checker passes "object" in lieu of "None" for attribute

# checks, so we manually convert it back.

typ_format, orig_type_format = format_type_distinctly(

typ, original_type, options=self.options

)

if typ_format == '"object"' and any(

type(item) == NoneType for item in original_type.items

):

typ_format = '"None"'

self.fail(

'Item {} of {} has no attribute "{}"{}'.format(

typ_format, orig_type_format, member, extra

),

context,

code=codes.UNION_ATTR,

)

return codes.UNION_ATTR

elif isinstance(original_type, TypeVarType):

bound = get_proper_type(original_type.upper_bound)

if isinstance(bound, UnionType):

typ_fmt, bound_fmt = format_type_distinctly(typ, bound, options=self.options)

original_type_fmt = format_type(original_type, self.options)

self.fail(

"Item {} of the upper bound {} of type variable {} has no "

'attribute "{}"{}'.format(

typ_fmt, bound_fmt, original_type_fmt, member, extra

),

context,

code=codes.UNION_ATTR,

)

return codes.UNION_ATTR

else:

self.fail(

'{} has no attribute "{}"{}'.format(

format_type(original_type, self.options), member, extra

),

context,

code=codes.ATTR_DEFINED,

)

return codes.ATTR_DEFINED

return None

def unsupported_operand_types(

self,

op: str,

left_type: Any,

right_type: Any,

context: Context,

*,

code: ErrorCode = codes.OPERATOR,

) -> None:

"""Report unsupported operand types for a binary operation.

Types can be Type objects or strings.

"""

left_str = ""

if isinstance(left_type, str):

left_str = left_type

else:

left_str = format_type(left_type, self.options)

right_str = ""

if isinstance(right_type, str):

right_str = right_type

else:

right_str = format_type(right_type, self.options)

if self.are_type_names_disabled():

msg = f"Unsupported operand types for {op} (likely involving Union)"

else:

msg = f"Unsupported operand types for {op} ({left_str} and {right_str})"

self.fail(msg, context, code=code)

def unsupported_left_operand(self, op: str, typ: Type, context: Context) -> None:

if self.are_type_names_disabled():

msg = f"Unsupported left operand type for {op} (some union)"

else:

msg = f"Unsupported left operand type for {op} ({format_type(typ, self.options)})"

self.fail(msg, context, code=codes.OPERATOR)

def not_callable(self, typ: Type, context: Context) -> Type:

self.fail(message_registry.NOT_CALLABLE.format(format_type(typ, self.options)), context)

return AnyType(TypeOfAny.from_error)

def untyped_function_call(self, callee: CallableType, context: Context) -> Type:

name = callable_name(callee) or "(unknown)"

self.fail(

f"Call to untyped function {name} in typed context",

context,

code=codes.NO_UNTYPED_CALL,

)

return AnyType(TypeOfAny.from_error)

def incompatible_argument(

self,

n: int,

m: int,

callee: CallableType,

arg_type: Type,

arg_kind: ArgKind,

object_type: Type | None,

context: Context,

outer_context: Context,

) -> ErrorCode | None:

"""Report an error about an incompatible argument type.

The argument type is arg_type, argument number is n and the

callee type is 'callee'. If the callee represents a method

that corresponds to an operator, use the corresponding

operator name in the messages.

Return the error code that used for the argument (multiple error

codes are possible).

"""

arg_type = get_proper_type(arg_type)

target = ""

callee_name = callable_name(callee)

if callee_name is not None:

name = callee_name

if callee.bound_args and callee.bound_args[0] is not None:

base = format_type(callee.bound_args[0], self.options)

else:

base = extract_type(name)

for method, op in op_methods_to_symbols.items():

for variant in method, "__r" + method[2:]:

# FIX: do not rely on textual formatting

if name.startswith(f'"{variant}" of'):

if op == "in" or variant != method:

# Reversed order of base/argument.

self.unsupported_operand_types(

op, arg_type, base, context, code=codes.OPERATOR

)

else:

self.unsupported_operand_types(

op, base, arg_type, context, code=codes.OPERATOR

)

return codes.OPERATOR

if name.startswith('"__getitem__" of'):

self.invalid_index_type(

arg_type, callee.arg_types[n - 1], base, context, code=codes.INDEX

)

return codes.INDEX

if name.startswith('"__setitem__" of'):

if n == 1:

self.invalid_index_type(

arg_type, callee.arg_types[n - 1], base, context, code=codes.INDEX

)

return codes.INDEX

else:

arg_type_str, callee_type_str = format_type_distinctly(

arg_type, callee.arg_types[n - 1], options=self.options

)

info = (

f" (expression has type {arg_type_str}, "

f"target has type {callee_type_str})"

)

error_msg = (

message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT.with_additional_msg(info)

)

self.fail(error_msg.value, context, code=error_msg.code)

return error_msg.code

target = f"to {name} "

msg = ""

code = codes.MISC

notes: list[str] = []

if callee_name == "<list>":

name = callee_name[1:-1]

n -= 1

actual_type_str, expected_type_str = format_type_distinctly(

arg_type, callee.arg_types[0], options=self.options

)

msg = "{} item {} has incompatible type {}; expected {}".format(

name.title(), n, actual_type_str, expected_type_str

)

code = codes.LIST_ITEM

elif callee_name == "<dict>" and isinstance(

get_proper_type(callee.arg_types[n - 1]), TupleType

):

name = callee_name[1:-1]

n -= 1

key_type, value_type = cast(TupleType, arg_type).items

expected_key_type, expected_value_type = cast(TupleType, callee.arg_types[n]).items

# don't increase verbosity unless there is need to do so

if is_subtype(key_type, expected_key_type):

key_type_str = format_type(key_type, self.options)

expected_key_type_str = format_type(expected_key_type, self.options)

else:

key_type_str, expected_key_type_str = format_type_distinctly(

key_type, expected_key_type, options=self.options

)

if is_subtype(value_type, expected_value_type):

value_type_str = format_type(value_type, self.options)

expected_value_type_str = format_type(expected_value_type, self.options)

else:

value_type_str, expected_value_type_str = format_type_distinctly(

value_type, expected_value_type, options=self.options

)

msg = "{} entry {} has incompatible type {}: {}; expected {}: {}".format(

name.title(),

n,

key_type_str,

value_type_str,

expected_key_type_str,

expected_value_type_str,

)

code = codes.DICT_ITEM

elif callee_name == "<dict>":

value_type_str, expected_value_type_str = format_type_distinctly(

arg_type, callee.arg_types[n - 1], options=self.options

)

msg = "Unpacked dict entry {} has incompatible type {}; expected {}".format(

n - 1, value_type_str, expected_value_type_str

)

code = codes.DICT_ITEM

elif callee_name == "<list-comprehension>":

actual_type_str, expected_type_str = map(

strip_quotes,

format_type_distinctly(arg_type, callee.arg_types[0], options=self.options),

)

msg = "List comprehension has incompatible type List[{}]; expected List[{}]".format(

actual_type_str, expected_type_str

)

elif callee_name == "<set-comprehension>":

actual_type_str, expected_type_str = map(

strip_quotes,

format_type_distinctly(arg_type, callee.arg_types[0], options=self.options),

)

msg = "Set comprehension has incompatible type Set[{}]; expected Set[{}]".format(

actual_type_str, expected_type_str

)

elif callee_name == "<dictionary-comprehension>":

actual_type_str, expected_type_str = format_type_distinctly(

arg_type, callee.arg_types[n - 1], options=self.options

)

msg = (

"{} expression in dictionary comprehension has incompatible type {}; "

"expected type {}"

).format("Key" if n == 1 else "Value", actual_type_str, expected_type_str)

elif callee_name == "<generator>":

actual_type_str, expected_type_str = format_type_distinctly(

arg_type, callee.arg_types[0], options=self.options

)

msg = "Generator has incompatible item type {}; expected {}".format(

actual_type_str, expected_type_str

)

else:

if self.prefer_simple_messages():

msg = "Argument has incompatible type"

else:

try:

expected_type = callee.arg_types[m - 1]

except IndexError: # Varargs callees

expected_type = callee.arg_types[-1]

arg_type_str, expected_type_str = format_type_distinctly(

arg_type, expected_type, bare=True, options=self.options

)

if arg_kind == ARG_STAR:

arg_type_str = "*" + arg_type_str

elif arg_kind == ARG_STAR2:

arg_type_str = "**" + arg_type_str

# For function calls with keyword arguments, display the argument name rather

# than the number.

arg_label = str(n)

if isinstance(outer_context, CallExpr) and len(outer_context.arg_names) >= n:

arg_name = outer_context.arg_names[n - 1]

if arg_name is not None:

arg_label = f'"{arg_name}"'

if (

arg_kind == ARG_STAR2

and isinstance(arg_type, TypedDictType)

and m <= len(callee.arg_names)

and callee.arg_names[m - 1] is not None

and callee.arg_kinds[m - 1] != ARG_STAR2

):

arg_name = callee.arg_names[m - 1]

assert arg_name is not None

arg_type_str, expected_type_str = format_type_distinctly(

arg_type.items[arg_name], expected_type, bare=True, options=self.options

)

arg_label = f'"{arg_name}"'

if isinstance(outer_context, IndexExpr) and isinstance(

outer_context.index, StrExpr

):

msg = 'Value of "{}" has incompatible type {}; expected {}'.format(

outer_context.index.value,

quote_type_string(arg_type_str),

quote_type_string(expected_type_str),

)

else:

msg = "Argument {} {}has incompatible type {}; expected {}".format(

arg_label,

target,

quote_type_string(arg_type_str),

quote_type_string(expected_type_str),

)

expected_type = get_proper_type(expected_type)

if isinstance(expected_type, UnionType):

expected_types = list(expected_type.items)

else:

expected_types = [expected_type]

for type in get_proper_types(expected_types):

if isinstance(arg_type, Instance) and isinstance(type, Instance):

notes = append_invariance_notes(notes, arg_type, type)

notes = append_numbers_notes(notes, arg_type, type)

object_type = get_proper_type(object_type)

if isinstance(object_type, TypedDictType):

code = codes.TYPEDDICT_ITEM

else:

code = codes.ARG_TYPE

self.fail(msg, context, code=code)

if notes:

for note_msg in notes:

self.note(note_msg, context, code=code)

return code

def incompatible_argument_note(

self,

original_caller_type: ProperType,

callee_type: ProperType,

context: Context,

code: ErrorCode | None,

) -> None:

if self.prefer_simple_messages():

return

if isinstance(

original_caller_type, (Instance, TupleType, TypedDictType, TypeType, CallableType)

):

if isinstance(callee_type, Instance) and callee_type.type.is_protocol:

self.report_protocol_problems(

original_caller_type, callee_type, context, code=code

)

if isinstance(callee_type, UnionType):

for item in callee_type.items:

item = get_proper_type(item)

if isinstance(item, Instance) and item.type.is_protocol:

self.report_protocol_problems(

original_caller_type, item, context, code=code

)

if isinstance(callee_type, CallableType) and isinstance(original_caller_type, Instance):

call = find_member(

"__call__", original_caller_type, original_caller_type, is_operator=True

)

if call:

self.note_call(original_caller_type, call, context, code=code)

self.maybe_note_concatenate_pos_args(original_caller_type, callee_type, context, code)

def maybe_note_concatenate_pos_args(

self,

original_caller_type: ProperType,

callee_type: ProperType,

context: Context,

code: ErrorCode | None = None,

) -> None:

# pos-only vs positional can be confusing, with Concatenate

if (

isinstance(callee_type, CallableType)

and isinstance(original_caller_type, CallableType)

and (original_caller_type.from_concatenate or callee_type.from_concatenate)

):

names: list[str] = []

for c, o in zip(

callee_type.formal_arguments(), original_caller_type.formal_arguments()

):

if None in (c.pos, o.pos):

# non-positional

continue

if c.name != o.name and c.name is None and o.name is not None:

names.append(o.name)

if names:

missing_arguments = '"' + '", "'.join(names) + '"'

self.note(

f'This is likely because "{original_caller_type.name}" has named arguments: '

f"{missing_arguments}. Consider marking them positional-only",

context,

code=code,

)

def invalid_index_type(

self,

index_type: Type,

expected_type: Type,

base_str: str,

context: Context,

*,

code: ErrorCode,

) -> None:

index_str, expected_str = format_type_distinctly(

index_type, expected_type, options=self.options

)

self.fail(

"Invalid index type {} for {}; expected type {}".format(

index_str, base_str, expected_str

),

context,

code=code,

)

def too_few_arguments(

self, callee: CallableType, context: Context, argument_names: Sequence[str | None] | None

) -> None:

if self.prefer_simple_messages():

msg = "Too few arguments"

elif argument_names is not None:

num_positional_args = sum(k is None for k in argument_names)

arguments_left = callee.arg_names[num_positional_args : callee.min_args]

diff = [k for k in arguments_left if k not in argument_names]

if len(diff) == 1:

msg = "Missing positional argument"

else:

msg = "Missing positional arguments"

callee_name = callable_name(callee)

if callee_name is not None and diff and all(d is not None for d in diff):

args = '", "'.join(cast(List[str], diff))

msg += f' "{args}" in call to {callee_name}'

else:

msg = "Too few arguments" + for_function(callee)

else:

msg = "Too few arguments" + for_function(callee)

self.fail(msg, context, code=codes.CALL_ARG)

def missing_named_argument(self, callee: CallableType, context: Context, name: str) -> None:

msg = f'Missing named argument "{name}"' + for_function(callee)

self.fail(msg, context, code=codes.CALL_ARG)

def too_many_arguments(self, callee: CallableType, context: Context) -> None:

if self.prefer_simple_messages():

msg = "Too many arguments"

else:

msg = "Too many arguments" + for_function(callee)

self.fail(msg, context, code=codes.CALL_ARG)

self.maybe_note_about_special_args(callee, context)

def too_many_arguments_from_typed_dict(

self, callee: CallableType, arg_type: TypedDictType, context: Context

) -> None:

# Try to determine the name of the extra argument.

for key in arg_type.items:

if key not in callee.arg_names:

msg = f'Extra argument "{key}" from **args' + for_function(callee)

break

else:

self.too_many_arguments(callee, context)

return

self.fail(msg, context)

def too_many_positional_arguments(self, callee: CallableType, context: Context) -> None:

if self.prefer_simple_messages():

msg = "Too many positional arguments"

else:

msg = "Too many positional arguments" + for_function(callee)

self.fail(msg, context)

self.maybe_note_about_special_args(callee, context)

def maybe_note_about_special_args(self, callee: CallableType, context: Context) -> None:

if self.prefer_simple_messages():

return

# https://github.com/python/mypy/issues/11309

first_arg = callee.def_extras.get("first_arg")

if first_arg and first_arg not in {"self", "cls", "mcs"}:

self.note(