jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/checkstrformat.py

@@ -1,1109 +0,0 @@
-"""
-Format expression type checker.
-
-This file is conceptually part of ExpressionChecker and TypeChecker. Main functionality
-is located in StringFormatterChecker.check_str_format_call() for '{}'.format(), and in
-StringFormatterChecker.check_str_interpolation() for printf-style % interpolation.
-
-Note that although at runtime format strings are parsed using custom parsers,
-here we use a regexp-based approach. This way we 99% match runtime behaviour while keeping
-implementation simple.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import TYPE_CHECKING, Callable, Dict, Final, Match, Pattern, Tuple, Union, cast
-from typing_extensions import TypeAlias as _TypeAlias
-
-import mypy.errorcodes as codes
-from mypy.errors import Errors
-from mypy.nodes import (
-    ARG_NAMED,
-    ARG_POS,
-    ARG_STAR,
-    ARG_STAR2,
-    BytesExpr,
-    CallExpr,
-    Context,
-    DictExpr,
-    Expression,
-    ExpressionStmt,
-    IndexExpr,
-    IntExpr,
-    MemberExpr,
-    MypyFile,
-    NameExpr,
-    Node,
-    StarExpr,
-    StrExpr,
-    TempNode,
-    TupleExpr,
-)
-from mypy.types import (
-    AnyType,
-    Instance,
-    LiteralType,
-    TupleType,
-    Type,
-    TypeOfAny,
-    TypeVarTupleType,
-    TypeVarType,
-    UnionType,
-    UnpackType,
-    find_unpack_in_list,
-    get_proper_type,
-    get_proper_types,
-)
-
-if TYPE_CHECKING:
-    # break import cycle only needed for mypy
-    import mypy.checker
-    import mypy.checkexpr
-
-from mypy import message_registry
-from mypy.maptype import map_instance_to_supertype
-from mypy.messages import MessageBuilder
-from mypy.parse import parse
-from mypy.subtypes import is_subtype
-from mypy.typeops import custom_special_method
-
-FormatStringExpr: _TypeAlias = Union[StrExpr, BytesExpr]
-Checkers: _TypeAlias = Tuple[Callable[[Expression], None], Callable[[Type], bool]]
-MatchMap: _TypeAlias = Dict[Tuple[int, int], Match[str]]  # span -> match
-
-
-def compile_format_re() -> Pattern[str]:
-    """Construct regexp to match format conversion specifiers in % interpolation.
-
-    See https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting
-    The regexp is intentionally a bit wider to report better errors.
-    """
-    key_re = r"(\((?P<key>[^)]*)\))?"  # (optional) parenthesised sequence of characters.
-    flags_re = r"(?P<flags>[#0\-+ ]*)"  # (optional) sequence of flags.
-    width_re = r"(?P<width>[1-9][0-9]*|\*)?"  # (optional) minimum field width (* or numbers).
-    precision_re = r"(?:\.(?P<precision>\*|[0-9]+)?)?"  # (optional) . followed by * of numbers.
-    length_mod_re = r"[hlL]?"  # (optional) length modifier (unused).
-    type_re = r"(?P<type>.)?"  # conversion type.
-    format_re = "%" + key_re + flags_re + width_re + precision_re + length_mod_re + type_re
-    return re.compile(format_re)
-
-
-def compile_new_format_re(custom_spec: bool) -> Pattern[str]:
-    """Construct regexps to match format conversion specifiers in str.format() calls.
-
-    See After https://docs.python.org/3/library/string.html#formatspec for
-    specifications. The regexps are intentionally wider, to report better errors,
-    instead of just not matching.
-    """
-
-    # Field (optional) is an integer/identifier possibly followed by several .attr and [index].
-    field = r"(?P<field>(?P<key>[^.[!:]*)([^:!]+)?)"
-
-    # Conversion (optional) is ! followed by one of letters for forced repr(), str(), or ascii().
-    conversion = r"(?P<conversion>![^:])?"
-
-    # Format specification (optional) follows its own mini-language:
-    if not custom_spec:
-        # Fill and align is valid for all builtin types.
-        fill_align = r"(?P<fill_align>.?[<>=^])?"
-        # Number formatting options are only valid for int, float, complex, and Decimal,
-        # except if only width is given (it is valid for all types).
-        # This contains sign, flags (sign, # and/or 0), width, grouping (_ or ,) and precision.
-        num_spec = r"(?P<flags>[+\- ]?#?0?)(?P<width>\d+)?[_,]?(?P<precision>\.\d+)?"
-        # The last element is type.
-        conv_type = r"(?P<type>.)?"  # only some are supported, but we want to give a better error
-        format_spec = r"(?P<format_spec>:" + fill_align + num_spec + conv_type + r")?"
-    else:
-        # Custom types can define their own form_spec using __format__().
-        format_spec = r"(?P<format_spec>:.*)?"
-
-    return re.compile(field + conversion + format_spec)
-
-
-FORMAT_RE: Final = compile_format_re()
-FORMAT_RE_NEW: Final = compile_new_format_re(False)
-FORMAT_RE_NEW_CUSTOM: Final = compile_new_format_re(True)
-DUMMY_FIELD_NAME: Final = "__dummy_name__"
-
-# Types that require either int or float.
-NUMERIC_TYPES_OLD: Final = {"d", "i", "o", "u", "x", "X", "e", "E", "f", "F", "g", "G"}
-NUMERIC_TYPES_NEW: Final = {"b", "d", "o", "e", "E", "f", "F", "g", "G", "n", "x", "X", "%"}
-
-# These types accept _only_ int.
-REQUIRE_INT_OLD: Final = {"o", "x", "X"}
-REQUIRE_INT_NEW: Final = {"b", "d", "o", "x", "X"}
-
-# These types fall back to SupportsFloat with % (other fall back to SupportsInt)
-FLOAT_TYPES: Final = {"e", "E", "f", "F", "g", "G"}
-
-
-class ConversionSpecifier:
-    def __init__(
-        self, match: Match[str], start_pos: int = -1, non_standard_format_spec: bool = False
-    ) -> None:
-        self.whole_seq = match.group()
-        self.start_pos = start_pos
-
-        m_dict = match.groupdict()
-        self.key = m_dict.get("key")
-
-        # Replace unmatched optional groups with empty matches (for convenience).
-        self.conv_type = m_dict.get("type", "")
-        self.flags = m_dict.get("flags", "")
-        self.width = m_dict.get("width", "")
-        self.precision = m_dict.get("precision", "")
-
-        # Used only for str.format() calls (it may be custom for types with __format__()).
-        self.format_spec = m_dict.get("format_spec")
-        self.non_standard_format_spec = non_standard_format_spec
-        # Used only for str.format() calls.
-        self.conversion = m_dict.get("conversion")
-        # Full formatted expression (i.e. key plus following attributes and/or indexes).
-        # Used only for str.format() calls.
-        self.field = m_dict.get("field")
-
-    def has_key(self) -> bool:
-        return self.key is not None
-
-    def has_star(self) -> bool:
-        return self.width == "*" or self.precision == "*"
-
-
-def parse_conversion_specifiers(format_str: str) -> list[ConversionSpecifier]:
-    """Parse c-printf-style format string into list of conversion specifiers."""
-    specifiers: list[ConversionSpecifier] = []
-    for m in re.finditer(FORMAT_RE, format_str):
-        specifiers.append(ConversionSpecifier(m, start_pos=m.start()))
-    return specifiers
-
-
-def parse_format_value(
-    format_value: str, ctx: Context, msg: MessageBuilder, nested: bool = False
-) -> list[ConversionSpecifier] | None:
-    """Parse format string into list of conversion specifiers.
-
-    The specifiers may be nested (two levels maximum), in this case they are ordered as
-    '{0:{1}}, {2:{3}{4}}'. Return None in case of an error.
-    """
-    top_targets = find_non_escaped_targets(format_value, ctx, msg)
-    if top_targets is None:
-        return None
-
-    result: list[ConversionSpecifier] = []
-    for target, start_pos in top_targets:
-        match = FORMAT_RE_NEW.fullmatch(target)
-        if match:
-            conv_spec = ConversionSpecifier(match, start_pos=start_pos)
-        else:
-            custom_match = FORMAT_RE_NEW_CUSTOM.fullmatch(target)
-            if custom_match:
-                conv_spec = ConversionSpecifier(
-                    custom_match, start_pos=start_pos, non_standard_format_spec=True
-                )
-            else:
-                msg.fail(
-                    "Invalid conversion specifier in format string",
-                    ctx,
-                    code=codes.STRING_FORMATTING,
-                )
-                return None
-
-        if conv_spec.key and ("{" in conv_spec.key or "}" in conv_spec.key):
-            msg.fail("Conversion value must not contain { or }", ctx, code=codes.STRING_FORMATTING)
-            return None
-        result.append(conv_spec)
-
-        # Parse nested conversions that are allowed in format specifier.
-        if (
-            conv_spec.format_spec
-            and conv_spec.non_standard_format_spec
-            and ("{" in conv_spec.format_spec or "}" in conv_spec.format_spec)
-        ):
-            if nested:
-                msg.fail(
-                    "Formatting nesting must be at most two levels deep",
-                    ctx,
-                    code=codes.STRING_FORMATTING,
-                )
-                return None
-            sub_conv_specs = parse_format_value(conv_spec.format_spec, ctx, msg, nested=True)
-            if sub_conv_specs is None:
-                return None
-            result.extend(sub_conv_specs)
-    return result
-
-
-def find_non_escaped_targets(
-    format_value: str, ctx: Context, msg: MessageBuilder
-) -> list[tuple[str, int]] | None:
-    """Return list of raw (un-parsed) format specifiers in format string.
-
-    Format specifiers don't include enclosing braces. We don't use regexp for
-    this because they don't work well with nested/repeated patterns
-    (both greedy and non-greedy), and these are heavily used internally for
-    representation of f-strings.
-
-    Return None in case of an error.
-    """
-    result = []
-    next_spec = ""
-    pos = 0
-    nesting = 0
-    while pos < len(format_value):
-        c = format_value[pos]
-        if not nesting:
-            # Skip any paired '{{' and '}}', enter nesting on '{', report error on '}'.
-            if c == "{":
-                if pos < len(format_value) - 1 and format_value[pos + 1] == "{":
-                    pos += 1
-                else:
-                    nesting = 1
-            if c == "}":
-                if pos < len(format_value) - 1 and format_value[pos + 1] == "}":
-                    pos += 1
-                else:
-                    msg.fail(
-                        "Invalid conversion specifier in format string: unexpected }",
-                        ctx,
-                        code=codes.STRING_FORMATTING,
-                    )
-                    return None
-        else:
-            # Adjust nesting level, then either continue adding chars or move on.
-            if c == "{":
-                nesting += 1
-            if c == "}":
-                nesting -= 1
-            if nesting:
-                next_spec += c
-            else:
-                result.append((next_spec, pos - len(next_spec)))
-                next_spec = ""
-        pos += 1
-    if nesting:
-        msg.fail(
-            "Invalid conversion specifier in format string: unmatched {",
-            ctx,
-            code=codes.STRING_FORMATTING,
-        )
-        return None
-    return result
-
-
-class StringFormatterChecker:
-    """String interpolation/formatter type checker.
-
-    This class works closely together with checker.ExpressionChecker.
-    """
-
-    # 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
-    # Some services are provided by a ExpressionChecker instance.
-    exprchk: mypy.checkexpr.ExpressionChecker
-
-    def __init__(
-        self,
-        exprchk: mypy.checkexpr.ExpressionChecker,
-        chk: mypy.checker.TypeChecker,
-        msg: MessageBuilder,
-    ) -> None:
-        """Construct an expression type checker."""
-        self.chk = chk
-        self.exprchk = exprchk
-        self.msg = msg
-
-    def check_str_format_call(self, call: CallExpr, format_value: str) -> None:
-        """Perform more precise checks for str.format() calls when possible.
-
-        Currently the checks are performed for:
-          * Actual string literals
-          * Literal types with string values
-          * Final names with string values
-
-        The checks that we currently perform:
-          * Check generic validity (e.g. unmatched { or }, and {} in invalid positions)
-          * Check consistency of specifiers' auto-numbering
-          * Verify that replacements can be found for all conversion specifiers,
-            and all arguments were used
-          * Non-standard format specs are only allowed for types with custom __format__
-          * Type check replacements with accessors applied (if any).
-          * Verify that specifier type is known and matches replacement type
-          * Perform special checks for some specifier types:
-            - 'c' requires a single character string
-            - 's' must not accept bytes
-            - non-empty flags are only allowed for numeric types
-        """
-        conv_specs = parse_format_value(format_value, call, self.msg)
-        if conv_specs is None:
-            return
-        if not self.auto_generate_keys(conv_specs, call):
-            return
-        self.check_specs_in_format_call(call, conv_specs, format_value)
-
-    def check_specs_in_format_call(
-        self, call: CallExpr, specs: list[ConversionSpecifier], format_value: str
-    ) -> None:
-        """Perform pairwise checks for conversion specifiers vs their replacements.
-
-        The core logic for format checking is implemented in this method.
-        """
-        assert all(s.key for s in specs), "Keys must be auto-generated first!"
-        replacements = self.find_replacements_in_call(call, [cast(str, s.key) for s in specs])
-        assert len(replacements) == len(specs)
-        for spec, repl in zip(specs, replacements):
-            repl = self.apply_field_accessors(spec, repl, ctx=call)
-            actual_type = repl.type if isinstance(repl, TempNode) else self.chk.lookup_type(repl)
-            assert actual_type is not None
-
-            # Special case custom formatting.
-            if (
-                spec.format_spec
-                and spec.non_standard_format_spec
-                and
-                # Exclude "dynamic" specifiers (i.e. containing nested formatting).
-                not ("{" in spec.format_spec or "}" in spec.format_spec)
-            ):
-                if (
-                    not custom_special_method(actual_type, "__format__", check_all=True)
-                    or spec.conversion
-                ):
-                    # TODO: add support for some custom specs like datetime?
-                    self.msg.fail(
-                        f'Unrecognized format specification "{spec.format_spec[1:]}"',
-                        call,
-                        code=codes.STRING_FORMATTING,
-                    )
-                    continue
-            # Adjust expected and actual types.
-            if not spec.conv_type:
-                expected_type: Type | None = AnyType(TypeOfAny.special_form)
-            else:
-                assert isinstance(call.callee, MemberExpr)
-                if isinstance(call.callee.expr, StrExpr):
-                    format_str = call.callee.expr
-                else:
-                    format_str = StrExpr(format_value)
-                expected_type = self.conversion_type(
-                    spec.conv_type, call, format_str, format_call=True
-                )
-            if spec.conversion is not None:
-                # If the explicit conversion is given, then explicit conversion is called _first_.
-                if spec.conversion[1] not in "rsa":
-                    self.msg.fail(
-                        'Invalid conversion type "{}",'
-                        ' must be one of "r", "s" or "a"'.format(spec.conversion[1]),
-                        call,
-                        code=codes.STRING_FORMATTING,
-                    )
-                actual_type = self.named_type("builtins.str")
-
-            # Perform the checks for given types.
-            if expected_type is None:
-                continue
-
-            a_type = get_proper_type(actual_type)
-            actual_items = (
-                get_proper_types(a_type.items) if isinstance(a_type, UnionType) else [a_type]
-            )
-            for a_type in actual_items:
-                if custom_special_method(a_type, "__format__"):
-                    continue
-                self.check_placeholder_type(a_type, expected_type, call)
-                self.perform_special_format_checks(spec, call, repl, a_type, expected_type)
-
-    def perform_special_format_checks(
-        self,
-        spec: ConversionSpecifier,
-        call: CallExpr,
-        repl: Expression,
-        actual_type: Type,
-        expected_type: Type,
-    ) -> None:
-        # TODO: try refactoring to combine this logic with % formatting.
-        if spec.conv_type == "c":
-            if isinstance(repl, (StrExpr, BytesExpr)) and len(repl.value) != 1:
-                self.msg.requires_int_or_char(call, format_call=True)
-            c_typ = get_proper_type(self.chk.lookup_type(repl))
-            if isinstance(c_typ, Instance) and c_typ.last_known_value:
-                c_typ = c_typ.last_known_value
-            if isinstance(c_typ, LiteralType) and isinstance(c_typ.value, str):
-                if len(c_typ.value) != 1:
-                    self.msg.requires_int_or_char(call, format_call=True)
-        if (not spec.conv_type or spec.conv_type == "s") and not spec.conversion:
-            if has_type_component(actual_type, "builtins.bytes") and not custom_special_method(
-                actual_type, "__str__"
-            ):
-                self.msg.fail(
-                    'If x = b\'abc\' then f"{x}" or "{}".format(x) produces "b\'abc\'", '
-                    'not "abc". If this is desired behavior, use f"{x!r}" or "{!r}".format(x). '
-                    "Otherwise, decode the bytes",
-                    call,
-                    code=codes.STR_BYTES_PY3,
-                )
-        if spec.flags:
-            numeric_types = UnionType(
-                [self.named_type("builtins.int"), self.named_type("builtins.float")]
-            )
-            if (
-                spec.conv_type
-                and spec.conv_type not in NUMERIC_TYPES_NEW
-                or not spec.conv_type
-                and not is_subtype(actual_type, numeric_types)
-                and not custom_special_method(actual_type, "__format__")
-            ):
-                self.msg.fail(
-                    "Numeric flags are only allowed for numeric types",
-                    call,
-                    code=codes.STRING_FORMATTING,
-                )
-
-    def find_replacements_in_call(self, call: CallExpr, keys: list[str]) -> list[Expression]:
-        """Find replacement expression for every specifier in str.format() call.
-
-        In case of an error use TempNode(AnyType).
-        """
-        result: list[Expression] = []
-        used: set[Expression] = set()
-        for key in keys:
-            if key.isdecimal():
-                expr = self.get_expr_by_position(int(key), call)
-                if not expr:
-                    self.msg.fail(
-                        "Cannot find replacement for positional"
-                        " format specifier {}".format(key),
-                        call,
-                        code=codes.STRING_FORMATTING,
-                    )
-                    expr = TempNode(AnyType(TypeOfAny.from_error))
-            else:
-                expr = self.get_expr_by_name(key, call)
-                if not expr:
-                    self.msg.fail(
-                        f'Cannot find replacement for named format specifier "{key}"',
-                        call,
-                        code=codes.STRING_FORMATTING,
-                    )
-                    expr = TempNode(AnyType(TypeOfAny.from_error))
-            result.append(expr)
-            if not isinstance(expr, TempNode):
-                used.add(expr)
-        # Strictly speaking not using all replacements is not a type error, but most likely
-        # a typo in user code, so we show an error like we do for % formatting.
-        total_explicit = len([kind for kind in call.arg_kinds if kind in (ARG_POS, ARG_NAMED)])
-        if len(used) < total_explicit:
-            self.msg.too_many_string_formatting_arguments(call)
-        return result
-
-    def get_expr_by_position(self, pos: int, call: CallExpr) -> Expression | None:
-        """Get positional replacement expression from '{0}, {1}'.format(x, y, ...) call.
-
-        If the type is from *args, return TempNode(<item type>). Return None in case of
-        an error.
-        """
-        pos_args = [arg for arg, kind in zip(call.args, call.arg_kinds) if kind == ARG_POS]
-        if pos < len(pos_args):
-            return pos_args[pos]
-        star_args = [arg for arg, kind in zip(call.args, call.arg_kinds) if kind == ARG_STAR]
-        if not star_args:
-            return None
-
-        # Fall back to *args when present in call.
-        star_arg = star_args[0]
-        varargs_type = get_proper_type(self.chk.lookup_type(star_arg))
-        if not isinstance(varargs_type, Instance) or not varargs_type.type.has_base(
-            "typing.Sequence"
-        ):
-            # Error should be already reported.
-            return TempNode(AnyType(TypeOfAny.special_form))
-        iter_info = self.chk.named_generic_type(
-            "typing.Sequence", [AnyType(TypeOfAny.special_form)]
-        ).type
-        return TempNode(map_instance_to_supertype(varargs_type, iter_info).args[0])
-
-    def get_expr_by_name(self, key: str, call: CallExpr) -> Expression | None:
-        """Get named replacement expression from '{name}'.format(name=...) call.
-
-        If the type is from **kwargs, return TempNode(<item type>). Return None in case of
-        an error.
-        """
-        named_args = [
-            arg
-            for arg, kind, name in zip(call.args, call.arg_kinds, call.arg_names)
-            if kind == ARG_NAMED and name == key
-        ]
-        if named_args:
-            return named_args[0]
-        star_args_2 = [arg for arg, kind in zip(call.args, call.arg_kinds) if kind == ARG_STAR2]
-        if not star_args_2:
-            return None
-        star_arg_2 = star_args_2[0]
-        kwargs_type = get_proper_type(self.chk.lookup_type(star_arg_2))
-        if not isinstance(kwargs_type, Instance) or not kwargs_type.type.has_base(
-            "typing.Mapping"
-        ):
-            # Error should be already reported.
-            return TempNode(AnyType(TypeOfAny.special_form))
-        any_type = AnyType(TypeOfAny.special_form)
-        mapping_info = self.chk.named_generic_type("typing.Mapping", [any_type, any_type]).type
-        return TempNode(map_instance_to_supertype(kwargs_type, mapping_info).args[1])
-
-    def auto_generate_keys(self, all_specs: list[ConversionSpecifier], ctx: Context) -> bool:
-        """Translate '{} {name} {}' to '{0} {name} {1}'.
-
-        Return True if generation was successful, otherwise report an error and return false.
-        """
-        some_defined = any(s.key and s.key.isdecimal() for s in all_specs)
-        all_defined = all(bool(s.key) for s in all_specs)
-        if some_defined and not all_defined:
-            self.msg.fail(
-                "Cannot combine automatic field numbering and manual field specification",
-                ctx,
-                code=codes.STRING_FORMATTING,
-            )
-            return False
-        if all_defined:
-            return True
-        next_index = 0
-        for spec in all_specs:
-            if not spec.key:
-                str_index = str(next_index)
-                spec.key = str_index
-                # Update also the full field (i.e. turn {.x} into {0.x}).
-                if not spec.field:
-                    spec.field = str_index
-                else:
-                    spec.field = str_index + spec.field
-                next_index += 1
-        return True
-
-    def apply_field_accessors(
-        self, spec: ConversionSpecifier, repl: Expression, ctx: Context
-    ) -> Expression:
-        """Transform and validate expr in '{.attr[item]}'.format(expr) into expr.attr['item'].
-
-        If validation fails, return TempNode(AnyType).
-        """
-        assert spec.key, "Keys must be auto-generated first!"
-        if spec.field == spec.key:
-            return repl
-        assert spec.field
-
-        temp_errors = Errors(self.chk.options)
-        dummy = DUMMY_FIELD_NAME + spec.field[len(spec.key) :]
-        temp_ast: Node = parse(
-            dummy, fnam="<format>", module=None, options=self.chk.options, errors=temp_errors
-        )
-        if temp_errors.is_errors():
-            self.msg.fail(
-                f'Syntax error in format specifier "{spec.field}"',
-                ctx,
-                code=codes.STRING_FORMATTING,
-            )
-            return TempNode(AnyType(TypeOfAny.from_error))
-
-        # These asserts are guaranteed by the original regexp.
-        assert isinstance(temp_ast, MypyFile)
-        temp_ast = temp_ast.defs[0]
-        assert isinstance(temp_ast, ExpressionStmt)
-        temp_ast = temp_ast.expr
-        if not self.validate_and_transform_accessors(temp_ast, repl, spec, ctx=ctx):
-            return TempNode(AnyType(TypeOfAny.from_error))
-
-        # Check if there are any other errors (like missing members).
-        # TODO: fix column to point to actual start of the format specifier _within_ string.
-        temp_ast.line = ctx.line
-        temp_ast.column = ctx.column
-        self.exprchk.accept(temp_ast)
-        return temp_ast
-
-    def validate_and_transform_accessors(
-        self,
-        temp_ast: Expression,
-        original_repl: Expression,
-        spec: ConversionSpecifier,
-        ctx: Context,
-    ) -> bool:
-        """Validate and transform (in-place) format field accessors.
-
-        On error, report it and return False. The transformations include replacing the dummy
-        variable with actual replacement expression and translating any name expressions in an
-        index into strings, so that this will work:
-
-            class User(TypedDict):
-                name: str
-                id: int
-            u: User
-            '{[id]:d} -> {[name]}'.format(u)
-        """
-        if not isinstance(temp_ast, (MemberExpr, IndexExpr)):
-            self.msg.fail(
-                "Only index and member expressions are allowed in"
-                ' format field accessors; got "{}"'.format(spec.field),
-                ctx,
-                code=codes.STRING_FORMATTING,
-            )
-            return False
-        if isinstance(temp_ast, MemberExpr):
-            node = temp_ast.expr
-        else:
-            node = temp_ast.base
-            if not isinstance(temp_ast.index, (NameExpr, IntExpr)):
-                assert spec.key, "Call this method only after auto-generating keys!"
-                assert spec.field
-                self.msg.fail(
-                    "Invalid index expression in format field"
-                    ' accessor "{}"'.format(spec.field[len(spec.key) :]),
-                    ctx,
-                    code=codes.STRING_FORMATTING,
-                )
-                return False
-            if isinstance(temp_ast.index, NameExpr):
-                temp_ast.index = StrExpr(temp_ast.index.name)
-        if isinstance(node, NameExpr) and node.name == DUMMY_FIELD_NAME:
-            # Replace it with the actual replacement expression.
-            assert isinstance(temp_ast, (IndexExpr, MemberExpr))  # XXX: this is redundant
-            if isinstance(temp_ast, IndexExpr):
-                temp_ast.base = original_repl
-            else:
-                temp_ast.expr = original_repl
-            return True
-        node.line = ctx.line
-        node.column = ctx.column
-        return self.validate_and_transform_accessors(
-            node, original_repl=original_repl, spec=spec, ctx=ctx
-        )
-
-    # TODO: In Python 3, the bytes formatting has a more restricted set of options
-    #       compared to string formatting.
-    def check_str_interpolation(self, expr: FormatStringExpr, replacements: Expression) -> Type:
-        """Check the types of the 'replacements' in a string interpolation
-        expression: str % replacements.
-        """
-        self.exprchk.accept(expr)
-        specifiers = parse_conversion_specifiers(expr.value)
-        has_mapping_keys = self.analyze_conversion_specifiers(specifiers, expr)
-        if has_mapping_keys is None:
-            pass  # Error was reported
-        elif has_mapping_keys:
-            self.check_mapping_str_interpolation(specifiers, replacements, expr)
-        else:
-            self.check_simple_str_interpolation(specifiers, replacements, expr)
-
-        if isinstance(expr, BytesExpr):
-            return self.named_type("builtins.bytes")
-        elif isinstance(expr, StrExpr):
-            return self.named_type("builtins.str")
-        else:
-            assert False
-
-    def analyze_conversion_specifiers(
-        self, specifiers: list[ConversionSpecifier], context: Context
-    ) -> bool | None:
-        has_star = any(specifier.has_star() for specifier in specifiers)
-        has_key = any(specifier.has_key() for specifier in specifiers)
-        all_have_keys = all(
-            specifier.has_key() or specifier.conv_type == "%" for specifier in specifiers
-        )
-
-        if has_key and has_star:
-            self.msg.string_interpolation_with_star_and_key(context)
-            return None
-        if has_key and not all_have_keys:
-            self.msg.string_interpolation_mixing_key_and_non_keys(context)
-            return None
-        return has_key
-
-    def check_simple_str_interpolation(
-        self,
-        specifiers: list[ConversionSpecifier],
-        replacements: Expression,
-        expr: FormatStringExpr,
-    ) -> None:
-        """Check % string interpolation with positional specifiers '%s, %d' % ('yes, 42')."""
-        checkers = self.build_replacement_checkers(specifiers, replacements, expr)
-        if checkers is None:
-            return
-
-        rhs_type = get_proper_type(self.accept(replacements))
-        rep_types: list[Type] = []
-        if isinstance(rhs_type, TupleType):
-            rep_types = rhs_type.items
-            unpack_index = find_unpack_in_list(rep_types)
-            if unpack_index is not None:
-                # TODO: we should probably warn about potentially short tuple.
-                # However, without special-casing for tuple(f(i) for in other_tuple)
-                # this causes false positive on mypy self-check in report.py.
-                extras = max(0, len(checkers) - len(rep_types) + 1)
-                unpacked = rep_types[unpack_index]
-                assert isinstance(unpacked, UnpackType)
-                unpacked = get_proper_type(unpacked.type)
-                if isinstance(unpacked, TypeVarTupleType):
-                    unpacked = get_proper_type(unpacked.upper_bound)
-                assert (
-                    isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
-                )
-                unpack_items = [unpacked.args[0]] * extras
-                rep_types = rep_types[:unpack_index] + unpack_items + rep_types[unpack_index + 1 :]
-        elif isinstance(rhs_type, AnyType):
-            return
-        elif isinstance(rhs_type, Instance) and rhs_type.type.fullname == "builtins.tuple":
-            # Assume that an arbitrary-length tuple has the right number of items.
-            rep_types = [rhs_type.args[0]] * len(checkers)
-        elif isinstance(rhs_type, UnionType):
-            for typ in rhs_type.relevant_items():
-                temp_node = TempNode(typ)
-                temp_node.line = replacements.line
-                self.check_simple_str_interpolation(specifiers, temp_node, expr)
-            return
-        else:
-            rep_types = [rhs_type]
-
-        if len(checkers) > len(rep_types):
-            # Only check the fix-length Tuple type. Other Iterable types would skip.
-            if is_subtype(rhs_type, self.chk.named_type("typing.Iterable")) and not isinstance(
-                rhs_type, TupleType
-            ):
-                return
-            else:
-                self.msg.too_few_string_formatting_arguments(replacements)
-        elif len(checkers) < len(rep_types):
-            self.msg.too_many_string_formatting_arguments(replacements)
-        else:
-            if len(checkers) == 1:
-                check_node, check_type = checkers[0]
-                if isinstance(rhs_type, TupleType) and len(rhs_type.items) == 1:
-                    check_type(rhs_type.items[0])
-                else:
-                    check_node(replacements)
-            elif isinstance(replacements, TupleExpr) and not any(
-                isinstance(item, StarExpr) for item in replacements.items
-            ):
-                for checks, rep_node in zip(checkers, replacements.items):
-                    check_node, check_type = checks
-                    check_node(rep_node)
-            else:
-                for checks, rep_type in zip(checkers, rep_types):
-                    check_node, check_type = checks
-                    check_type(rep_type)
-
-    def check_mapping_str_interpolation(
-        self,
-        specifiers: list[ConversionSpecifier],
-        replacements: Expression,
-        expr: FormatStringExpr,
-    ) -> None:
-        """Check % string interpolation with names specifiers '%(name)s' % {'name': 'John'}."""
-        if isinstance(replacements, DictExpr) and all(
-            isinstance(k, (StrExpr, BytesExpr)) for k, v in replacements.items
-        ):
-            mapping: dict[str, Type] = {}
-            for k, v in replacements.items:
-                if isinstance(expr, BytesExpr):
-                    # Special case: for bytes formatting keys must be bytes.
-                    if not isinstance(k, BytesExpr):
-                        self.msg.fail(
-                            "Dictionary keys in bytes formatting must be bytes, not strings",
-                            expr,
-                            code=codes.STRING_FORMATTING,
-                        )
-                key_str = cast(FormatStringExpr, k).value
-                mapping[key_str] = self.accept(v)
-
-            for specifier in specifiers:
-                if specifier.conv_type == "%":
-                    # %% is allowed in mappings, no checking is required
-                    continue
-                assert specifier.key is not None
-                if specifier.key not in mapping:
-                    self.msg.key_not_in_mapping(specifier.key, replacements)
-                    return
-                rep_type = mapping[specifier.key]
-                assert specifier.conv_type is not None
-                expected_type = self.conversion_type(specifier.conv_type, replacements, expr)
-                if expected_type is None:
-                    return
-                self.chk.check_subtype(
-                    rep_type,
-                    expected_type,
-                    replacements,
-                    message_registry.INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION,
-                    "expression has type",
-                    f"placeholder with key '{specifier.key}' has type",
-                    code=codes.STRING_FORMATTING,
-                )
-                if specifier.conv_type == "s":
-                    self.check_s_special_cases(expr, rep_type, expr)
-        else:
-            rep_type = self.accept(replacements)
-            dict_type = self.build_dict_type(expr)
-            self.chk.check_subtype(
-                rep_type,
-                dict_type,
-                replacements,
-                message_registry.FORMAT_REQUIRES_MAPPING,
-                "expression has type",
-                "expected type for mapping is",
-                code=codes.STRING_FORMATTING,
-            )
-
-    def build_dict_type(self, expr: FormatStringExpr) -> Type:
-        """Build expected mapping type for right operand in % formatting."""
-        any_type = AnyType(TypeOfAny.special_form)
-        if isinstance(expr, BytesExpr):
-            bytes_type = self.chk.named_generic_type("builtins.bytes", [])
-            return self.chk.named_generic_type(
-                "_typeshed.SupportsKeysAndGetItem", [bytes_type, any_type]
-            )
-        elif isinstance(expr, StrExpr):
-            str_type = self.chk.named_generic_type("builtins.str", [])
-            return self.chk.named_generic_type(
-                "_typeshed.SupportsKeysAndGetItem", [str_type, any_type]
-            )
-        else:
-            assert False, "Unreachable"
-
-    def build_replacement_checkers(
-        self, specifiers: list[ConversionSpecifier], context: Context, expr: FormatStringExpr
-    ) -> list[Checkers] | None:
-        checkers: list[Checkers] = []
-        for specifier in specifiers:
-            checker = self.replacement_checkers(specifier, context, expr)
-            if checker is None:
-                return None
-            checkers.extend(checker)
-        return checkers
-
-    def replacement_checkers(
-        self, specifier: ConversionSpecifier, context: Context, expr: FormatStringExpr
-    ) -> list[Checkers] | None:
-        """Returns a list of tuples of two functions that check whether a replacement is
-        of the right type for the specifier. The first function takes a node and checks
-        its type in the right type context. The second function just checks a type.
-        """
-        checkers: list[Checkers] = []
-
-        if specifier.width == "*":
-            checkers.append(self.checkers_for_star(context))
-        if specifier.precision == "*":
-            checkers.append(self.checkers_for_star(context))
-
-        if specifier.conv_type == "c":
-            c = self.checkers_for_c_type(specifier.conv_type, context, expr)
-            if c is None:
-                return None
-            checkers.append(c)
-        elif specifier.conv_type is not None and specifier.conv_type != "%":
-            c = self.checkers_for_regular_type(specifier.conv_type, context, expr)
-            if c is None:
-                return None
-            checkers.append(c)
-        return checkers
-
-    def checkers_for_star(self, context: Context) -> Checkers:
-        """Returns a tuple of check functions that check whether, respectively,
-        a node or a type is compatible with a star in a conversion specifier.
-        """
-        expected = self.named_type("builtins.int")
-
-        def check_type(type: Type) -> bool:
-            expected = self.named_type("builtins.int")
-            return self.chk.check_subtype(
-                type, expected, context, "* wants int", code=codes.STRING_FORMATTING
-            )
-
-        def check_expr(expr: Expression) -> None:
-            type = self.accept(expr, expected)
-            check_type(type)
-
-        return check_expr, check_type
-
-    def check_placeholder_type(self, typ: Type, expected_type: Type, context: Context) -> bool:
-        return self.chk.check_subtype(
-            typ,
-            expected_type,
-            context,
-            message_registry.INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION,
-            "expression has type",
-            "placeholder has type",
-            code=codes.STRING_FORMATTING,
-        )
-
-    def checkers_for_regular_type(
-        self, conv_type: str, context: Context, expr: FormatStringExpr
-    ) -> Checkers | None:
-        """Returns a tuple of check functions that check whether, respectively,
-        a node or a type is compatible with 'type'. Return None in case of an error.
-        """
-        expected_type = self.conversion_type(conv_type, context, expr)
-        if expected_type is None:
-            return None
-
-        def check_type(typ: Type) -> bool:
-            assert expected_type is not None
-            ret = self.check_placeholder_type(typ, expected_type, context)
-            if ret and conv_type == "s":
-                ret = self.check_s_special_cases(expr, typ, context)
-            return ret
-
-        def check_expr(expr: Expression) -> None:
-            type = self.accept(expr, expected_type)
-            check_type(type)
-
-        return check_expr, check_type
-
-    def check_s_special_cases(self, expr: FormatStringExpr, typ: Type, context: Context) -> bool:
-        """Additional special cases for %s in bytes vs string context."""
-        if isinstance(expr, StrExpr):
-            # Couple special cases for string formatting.
-            if has_type_component(typ, "builtins.bytes"):
-                self.msg.fail(
-                    'If x = b\'abc\' then "%s" % x produces "b\'abc\'", not "abc". '
-                    'If this is desired behavior use "%r" % x. Otherwise, decode the bytes',
-                    context,
-                    code=codes.STR_BYTES_PY3,
-                )
-                return False
-        if isinstance(expr, BytesExpr):
-            # A special case for bytes formatting: b'%s' actually requires bytes on Python 3.
-            if has_type_component(typ, "builtins.str"):
-                self.msg.fail(
-                    "On Python 3 b'%s' requires bytes, not string",
-                    context,
-                    code=codes.STRING_FORMATTING,
-                )
-                return False
-        return True
-
-    def checkers_for_c_type(
-        self, type: str, context: Context, format_expr: FormatStringExpr
-    ) -> Checkers | None:
-        """Returns a tuple of check functions that check whether, respectively,
-        a node or a type is compatible with 'type' that is a character type.
-        """
-        expected_type = self.conversion_type(type, context, format_expr)
-        if expected_type is None:
-            return None
-
-        def check_type(type: Type) -> bool:
-            assert expected_type is not None
-            if isinstance(format_expr, BytesExpr):
-                err_msg = '"%c" requires an integer in range(256) or a single byte'
-            else:
-                err_msg = '"%c" requires int or char'
-            return self.chk.check_subtype(
-                type,
-                expected_type,
-                context,
-                err_msg,
-                "expression has type",
-                code=codes.STRING_FORMATTING,
-            )
-
-        def check_expr(expr: Expression) -> None:
-            """int, or str with length 1"""
-            type = self.accept(expr, expected_type)
-            # We need further check with expr to make sure that
-            # it has exact one char or one single byte.
-            if check_type(type):
-                # Python 3 doesn't support b'%c' % str
-                if (
-                    isinstance(format_expr, BytesExpr)
-                    and isinstance(expr, BytesExpr)
-                    and len(expr.value) != 1
-                ):
-                    self.msg.requires_int_or_single_byte(context)
-                elif isinstance(expr, (StrExpr, BytesExpr)) and len(expr.value) != 1:
-                    self.msg.requires_int_or_char(context)
-
-        return check_expr, check_type
-
-    def conversion_type(
-        self, p: str, context: Context, expr: FormatStringExpr, format_call: bool = False
-    ) -> Type | None:
-        """Return the type that is accepted for a string interpolation conversion specifier type.
-
-        Note that both Python's float (e.g. %f) and integer (e.g. %d)
-        specifier types accept both float and integers.
-
-        The 'format_call' argument indicates whether this type came from % interpolation or from
-        a str.format() call, the meaning of few formatting types are different.
-        """
-        NUMERIC_TYPES = NUMERIC_TYPES_NEW if format_call else NUMERIC_TYPES_OLD
-        INT_TYPES = REQUIRE_INT_NEW if format_call else REQUIRE_INT_OLD
-        if p == "b" and not format_call:
-            if not isinstance(expr, BytesExpr):
-                self.msg.fail(
-                    'Format character "b" is only supported on bytes patterns',
-                    context,
-                    code=codes.STRING_FORMATTING,
-                )
-                return None
-            return self.named_type("builtins.bytes")
-        elif p == "a":
-            # TODO: return type object?
-            return AnyType(TypeOfAny.special_form)
-        elif p in ["s", "r"]:
-            return AnyType(TypeOfAny.special_form)
-        elif p in NUMERIC_TYPES:
-            if p in INT_TYPES:
-                numeric_types = [self.named_type("builtins.int")]
-            else:
-                numeric_types = [
-                    self.named_type("builtins.int"),
-                    self.named_type("builtins.float"),
-                ]
-                if not format_call:
-                    if p in FLOAT_TYPES:
-                        numeric_types.append(self.named_type("typing.SupportsFloat"))
-                    else:
-                        numeric_types.append(self.named_type("typing.SupportsInt"))
-            return UnionType.make_union(numeric_types)
-        elif p in ["c"]:
-            if isinstance(expr, BytesExpr):
-                return UnionType(
-                    [self.named_type("builtins.int"), self.named_type("builtins.bytes")]
-                )
-            else:
-                return UnionType(
-                    [self.named_type("builtins.int"), self.named_type("builtins.str")]
-                )
-        else:
-            self.msg.unsupported_placeholder(p, context)
-            return None
-
-    #
-    # Helpers
-    #
-
-    def named_type(self, name: str) -> Instance:
-        """Return an instance type with type given by the name and no type
-        arguments. Alias for TypeChecker.named_type.
-        """
-        return self.chk.named_type(name)
-
-    def accept(self, expr: Expression, context: Type | None = None) -> Type:
-        """Type check a node. Alias for TypeChecker.accept."""
-        return self.chk.expr_checker.accept(expr, context)
-
-
-def has_type_component(typ: Type, fullname: str) -> bool:
-    """Is this a specific instance type, or a union that contains it?
-
-    We use this ad-hoc function instead of a proper visitor or subtype check
-    because some str vs bytes errors are strictly speaking not runtime errors,
-    but rather highly counter-intuitive behavior. This is similar to what is used for
-    --strict-equality.
-    """
-    typ = get_proper_type(typ)
-    if isinstance(typ, Instance):
-        return typ.type.has_base(fullname)
-    elif isinstance(typ, TypeVarType):
-        return has_type_component(typ.upper_bound, fullname) or any(
-            has_type_component(v, fullname) for v in typ.values
-        )
-    elif isinstance(typ, UnionType):
-        return any(has_type_component(t, fullname) for t in typ.relevant_items())
-    return False