bugbear.py

from __future__ import annotations

import ast
import builtins
import io
import itertools
import logging
import math
import re
import symtable
import sys
import tokenize
import warnings
from collections import Counter, defaultdict
from contextlib import suppress
from functools import lru_cache
from keyword import iskeyword
from typing import (
    Any,
    Callable,
    Dict,
    Iterable,
    Iterator,
    List,
    NamedTuple,
    Protocol,
    Sequence,
    cast,
)

import attr  # type: ignore
import pycodestyle  # type: ignore
from flake8.exceptions import PluginExecutionFailed

__version__ = "26.9.30"

LOG = logging.getLogger("flake8.bugbear")
CONTEXTFUL_NODES = (
    ast.Module,
    ast.ClassDef,
    ast.AsyncFunctionDef,
    ast.FunctionDef,
    ast.Lambda,
    ast.ListComp,
    ast.SetComp,
    ast.DictComp,
    ast.GeneratorExp,
)
FUNCTION_NODES = (ast.AsyncFunctionDef, ast.FunctionDef, ast.Lambda)
EAGER_COMPREHENSION_NODES = (ast.ListComp, ast.SetComp, ast.DictComp)
FUNCTIONS_WITHOUT_SIDE_EFFECTS = (
    "all",
    "any",
    "dict",
    "frozenset",
    "isinstance",
    "issubclass",
    "len",
    "max",
    "min",
    "repr",
    "set",
    "sorted",
    "str",
    "tuple",
)
# Arithmetic operators whose result is all a statement like `a * b` produces.
# Shifts, bitwise operators and `@` are left out: libraries overload them for
# their side effects, such as Airflow's `task1 >> task2`.
B018_ARITHMETIC_OPERATORS = (
    ast.Add,
    ast.Sub,
    ast.Mult,
    ast.Div,
    ast.FloorDiv,
    ast.Mod,
    ast.Pow,
)
# Builtins that return a lazy iterator, so `map(print, items)` as a statement
# never calls `print`. `iter` is left out: `iter(x)` calls `x.__iter__()` right
# away, which is what a bare `iter(x)` is usually for.
B018_LAZY_FUNCTIONS = ("enumerate", "filter", "map", "reversed", "zip")
B018_RAISING_BLOCKS: tuple[type[ast.stmt], ...] = (ast.Try, ast.With, ast.AsyncWith)
if sys.version_info >= (3, 11):
    B018_RAISING_BLOCKS += (ast.TryStar,)
B908_pytest_functions = {"raises", "warns"}
B908_unittest_methods = {
    "assertRaises",
    "assertRaisesRegex",
    "assertRaisesRegexp",
    "assertWarns",
    "assertWarnsRegex",
}

B902_default_decorators = {"classmethod"}


class Context(NamedTuple):
    node: ast.AST
    stack: list[ast.AST]


def _defines_a_generator(function_node: ast.FunctionDef) -> bool:
    """Does this function's own body contain a yield? (nested ones do not count)"""
    stack = list(function_node.body)
    while stack:
        node = stack.pop()
        if isinstance(node, (ast.Yield, ast.YieldFrom)):
            return True
        if isinstance(node, FUNCTION_NODES):
            continue
        stack.extend(ast.iter_child_nodes(node))
    return False


def _is_rebound(
    name: str, names_used: dict[str, list[ast.Name]], parents: dict[int, ast.AST]
) -> bool:
    """Is `name` bound anywhere in this scope other than by the definition?"""
    return any(
        isinstance(reference.ctx, (ast.Store, ast.Del))
        for reference in names_used.get(name, ())
    )


@attr.s(unsafe_hash=False)
class BugBearChecker:
    name = "flake8-bugbear"
    version = __version__

    tree = attr.ib(default=None)
    filename = attr.ib(default="(none)")
    lines = attr.ib(default=None)
    max_line_length = attr.ib(default=79)
    visitor = attr.ib(init=False, factory=lambda: BugBearVisitor)
    options = attr.ib(default=None)

    def run(self) -> Iterable[tuple[int, int, str, type]]:
        if not self.tree or not self.lines:
            self.load_file()

        if self.options and hasattr(self.options, "extend_immutable_calls"):
            b008_b039_extend_immutable_calls = set(self.options.extend_immutable_calls)
        else:
            b008_b039_extend_immutable_calls = set()

        b902_classmethod_decorators: set[str] = B902_default_decorators
        if self.options and hasattr(self.options, "classmethod_decorators"):
            b902_classmethod_decorators = set(self.options.classmethod_decorators)

        visitor = self.visitor(
            filename=self.filename,
            lines=self.lines,
            b008_b039_extend_immutable_calls=b008_b039_extend_immutable_calls,
            b902_classmethod_decorators=b902_classmethod_decorators,
        )
        try:
            visitor.visit(self.tree)
        except RecursionError as exc:
            raise PluginExecutionFailed(self.filename, self.name, exc) from exc
        for e in itertools.chain(visitor.errors, self.gen_line_based_checks()):
            if self.should_warn(e.message[:4]):
                yield self.adapt_error(e)

    def _doc_line_numbers(self) -> set[int]:
        """Return the line numbers that pycodestyle's W505 treats as documentation.

        These are lines holding only a comment and lines of a string or bytes literal
        that is a statement on its own (docstrings), but not trailing comments or
        strings that are part of code, even code after a `;` on the same line.
        """
        doc_lines: set[int] = set()
        for node in ast.walk(self.tree):
            if (
                isinstance(node, ast.Expr)
                and isinstance(node.value, ast.Constant)
                and isinstance(node.value.value, (str, bytes))
                and not self.lines[node.lineno - 1][: node.col_offset].strip()
                and self._only_comment_after(node)
            ):
                doc_lines.update(range(node.lineno, (node.end_lineno or 0) + 1))
        with suppress(tokenize.TokenError, SyntaxError):
            for token in tokenize.generate_tokens(
                io.StringIO("".join(self.lines)).readline
            ):
                if (
                    token.type == tokenize.COMMENT
                    and not token.line[: token.start[1]].strip()
                ):
                    doc_lines.add(token.start[0])
        return doc_lines

    def _only_comment_after(self, node: ast.expr) -> bool:
        """Whether nothing but a comment follows `node` on its last line."""
        line = self.lines[(node.end_lineno or node.lineno) - 1].encode()
        rest = line[node.end_col_offset or 0 :].decode(errors="replace").strip()
        return not rest or rest.startswith("#")

    def gen_line_based_checks(self) -> Iterator["error"]:
        """gen_line_based_checks() -> (error, error, error, ...)

        The following simple checks are based on the raw lines, not the AST.
        """
        # Only when `max-doc-length` is configured are docstring and comment lines
        # measured against it instead of `max-line-length`.
        max_doc_length: int | None = getattr(self.options, "max_doc_length", None)
        doc_lines = self._doc_line_numbers() if max_doc_length is not None else set()
        noqa_type_ignore_regex = re.compile(
            r"#\s*(noqa|type:\s*ignore|pragma:)[^#\r\n]*$"
        )
        for lineno, line in enumerate(self.lines, start=1):
            # Special case: ignore long shebang (following pycodestyle).
            if lineno == 1 and line.startswith("#!"):
                continue

            # At first, removing noqa and type: ignore trailing comments"
            no_comment_line = noqa_type_ignore_regex.sub("", line)
            if no_comment_line != line:
                no_comment_line = noqa_type_ignore_regex.sub("", no_comment_line)

            max_length = self.max_line_length
            if max_doc_length is not None and lineno in doc_lines:
                max_length = max_doc_length
            length = len(no_comment_line) - 1
            if length > 1.1 * max_length and no_comment_line.strip():
                # Special case long URLS and paths to follow pycodestyle.
                # Would use the `pycodestyle.maximum_line_length` directly but
                # need to supply it arguments that are not available so chose
                # to replicate instead.
                chunks = no_comment_line.split()

                is_line_comment_url_path = len(chunks) == 2 and chunks[0] == "#"

                just_long_url_path = len(chunks) == 1

                num_leading_whitespaces = len(no_comment_line) - len(chunks[-1])
                too_many_leading_white_spaces = (
                    num_leading_whitespaces >= max_length - 7
                )

                skip = is_line_comment_url_path or just_long_url_path
                if skip and not too_many_leading_white_spaces:
                    continue

                yield error_codes["B950"](lineno, length, vars=(length, max_length))

    @classmethod
    def adapt_error(cls, e: error) -> tuple[int, int, str, type]:
        """Adapts the extended error namedtuple to be compatible with Flake8."""
        return e._replace(message=e.message.format(*e.vars))[:4]

    def load_file(self) -> None:
        """Loads the file in a way that auto-detects source encoding and deals
        with broken terminal encodings for stdin.

        Stolen from flake8_import_order because it's good.
        """

        if self.filename in ("stdin", "-", None):
            self.filename = "stdin"
            self.lines = pycodestyle.stdin_get_value().splitlines(True)
        else:
            self.lines = pycodestyle.readlines(self.filename)

        if not self.tree:
            self.tree = ast.parse("".join(self.lines))

    @staticmethod
    def add_options(optmanager: Any) -> None:
        """Informs flake8 to ignore B9xx by default."""
        optmanager.extend_default_ignore(disabled_by_default)
        optmanager.add_option(
            "--extend-immutable-calls",
            comma_separated_list=True,
            parse_from_config=True,
            default=[],
            help="Skip B008 test for additional immutable calls.",
        )
        # you cannot register the same option in two different plugins, so we
        # only register --classmethod-decorators if pep8-naming is not installed
        if "pep8ext_naming" not in sys.modules.keys():
            optmanager.add_option(
                "--classmethod-decorators",
                comma_separated_list=True,
                parse_from_config=True,
                default=B902_default_decorators,
                help=(
                    "List of method decorators that should be treated as classmethods"
                    " by B902"
                ),
            )

    @lru_cache  # noqa: B019
    def should_warn(self, code: str) -> bool:
        """Returns `True` if Bugbear should emit a particular warning.

        flake8 overrides default ignores when the user specifies
        `ignore = ` in configuration.  This is problematic because it means
        specifying anything in `ignore = ` implicitly enables all optional
        warnings.  This function is a workaround for this behavior.

        As documented in the README, the user is expected to explicitly select
        the warnings.

        NOTE: This method is deprecated and will be removed in a future release. It is
        recommended to use `extend-ignore` and `extend-select` in your flake8
        configuration to avoid implicitly altering selected and ignored codes.
        """
        if code[:2] != "B9":
            # Normal warnings are safe for emission.
            return True

        if self.options is None:
            # Without options configured, Bugbear will emit B9 but flake8 will ignore
            LOG.info(
                "Options not provided to Bugbear, optional warning %s selected.", code
            )
            return True

        for i in range(2, len(code) + 1):
            if self.options.select and code[:i] in self.options.select:
                return True

            # flake8 >=4.0: Also check for codes in extend_select
            if (
                hasattr(self.options, "extend_select")
                and self.options.extend_select
                and code[:i] in self.options.extend_select
            ):
                return True

        LOG.info(
            "Optional warning %s not present in selected warnings: %r. Not "
            "firing it at all.",
            code,
            self.options.select,
        )
        return False


def _is_identifier(arg) -> bool:
    # Return True if arg is a valid identifier, per
    # https://docs.python.org/2/reference/lexical_analysis.html#identifiers

    if not isinstance(arg, ast.Constant) or not isinstance(arg.value, str):
        return False

    return re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", arg.value) is not None


def _flatten_excepthandler(node: ast.expr | None) -> Iterator[ast.expr | None]:
    if not isinstance(node, ast.Tuple):
        yield node
        return
    expr_list = node.elts.copy()
    while len(expr_list):
        expr = expr_list.pop(0)
        if isinstance(expr, ast.Starred) and isinstance(
            expr.value, (ast.List, ast.Tuple)
        ):
            expr_list.extend(expr.value.elts)
            continue

        yield expr


def _check_redundant_excepthandlers(
    names: Sequence[str], node: ast.ExceptHandler, in_trystar: str
):
    # See if any of the given exception names could be removed, e.g. from:
    #    (MyError, MyError)  # duplicate names
    #    (MyError, BaseException)  # everything derives from the Base
    #    (Exception, TypeError)  # builtins where one subclasses another
    #    (IOError, OSError)  # IOError is an alias of OSError since Python3.3
    # but note that other cases are impractical to handle from the AST.
    # We expect this is mostly useful for users who do not have the
    # builtin exception hierarchy memorised, and include a 'shadowed'
    # subtype without realising that it's redundant.
    good = sorted(set(names), key=names.index)
    if "BaseException" in good:
        good = ["BaseException"]
    # Remove redundant exceptions that the automatic system either handles
    # poorly (usually aliases) or can't be checked (e.g. it's not an
    # built-in exception).
    for primary, equivalents in B014_REDUNDANT_EXCEPTIONS.items():
        if primary in good:
            good = [g for g in good if g not in equivalents]

    for name, other in itertools.permutations(tuple(good), 2):
        if _typesafe_issubclass(
            getattr(builtins, name, type), getattr(builtins, other, ())
        ):
            if name in good:
                good.remove(name)
    if good != names:
        desc = good[0] if len(good) == 1 else "({})".format(", ".join(good))
        as_ = " as " + node.name if node.name is not None else ""
        return error_codes["B014"](
            node.lineno,
            node.col_offset,
            vars=(", ".join(names), as_, desc, in_trystar),
        )
    return None


def _to_name_str(node: ast.expr | None) -> str | None:
    # Turn Name and Attribute nodes to strings, e.g "ValueError" or
    # "pkg.mod.error", handling any depth of attribute accesses.
    # Return None for unrecognized nodes.
    if isinstance(node, ast.Name):
        return node.id
    if isinstance(node, ast.Call):
        return _to_name_str(node.func)
    elif isinstance(node, ast.Attribute):
        inner = _to_name_str(node.value)
        if inner is None:
            return None
        return f"{inner}.{node.attr}"
    else:
        return None


def _truthy_constant_kind(node: ast.expr) -> str | None:
    """Describe a constant that is always truthy, like `"x"` or `-1`."""
    if (
        isinstance(node, ast.UnaryOp)
        and isinstance(node.op, (ast.UAdd, ast.USub))
        and isinstance(node.operand, ast.Constant)
        and not isinstance(node.operand.value, (str, bytes))
    ):
        node = node.operand
    if not isinstance(node, ast.Constant) or not node.value:
        return None
    if isinstance(node.value, str):
        return "non-empty string"
    if isinstance(node.value, bytes):
        return "non-empty bytes"
    # `assert False` is B011, and `assert True` is left alone on purpose
    if isinstance(node.value, (int, float, complex)) and not isinstance(
        node.value, bool
    ):
        return "non-zero number"
    return None


def names_from_assignments(assign_target: ast.expr) -> Iterator[str]:
    if isinstance(assign_target, ast.Name):
        yield assign_target.id
    elif isinstance(assign_target, ast.Starred):
        yield from names_from_assignments(assign_target.value)
    elif isinstance(assign_target, (ast.List, ast.Tuple)):
        for child in assign_target.elts:
            yield from names_from_assignments(child)


def _nested_tables(table: Any, deep: bool) -> Iterator[Any]:
    """Tables of the functions nested in `table`, looking through class bodies and
    the annotation and type parameter scopes of Python 3.12+."""
    for child in table.get_children() if table else ():
        is_function = isinstance(child, symtable.Function)
        if is_function:
            yield child
        if deep or not is_function:
            yield from _nested_tables(child, deep)


def children_in_scope(node: ast.AST) -> Iterator[ast.AST]:
    yield node
    if not isinstance(node, FUNCTION_NODES):
        for child in ast.iter_child_nodes(node):
            yield from children_in_scope(child)


def _typesafe_issubclass(cls: type, class_or_tuple: type | tuple[type, ...]) -> bool:
    try:
        return issubclass(cls, class_or_tuple)
    except TypeError:
        # User code specifies a type that is not a type in our current run. Might be
        # their error, might be a difference in our environments. We don't know so we
        # ignore this
        return False


class ExceptBaseExceptionVisitor(ast.NodeVisitor):
    def __init__(self, except_node: ast.ExceptHandler) -> None:
        super().__init__()
        self.root = except_node
        self._re_raised = False

    def re_raised(self) -> bool:
        self.visit(self.root)
        return self._re_raised

    def visit_Raise(self, node: ast.Raise) -> None:
        """If we find a corresponding `raise` or `raise e` where e was from
        `except BaseException as e:` then we mark re_raised as True and can
        stop scanning."""
        if node.exc is None or (
            isinstance(node.exc, ast.Name) and node.exc.id == self.root.name
        ):
            self._re_raised = True
            return
        return super().generic_visit(node)

    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
        if node is not self.root:
            return  # entered a nested except - stop searching
        return super().generic_visit(node)


@attr.define
class B040CaughtException:
    name: str
    has_note: bool


class B041UnhandledKeyType:
    """
    A dictionary key of a type that we do not check for duplicates.
    """


@attr.define(frozen=True)
class B041VariableKeyType:
    name: str


class AstPositionNode(Protocol):
    lineno: int
    col_offset: int


def _b906_is_libcst_module(module: str | None, level: int) -> bool:
    return (
        level == 0
        and module is not None
        and (module == "libcst" or module.startswith("libcst."))
    )


def _b906_import_binding(alias: ast.alias) -> tuple[str, str | None]:
    """``(bound name, libcst kind)`` for an ``import`` alias; kind is
    ``"module"`` for ``import libcst[.sub] [as x]``, else ``None``."""
    bound = alias.asname or alias.name.partition(".")[0]
    kind = "module" if _b906_is_libcst_module(alias.name, 0) else None
    return bound, kind


def _b906_importfrom_binding(
    node: ast.ImportFrom, alias: ast.alias
) -> tuple[str, str | None]:
    kind = "name" if _b906_is_libcst_module(node.module, node.level) else None
    return alias.asname or alias.name, kind


def _b906_named_binding(node: ast.AST) -> str:
    """Name bound by a ``match``/``except`` node itself ('' if none)."""
    if isinstance(node, (ast.MatchAs, ast.MatchStar, ast.ExceptHandler)):
        return node.name or ""
    if isinstance(node, ast.MatchMapping):
        return node.rest or ""
    return ""


def _b906_scope_bindings(  # noqa: C901
    statements: list[ast.stmt], cutoff: ast.AST, base: dict[str, str | None]
) -> dict[str, str | None]:
    """Resolve names in one scope body up to (excluding) ``cutoff``.

    Walks one scope's statements in order without descending into nested
    function/class/lambda/comprehension scopes (their bindings are their
    own; eager comprehensions only leak walruses, handled explicitly).
    Each name maps to ``"module"``/``"name"`` if its latest binding is a
    libcst import (see :func:`_b906_import_binding`), else ``None``. Uses
    latest binding wins, so a rebinding shadows an earlier import and a
    later import shadows an earlier rebinding. Bare annotations
    (``x: T``) do not bind. ``global``/``nonlocal`` are not modelled:
    they only occur inside functions, whose scopes are never resolved.
    """
    result = dict(base)

    def bind(name: str, kind: str | None) -> None:
        result[name] = kind

    def visit_definition(
        node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda,
    ) -> None:
        # Only the parts evaluated in this scope, then the name binding.
        # Lambdas bind no name in this scope (handled by the caller).
        name: str | None = None
        if isinstance(node, ast.ClassDef):
            parts: list[ast.AST] = [
                *node.decorator_list,
                *node.bases,
                *node.keywords,
            ]
            name = node.name
        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
            parts = list(_b906_definition_exprs(node))
            name = node.name
        else:
            parts = list(_b906_definition_exprs(node))
        for part in parts:
            visit(part)
        if name is not None:
            bind(name, None)

    def visit_comprehension(
        node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp,
    ) -> None:
        # Targets are comprehension-local; only walruses in the iterated/
        # element expressions bind in this scope.
        for generator in node.generators:
            visit(generator.iter)
            for condition in generator.ifs:
                visit(condition)
        if isinstance(node, ast.DictComp):
            if node.key is not None:
                visit(node.key)
            visit(node.value)
        else:
            visit(node.elt)

    def visit(node: ast.AST) -> None:
        if node is cutoff:
            return
        if isinstance(node, FUNCTION_NODES + (ast.ClassDef,)):
            visit_definition(node)
            return
        if isinstance(
            node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
        ):
            visit_comprehension(node)
            return
        if isinstance(node, ast.Import):
            for alias in node.names:
                bound, kind = _b906_import_binding(alias)
                bind(bound, kind)
            return
        if isinstance(node, ast.ImportFrom):
            for alias in node.names:
                if alias.name == "*":
                    continue
                bound, kind = _b906_importfrom_binding(node, alias)
                bind(bound, kind)
            return
        if isinstance(node, ast.AnnAssign) and node.value is None:
            visit(node.annotation)
            if not isinstance(node.target, ast.Name):
                visit(node.target)
            return
        if isinstance(node, ast.NamedExpr) and isinstance(node.target, ast.Name):
            visit(node.value)
            bind(node.target.id, None)
            return
        if isinstance(node, ast.Name):
            if isinstance(node.ctx, (ast.Store, ast.Del)):
                bind(node.id, None)
            return
        if isinstance(
            node, (ast.ExceptHandler, ast.MatchAs, ast.MatchStar, ast.MatchMapping)
        ):
            bound = _b906_named_binding(node)
            if bound:
                bind(bound, None)
            for child in ast.iter_child_nodes(node):
                visit(child)
            return
        for child in ast.iter_child_nodes(node):
            visit(child)

    for stmt in statements:
        if stmt is cutoff:
            break
        visit(stmt)
    return result


def _b906_definition_exprs(
    node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda,
) -> list[ast.expr]:
    """Expressions of a function/lambda evaluated in the enclosing scope."""
    if isinstance(node, ast.Lambda):
        return [
            default
            for default in (*node.args.defaults, *node.args.kw_defaults)
            if default is not None
        ]
    exprs: list[ast.expr] = list(node.decorator_list)
    args = [
        *node.args.posonlyargs,
        *node.args.args,
        *node.args.kwonlyargs,
    ]
    if node.args.vararg is not None:
        args.append(node.args.vararg)
    if node.args.kwarg is not None:
        args.append(node.args.kwarg)
    exprs.extend(arg.annotation for arg in args if arg.annotation is not None)
    exprs.extend(
        default
        for default in (*node.args.defaults, *node.args.kw_defaults)
        if default is not None
    )
    if node.returns is not None:
        exprs.append(node.returns)
    return exprs


def _b031_module_groupby_is_itertools(module: ast.Module) -> bool:
    """Whether a bare ``groupby`` is ``itertools.groupby`` or never bound.

    Whole-module ``ast.walk``; nested scopes are intentionally not modeled.
    """
    from_itertools = False
    other = False
    for node in ast.walk(module):
        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
            if node.name == "groupby":
                other = True
        elif isinstance(node, (ast.Import, ast.ImportFrom)):
            for alias in node.names:
                # Absolute ``from itertools import *`` binds ``groupby``.
                # Other star imports do not. ``import groupby.sub`` does.
                if alias.name == "*":
                    if (
                        isinstance(node, ast.ImportFrom)
                        and node.level == 0
                        and node.module == "itertools"
                    ):
                        from_itertools = True
                    continue
                bound = alias.asname or alias.name.split(".", 1)[0]
                if bound != "groupby":
                    continue
                if (
                    isinstance(node, ast.ImportFrom)
                    and node.level == 0
                    and node.module == "itertools"
                    and alias.name == "groupby"
                ):
                    from_itertools = True
                else:
                    other = True
        elif (
            isinstance(node, ast.Name)
            and node.id == "groupby"
            and isinstance(node.ctx, ast.Store)
        ):
            other = True
        elif (
            isinstance(node, (ast.MatchAs, ast.MatchStar, ast.ExceptHandler))
            and node.name == "groupby"
        ) or (isinstance(node, ast.MatchMapping) and node.rest == "groupby"):
            other = True
    return from_itertools or not other


@attr.s
class BugBearVisitor(ast.NodeVisitor):
    filename = attr.ib()
    lines = attr.ib()
    b008_b039_extend_immutable_calls: set[str] = attr.ib(factory=set)
    b902_classmethod_decorators: set[str] = attr.ib(factory=set)
    node_window: list[ast.AST] = attr.ib(factory=list)
    errors: list[error] = attr.ib(factory=list)
    contexts: list[Context] = attr.ib(factory=list)
    b040_caught_exception: B040CaughtException | None = attr.ib(default=None)

    NODE_WINDOW_SIZE = 4
    _b023_seen: set[ast.Name] = attr.ib(factory=set, init=False)
    _closure_reads_cache: dict[int, set[str]] = attr.ib(factory=dict, init=False)
    _symtable_root: Any = attr.ib(default=False, init=False)
    _b023_scopes: dict[int, tuple] = attr.ib(factory=dict, init=False)
    _b005_imports: set[str] = attr.ib(factory=set, init=False)
    # Module-scope libcst bindings from `_b906_scope_bindings` (name ->
    # ``"module"``/``"name"``/``None``), resolved lazily per class so the
    # position cutoff is the class being checked; ``None`` until known.
    _b906_module_libcst: Callable[[ast.AST], dict[str, str | None]] | None = attr.ib(
        default=None, init=False
    )
    # None marks an imported name that has since been rebound at module scope.
    _b008_imports: dict[str, str | None] = attr.ib(factory=dict, init=False)
    _b008_class_imports: list[dict[str, str | None]] = attr.ib(factory=list, init=False)
    _b008_class_globals: list[set[str]] = attr.ib(factory=list, init=False)
    # None until the enclosing module has been scanned for bindings of groupby.
    _b031_bare_groupby_is_itertools: bool | None = attr.ib(default=None, init=False)

    # set to "*" when inside a try/except*, for correctly printing errors
    in_trystar: str = attr.ib(default="")

    if False:
        # Useful for tracing what the hell is going on.

        def __getattr__(self, name: str):  # type: ignore[unreachable]
            print(name)
            return self.__getattribute__(name)

    def add_error(self, code: str, node: AstPositionNode, *vars: object) -> None:
        self.errors.append(error_codes[code](node.lineno, node.col_offset, vars=vars))

    @property
    def node_stack(self) -> list[ast.AST]:
        if len(self.contexts) == 0:
            return []

        context, stack = self.contexts[-1]
        return stack

    def _b008_shadow_imports(
        self,
        names: Iterable[str],
        imports: dict[str, str | None] | None = None,
    ) -> None:
        if imports is None:
            imports = self._b008_imports
        for name in names:
            if imports.get(name) is not None:
                imports[name] = None

    def _b008_shadow_bindings(
        self,
        names: Iterable[str],
        imports: dict[str, str | None] | None = None,
    ) -> None:
        names = tuple(names)
        self._b008_shadow_imports(names, imports)
        if (
            imports is not None
            and self._b008_class_imports
            and imports is self._b008_class_imports[-1]
            and self._b008_class_globals
        ):
            global_names = self._b008_class_globals[-1].intersection(names)
            self._b008_shadow_imports(global_names)

    def _b008_shadow_named_expr_targets(
        self,
        nodes: Iterable[ast.AST],
        imports: dict[str, str | None] | None = None,
    ) -> None:
        finder = B008NamedExprFinder()
        finder.visit(list(nodes))
        self._b008_shadow_bindings(finder.names, imports)

    def _b008_in_module_scope(self) -> bool:
        return len(self.contexts) == 1 and isinstance(self.contexts[0].node, ast.Module)

    def _b008_is_direct_module_statement(self) -> bool:
        return self._b008_in_module_scope() and len(self.node_stack) == 2

    def _b008_in_module_child(self) -> bool:
        return len(self.contexts) == 2 and isinstance(self.contexts[0].node, ast.Module)

    def _b008_in_direct_module_child(self) -> bool:
        return self._b008_in_module_child() and len(self.contexts[0].stack) == 1

    def _b008_in_direct_module_class_scope(self) -> bool:
        return self._b008_in_direct_module_child() and isinstance(
            self.contexts[-1].node, ast.ClassDef
        )

    def _b008_in_direct_module_class_child(self) -> bool:
        return (
            len(self.contexts) == 3
            and isinstance(self.contexts[0].node, ast.Module)
            and isinstance(self.contexts[1].node, ast.ClassDef)
            and len(self.contexts[1].stack) == 1
        )

    def _b008_binding_imports(self) -> dict[str, str | None] | None:
        if self._b008_in_module_scope():
            return self._b008_imports
        if self._b008_in_direct_module_class_scope() and self._b008_class_imports:
            return self._b008_class_imports[-1]
        return None

    def _b008_function_imports(self) -> dict[str, str | None] | None:
        if self._b008_in_direct_module_child():
            return self._b008_imports
        if self._b008_in_direct_module_class_child() and self._b008_class_imports:
            return self._b008_class_imports[-1]
        return None

    @staticmethod
    def _b008_function_annotations(
        node: ast.FunctionDef | ast.AsyncFunctionDef,
    ) -> list[ast.expr]:
        arguments = [
            *node.args.posonlyargs,
            *node.args.args,
            *node.args.kwonlyargs,
        ]
        if node.args.vararg is not None:
            arguments.append(node.args.vararg)
        if node.args.kwarg is not None:
            arguments.append(node.args.kwarg)
        annotations = [argument.annotation for argument in arguments]
        if node.returns is not None:
            annotations.append(node.returns)
        return [annotation for annotation in annotations if annotation is not None]

    def in_class_init(self) -> bool:
        return (
            len(self.contexts) >= 2
            and isinstance(self.contexts[-2].node, ast.ClassDef)
            and isinstance(self.contexts[-1].node, ast.FunctionDef)
            and self.contexts[-1].node.name == "__init__"
        )

    def visit_Return(self, node: ast.Return) -> None:
        if self.in_class_init():
            if node.value is not None:
                self.add_error("B037", node)
        self.generic_visit(node)

    def visit_Yield(self, node: ast.Yield) -> None:
        if self.in_class_init():
            self.add_error("B037", node)
        self.generic_visit(node)

    def visit_YieldFrom(self, node: ast.YieldFrom) -> None:
        if self.in_class_init():
            self.add_error("B037", node)
        self.generic_visit(node)

    def visit(self, node: ast.AST) -> None:
        is_contextful = isinstance(node, CONTEXTFUL_NODES)

        if is_contextful:
            context = Context(node, [])
            self.contexts.append(context)

        self.node_stack.append(node)
        self.node_window.append(node)
        self.node_window = self.node_window[-self.NODE_WINDOW_SIZE :]
        super().visit(node)
        self.node_stack.pop()

        if is_contextful:
            self.contexts.pop()

        self.check_for_b018(node)

    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
        if node.type is None:
            self.add_error("B001", node)
            self.generic_visit(node)
            return

        old_b040_caught_exception = self.b040_caught_exception
        if node.name is None:
            self.b040_caught_exception = None
        else:
            self.b040_caught_exception = B040CaughtException(node.name, False)  # type: ignore[call-arg]

        names = self.check_for_b013_b014_b029_b030(node)

        if (
            "BaseException" in names
            and not ExceptBaseExceptionVisitor(node).re_raised()
        ):
            self.add_error("B036", node)

        self.generic_visit(node)

        if (
            self.b040_caught_exception is not None
            and self.b040_caught_exception.has_note
        ):
            self.add_error("B040", node)
        self.b040_caught_exception = old_b040_caught_exception
        imports = self._b008_binding_imports()
        if imports is not None and node.name is not None:
            self._b008_shadow_bindings((node.name,), imports)

    def visit_UAdd(self, node: ast.UAdd) -> None:
        trailing_nodes = list(map(type, self.node_window[-4:]))
        if trailing_nodes == [ast.UnaryOp, ast.UAdd, ast.UnaryOp, ast.UAdd]:
            originator = cast(ast.UnaryOp, self.node_window[-4])
            self.add_error("B002", originator)
        self.generic_visit(node)

    def visit_Call(self, node: ast.Call) -> None:
        is_b040_add_note = False
        if isinstance(node.func, ast.Attribute):
            self.check_for_b005(node)
            is_b040_add_note = self.check_for_b040_add_note(node.func)
        elif isinstance(node.func, ast.Name):
            # Check for getattr/setattr/delattr with constant attribute names
            with suppress(AttributeError, IndexError):
                if (
                    node.func.id in ("getattr", "hasattr")
                    and isinstance(node.args[1], ast.Constant)
                    and node.args[1].value == "__call__"
                ):
                    self.add_error("B004", node)
                if (
                    node.func.id == "getattr"
                    and len(node.args) == 2
                    and _is_identifier(node.args[1])
                    and isinstance(node.args[1], ast.Constant)
                    and isinstance(node.args[1].value, str)
                    and not iskeyword(node.args[1].value)
                ):
                    self.add_error("B009", node)
                elif (
                    not any(isinstance(n, ast.Lambda) for n in self.node_stack)
                    and node.func.id == "setattr"
                    and len(node.args) == 3
                    and _is_identifier(node.args[1])
                    and isinstance(node.args[1], ast.Constant)
                    and isinstance(node.args[1].value, str)
                    and not iskeyword(node.args[1].value)
                ):
                    self.add_error("B010", node)
                elif (
                    node.func.id == "delattr"
                    and len(node.args) == 2
                    and _is_identifier(node.args[1])
                    and isinstance(node.args[1], ast.Constant)
                    and isinstance(node.args[1].value, str)
                    and not iskeyword(node.args[1].value)
                ):
                    self.add_error("B043", node)

        self.check_for_b026(node)
        self.check_for_b028(node)
        self.check_for_b034(node)
        self.check_for_b039(node)
        self.check_for_b046(node)
        self.check_for_b905(node)
        self.check_for_b910(node)
        self.check_for_b911(node)
        self.check_for_b912(node)

        # no need for copying, if used in nested calls it will be set to None
        current_b040_caught_exception = self.b040_caught_exception
        if not is_b040_add_note:
            self.check_for_b040_usage(node.args)
            self.check_for_b040_usage(node.keywords)

        self.generic_visit(node)

        if is_b040_add_note:
            # Avoid nested calls within the parameter list using the variable itself.
            # e.g. `e.add_note(str(e))`
            self.b040_caught_exception = current_b040_caught_exception

    def visit_Module(self, node: ast.Module) -> None:
        self.generic_visit(node)

    def visit_Name(  # noqa: B906 # names don't contain other names
        self, node: ast.Name
    ) -> None:
        imports = self._b008_binding_imports()
        if (
            imports is not None
            and isinstance(node.ctx, (ast.Store, ast.Del))
            and not (
                isinstance(node.ctx, ast.Store)
                and len(self.node_stack) >= 2
                and isinstance(self.node_stack[-2], ast.AnnAssign)
                and self.node_stack[-2].value is None
            )
        ):
            self._b008_shadow_bindings((node.id,), imports)

    def visit_Assign(self, node: ast.Assign) -> None:
        self.check_for_b040_usage(node.value)
        if len(node.targets) == 1:
            t = node.targets[0]

            if isinstance(t, ast.Attribute) and isinstance(t.value, ast.Name):
                if (t.value.id, t.attr) == ("os", "environ"):
                    self.add_error("B003", node)
        self.generic_visit(node)

    def visit_For(self, node: ast.For) -> None:
        self.check_for_b045(node)
        self.check_for_b007(node)
        self.check_for_b020(node)
        self.check_for_b023(node)
        self.check_for_b031(node)
        self.check_for_b909(node)
        self.check_for_b913(node)
        self.generic_visit(node)

    def visit_AsyncFor(self, node: ast.AsyncFor) -> None:
        self.check_for_b045(node)
        self.check_for_b023(node)
        self.generic_visit(node)

    def visit_While(self, node: ast.While) -> None:
        self.check_for_b023(node)
        self.generic_visit(node)

    def visit_ListComp(self, node: ast.ListComp) -> None:
        self.check_for_b023(node)
        self.generic_visit(node)

    def visit_SetComp(self, node: ast.SetComp) -> None:
        self.check_for_b023(node)
        self.generic_visit(node)

    def visit_DictComp(self, node: ast.DictComp) -> None:
        self.check_for_b023(node)
        self.check_for_b035(node)
        self.generic_visit(node)

    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
        self.check_for_b023(node)
        self.generic_visit(node)

    def visit_Assert(self, node: ast.Assert) -> None:
        self.check_for_b011(node)
        self.check_for_b044(node)
        self.generic_visit(node)

    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
        self.check_for_b902(node)
        imports = self._b008_function_imports()
        if imports is not None:
            self._b008_shadow_named_expr_targets(node.decorator_list, imports)
        self.check_for_b006_and_b008(node)
        if imports is not None:
            self._b008_shadow_named_expr_targets(
                self._b008_function_annotations(node), imports
            )
        self.check_for_b019(node)
        self.check_for_b049(node)
        self.generic_visit(node)
        if self._b008_in_module_child():
            self._b008_shadow_imports((node.name,))
        elif self._b008_in_direct_module_class_child() and imports is not None:
            self._b008_shadow_bindings((node.name,), imports)

    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
        self.check_for_b901(node)
        self.check_for_b902(node)
        imports = self._b008_function_imports()
        if imports is not None:
            self._b008_shadow_named_expr_targets(node.decorator_list, imports)
        self.check_for_b006_and_b008(node)
        if imports is not None:
            self._b008_shadow_named_expr_targets(
                self._b008_function_annotations(node), imports
            )
        self.check_for_b019(node)
        self.check_for_b021(node)
        self.check_for_b049(node)
        self.check_for_b906(node)
        self.generic_visit(node)
        if self._b008_in_module_child():
            self._b008_shadow_imports((node.name,))
        elif self._b008_in_direct_module_class_child() and imports is not None:
            self._b008_shadow_bindings((node.name,), imports)

    def visit_ClassDef(self, node: ast.ClassDef) -> None:
        self.check_for_b903(node)
        is_module_class = self._b008_in_direct_module_child()
        parent_class_imports = None
        if self._b008_in_direct_module_class_child() and self._b008_class_imports:
            parent_class_imports = self._b008_class_imports[-1]
        if is_module_class:
            definition_nodes = [*node.decorator_list, *node.bases, *node.keywords]
            self._b008_shadow_named_expr_targets(definition_nodes)
            self._b008_class_imports.append(self._b008_imports.copy())
            self._b008_class_globals.append(set())
        self.check_for_b021(node)
        self.check_for_b024_and_b027(node)
        self.check_for_b042(node)
        self.generic_visit(node)
        if is_module_class:
            self._b008_class_imports.pop()
            self._b008_class_globals.pop()
        if self._b008_in_module_child():
            self._b008_shadow_imports((node.name,))
        elif parent_class_imports is not None:
            self._b008_shadow_bindings((node.name,), parent_class_imports)

    def visit_Try(self, node: ast.Try | ast.TryStar) -> None:
        self.check_for_b012(node)
        self.check_for_b025(node)
        self.check_for_b047(node)
        self.generic_visit(node)

    def visit_TryStar(self, node: ast.TryStar) -> None:
        outer_trystar = self.in_trystar
        self.in_trystar = "*"
        self.visit_Try(node)
        self.in_trystar = outer_trystar

    def visit_Compare(self, node: ast.Compare) -> None:
        self.check_for_b015(node)
        self.generic_visit(node)

    def visit_Raise(self, node: ast.Raise) -> None:
        if node.exc is None:
            self.b040_caught_exception = None
        else:
            self.check_for_b040_usage(node.exc)
            self.check_for_b040_usage(node.cause)
        self.check_for_b016(node)
        self.check_for_b904(node)
        self.generic_visit(node)

    def visit_With(self, node: ast.With) -> None:
        self.check_for_b017(node)
        self.check_for_b022(node)
        self.check_for_b908(node)
        self.generic_visit(node)

    def visit_MatchAs(self, node: ast.MatchAs) -> None:
        imports = self._b008_binding_imports()
        if imports is not None and node.name is not None:
            self._b008_shadow_bindings((node.name,), imports)
        self.generic_visit(node)

    def visit_MatchMapping(self, node: ast.MatchMapping) -> None:
        imports = self._b008_binding_imports()
        if imports is not None and node.rest is not None:
            self._b008_shadow_bindings((node.rest,), imports)
        self.generic_visit(node)

    def visit_MatchStar(self, node: ast.MatchStar) -> None:
        imports = self._b008_binding_imports()
        if imports is not None and node.name is not None:
            self._b008_shadow_bindings((node.name,), imports)
        self.generic_visit(node)

    def visit_Global(self, node: ast.Global) -> None:
        if self._b008_in_direct_module_class_scope() and self._b008_class_globals:
            self._b008_class_globals[-1].update(node.names)

    def visit_JoinedStr(self, node: ast.JoinedStr) -> None:
        self.check_for_b907(node)
        self.generic_visit(node)

    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
        self.check_for_b032(node)
        self.check_for_b040_usage(node.value)
        self.generic_visit(node)

    def visit_NamedExpr(self, node: ast.NamedExpr) -> None:
        if isinstance(node.target, ast.Name) and (
            self._b008_in_module_scope()
            or (
                len(self.contexts) >= 2
                and isinstance(self.contexts[0].node, ast.Module)
                and all(
                    isinstance(context.node, EAGER_COMPREHENSION_NODES)
                    for context in self.contexts[1:]
                )
            )
        ):
            self._b008_shadow_imports((node.target.id,))
        self.generic_visit(node)

    def visit_Import(self, node: ast.Import) -> None:
        self.check_for_b005(node)
        if self.b008_b039_extend_immutable_calls and self._b008_in_module_scope():
            for name in node.names:
                bound_name = name.asname or name.name.partition(".")[0]
                qualified_name = name.name if name.asname else bound_name
                if self._b008_is_direct_module_statement():
                    self._b008_imports[bound_name] = qualified_name
                else:
                    self._b008_shadow_imports((bound_name,))
        elif (imports := self._b008_binding_imports()) is not None:
            self._b008_shadow_bindings(
                (name.asname or name.name.partition(".")[0] for name in node.names),
                imports,
            )
        self.generic_visit(node)

    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
        self.check_for_b005(node)
        if self.b008_b039_extend_immutable_calls and self._b008_in_module_scope():
            for name in node.names:
                if name.name == "*":
                    self._b008_shadow_imports(self._b008_imports)
                elif (
                    self._b008_is_direct_module_statement()
                    and node.level == 0
                    and node.module is not None
                ):
                    self._b008_imports[name.asname or name.name] = (
                        f"{node.module}.{name.name}"
                    )
                else:
                    self._b008_shadow_imports((name.asname or name.name,))
        elif (imports := self._b008_binding_imports()) is not None:
            if any(name.name == "*" for name in node.names):
                self._b008_shadow_bindings(imports, imports)
            else:
                self._b008_shadow_bindings(
                    (name.asname or name.name for name in node.names), imports
                )
        self.generic_visit(node)

    def visit_Set(self, node: ast.Set) -> None:
        self.check_for_b033(node)
        self.generic_visit(node)

    def visit_Dict(self, node: ast.Dict) -> None:
        self.check_for_b041(node)
        self.generic_visit(node)

    def check_for_b041(self, node: ast.Dict) -> None:
        # Complain if there are duplicate key-value pairs in a dictionary literal.
        def convert_to_value(item: ast.expr | None) -> Any:
            if isinstance(item, ast.Constant):
                return item.value
            elif isinstance(item, ast.Tuple):
                return tuple(convert_to_value(i) for i in item.elts)
            elif isinstance(item, ast.Name):
                return B041VariableKeyType(item.id)  # type: ignore[call-arg]
            else:
                return B041UnhandledKeyType()

        keys = [convert_to_value(key) for key in node.keys]
        key_counts = Counter(keys)
        duplicate_keys = [key for key, count in key_counts.items() if count > 1]
        for key in duplicate_keys:
            key_indices = [i for i, i_key in enumerate(keys) if i_key == key]
            seen = set()
            for index in key_indices:
                value = convert_to_value(node.values[index])
                if value in seen:
                    key_node = node.keys[index]
                    if key_node is not None:
                        self.add_error("B041", key_node)
                seen.add(value)

    def check_for_b005(self, node: ast.Import | ast.ImportFrom | ast.Call) -> None:
        if isinstance(node, ast.Import):
            for name in node.names:
                self._b005_imports.add(name.asname or name.name)
        elif isinstance(node, ast.ImportFrom):
            for name in node.names:
                self._b005_imports.add(f"{node.module}.{name.name or name.asname}")
        elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
            if node.func.attr not in B005_METHODS:
                return  # method name doesn't match

            if (
                isinstance(node.func.value, ast.Name)
                and node.func.value.id in self._b005_imports
            ):
                return  # method is being run on an imported module

            if (
                len(node.args) != 1
                or not isinstance(node.args[0], ast.Constant)
                or not isinstance(node.args[0].value, str)
            ):
                return  # used arguments don't match the builtin strip

            value = node.args[0].value
            if len(value) == 1:
                return  # stripping just one character

            if len(value) == len(set(value)):
                return  # no characters appear more than once

            self.add_error("B005", node)

    def check_for_b006_and_b008(
        self, node: ast.FunctionDef | ast.AsyncFunctionDef
    ) -> None:
        imported_names = self._b008_function_imports()
        if not self.b008_b039_extend_immutable_calls:
            imported_names = None
        visitor = FunctionDefDefaultsVisitor(
            error_codes["B006"],
            error_codes["B008"],
            self.b008_b039_extend_immutable_calls,
            imported_names,
        )
        for default in node.args.defaults + node.args.kw_defaults:
            if default is not None:
                visitor.visit(default)
        self.errors.extend(visitor.errors)

    def check_for_b039(self, node: ast.Call) -> None:
        if not (
            (isinstance(node.func, ast.Name) and node.func.id == "ContextVar")
            or (
                isinstance(node.func, ast.Attribute)
                and node.func.attr == "ContextVar"
                and isinstance(node.func.value, ast.Name)
                and node.func.value.id == "contextvars"
            )
        ):
            return
        # ContextVar only takes one kw currently, but better safe than sorry
        for kw in node.keywords:
            if kw.arg == "default":
                break
        else:
            return

        visitor = FunctionDefDefaultsVisitor(
            error_codes["B039"],
            error_codes["B039"],
            self.b008_b039_extend_immutable_calls,
        )
        visitor.visit(kw.value)
        self.errors.extend(visitor.errors)

    def check_for_b007(self, node: ast.For) -> None:
        targets = NameFinder()
        targets.visit(node.target)
        ctrl_names = set(filter(lambda s: not s.startswith("_"), targets.names))
        body = NameFinder()
        for expr in node.body:
            body.visit(expr)
        unused_names = ctrl_names - set(body.names)
        scope = self.contexts[-1].node
        # Names bound in a class body are not visible to the functions nested in it.
        if unused_names and not isinstance(scope, ast.ClassDef):
            unused_names -= self._closure_reads(scope)
        for name in sorted(unused_names):
            n = targets.names[name][0]
            self.add_error("B007", n, name)

    def _closure_reads(self, scope: Any) -> set[str]:
        """Names read by functions nested in `scope`, as resolved by CPython:
        their free variables, plus (for a function or module) the globals
        they read when the name is global in the enclosing table."""
        if id(scope) not in self._closure_reads_cache:
            if self._symtable_root is False:  # once per file
                try:
                    source = "".join(self.lines)
                    self._symtable_root = symtable.symtable(
                        source, self.filename, "exec"
                    )
                except Exception:  # SyntaxError, ValueError, ...: no exemption
                    self._symtable_root = None
            table, module = self._symtable_root, isinstance(scope, ast.Module)
            scope_globals: set[str] = set()
            if not module:
                key = (scope.name, scope.lineno)
                table = next(
                    (
                        t
                        for t in _nested_tables(table, deep=True)
                        if isinstance(t, symtable.Function)
                        and (t.get_name(), t.get_lineno()) == key
                    ),
                    None,
                )
                if table is not None:
                    # A `global` declaration makes the loop target global too, in
                    # which case nested readers have no free variable.
                    scope_globals = {
                        s.get_name() for s in table.get_symbols() if s.is_global()
                    }
            reads: set[str] = set()
            for t in _nested_tables(table, deep=module):
                if module:
                    reads.update(
                        s.get_name()
                        for s in t.get_symbols()
                        if s.is_global() and s.is_referenced()
                    )
                else:
                    reads.update(t.get_frees())
            if scope_globals:
                # Referenced globals don't propagate through intermediate
                # functions, so look at every function nested in the scope. A
                # name bound locally in between is not global in the table that
                # reads it, so shadowing still counts as unused.
                for t in _nested_tables(table, deep=True):
                    reads.update(
                        s.get_name()
                        for s in t.get_symbols()
                        if s.get_name() in scope_globals
                        and s.is_global()
                        and s.is_referenced()
                    )
            self._closure_reads_cache[id(scope)] = reads
        return self._closure_reads_cache[id(scope)]

    def check_for_b011(self, node: ast.Assert) -> None:
        if isinstance(node.test, ast.Constant) and node.test.value is False:
            self.add_error("B011", node)

    def check_for_b012(self, node: ast.Try | ast.TryStar) -> None:
        def _loop(node: ast.AST, bad_node_types: tuple[type[ast.AST], ...]) -> None:
            if isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef)):
                return

            if isinstance(node, (ast.While, ast.For, ast.AsyncFor)):
                bad_node_types = (ast.Return,)

            elif isinstance(node, bad_node_types):
                # All Return, Continue, Break nodes have lineno and col_offset
                self.add_error("B012", cast(AstPositionNode, node), self.in_trystar)

            for child in ast.iter_child_nodes(node):
                _loop(child, bad_node_types)

        for child in node.finalbody:
            _loop(child, (ast.Return, ast.Continue, ast.Break))

    def check_for_b013_b014_b029_b030(self, node: ast.ExceptHandler) -> list[str]:
        handlers: Iterable[ast.expr | None] = _flatten_excepthandler(node.type)
        names: list[str] = []
        bad_handlers: list[object] = []
        ignored_handlers: list[ast.Name | ast.Attribute | ast.Call | ast.Starred] = []

        for handler in handlers:
            if isinstance(handler, (ast.Name, ast.Attribute)):
                name = _to_name_str(handler)
                if name is None:
                    ignored_handlers.append(handler)
                else:
                    names.append(name)
            elif isinstance(handler, (ast.Call, ast.Starred)):
                ignored_handlers.append(handler)
            else:
                bad_handlers.append(handler)
        if bad_handlers:
            self.add_error("B030", node)
        if len(names) == 0 and not bad_handlers and not ignored_handlers:
            self.add_error(
                "B029",
                node,
                self.in_trystar,
            )
        elif (
            len(names) == 1
            and not bad_handlers
            and not ignored_handlers
            and isinstance(node.type, ast.Tuple)
        ):
            self.add_error(
                "B013",
                node,
                *names,
                self.in_trystar,
            )
        else:
            maybe_error = _check_redundant_excepthandlers(names, node, self.in_trystar)
            if maybe_error is not None:
                self.errors.append(maybe_error)
        return names

    def check_for_b015(self, node: ast.Compare) -> None:
        if not isinstance(self.node_stack[-2], ast.Expr):
            return
        # An overloaded comparison can intentionally raise or warn in a test.
        # node_stack is local to the current scope, so nested function bodies
        # do not inherit an outer assertion context manager.
        if any(
            isinstance(ancestor, ast.With)
            and any(self._is_assertRaises_like(item) for item in ancestor.items)
            for ancestor in self.node_stack
        ):
            return
        self.add_error("B015", node)

    def check_for_b016(self, node: ast.Raise) -> None:
        if isinstance(node.exc, ast.JoinedStr) or (
            isinstance(node.exc, ast.Constant)
            and (
                isinstance(node.exc.value, (int, float, complex, str, bool))
                or node.exc.value is None
            )
        ):
            self.add_error("B016", node)

    def check_for_b017(self, node: ast.With) -> None:
        """Checks for use of the evil syntax 'with assertRaises(Exception):'
        or 'with pytest.raises(Exception)'.

        This form of assertRaises will catch everything that subclasses
        Exception, which happens to be the vast majority of Python internal
        errors, including the ones raised when a non-existing method/function
        is called, or a function is called with an invalid dictionary key
        lookup.
        """
        item = node.items[0]
        item_context = item.context_expr

        if (
            isinstance(item_context, ast.Call)
            and (
                (
                    isinstance(item_context.func, ast.Attribute)
                    and (
                        item_context.func.attr == "assertRaises"
                        or (
                            item_context.func.attr == "raises"
                            and isinstance(item_context.func.value, ast.Name)
                            and item_context.func.value.id == "pytest"
                            and "match" not in (
                                kwd.arg for kwd in item_context.keywords
                            )
                        )
                    )
                )
                or (
                    isinstance(item_context.func, ast.Name)
                    and item_context.func.id == "raises"
                    and isinstance(item_context.func.ctx, ast.Load)
                    and "pytest.raises" in self._b005_imports
                    and "match" not in (kwd.arg for kwd in item_context.keywords)
                )
            )
            and len(item_context.args) == 1
            and isinstance(item_context.args[0], ast.Name)
            and item_context.args[0].id in {"Exception", "BaseException"}
            and not item.optional_vars
        ):
            self.add_error("B017", node)

    def check_for_b019(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
        if (
            len(node.decorator_list) == 0
            or len(self.contexts) < 2
            or not isinstance(self.contexts[-2].node, ast.ClassDef)
        ):
            return

        # Preserve decorator order so we can get the lineno from the decorator node
        # rather than the function node (this location definition changes in Python 3.8)
        resolved_decorators = (
            ".".join(compose_call_path(decorator)) for decorator in node.decorator_list
        )
        for idx, decorator in enumerate(resolved_decorators):
            if decorator in {"classmethod", "staticmethod"}:
                return

            if decorator in B019_CACHES:
                self.add_error("B019", node.decorator_list[idx])
                return

    def check_for_b049(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
        # Decorators are applied bottom-up, so a property/classmethod/staticmethod
        # listed *after* @abstractmethod is applied first, and abstractmethod then
        # tries to set `__isabstractmethod__` on a read-only descriptor.
        abstract_decorator: ast.expr | None = None
        for decorator in node.decorator_list:
            path = ".".join(compose_call_path(decorator))
            if path in {"abstractmethod", "abc.abstractmethod"}:
                abstract_decorator = decorator
            elif abstract_decorator is not None and (
                path in B049_DESCRIPTORS
                or (
                    isinstance(decorator, ast.Attribute)
                    and decorator.attr in B049_PROPERTY_ACCESSORS
                )
            ):
                self.add_error("B049", abstract_decorator, path)
                return

    def check_for_b020(self, node: ast.For) -> None:
        iterset = B020AttributeFinder()
        iterset.visit(node.iter)
        iterset_names = set(iterset.names)

        # `for self.a in self.b` rebinds an attribute, not the name `self`, so
        # comparing the bare base name reports every loop over a sibling
        # attribute of the same object. Compare the whole dotted path instead.
        candidates: dict[str, ast.expr] = dict(_dotted_targets(node.target))
        if candidates:
            iterset_names |= iterset.paths

        # a name that only ever appears in load context is the *base* of an
        # attribute or subscript target, not something the loop rebinds.
        # Only the top-level bindings of the target share a name with the
        # pre-existing iterable; a name bound inside a nested destructuring
        # pattern, like `series` in
        # `for i, (ax, (series, name)) in enumerate(zip(axs, series))`,
        # shadows a value the iterable expression already read and is not
        # what the loop rebinds on each iteration.
        top_level: list[ast.expr] = (
            node.target.elts
            if isinstance(node.target, (ast.Tuple, ast.List))
            else [node.target]
        )
        for element in top_level:
            if isinstance(element, ast.Starred):
                element = element.value
            if isinstance(element, ast.Name):
                candidates.setdefault(element.id, element)

        for name in sorted(candidates):
            if name in iterset_names:
                self.add_error("B020", candidates[name], name)

    def check_for_b023(  # noqa: C901
        self,
        loop_node: (
            ast.For
            | ast.AsyncFor
            | ast.While
            | ast.GeneratorExp
            | ast.SetComp
            | ast.ListComp
            | ast.DictComp
        ),
    ) -> None:
        """Check that functions (including lambdas) do not use loop variables.

        https://docs.python-guide.org/writing/gotchas/#late-binding-closures from
        functions - usually but not always lambdas - defined inside a loop are a
        classic source of bugs.

        For each use of a variable inside a function defined inside a loop, we
        emit a warning if that variable is reassigned on each loop iteration
        (outside the function).  This includes but is not limited to explicit
        loop variables like the `x` in `for x in range(3):`.
        """
        # Because most loops don't contain functions, it's most efficient to
        # implement this "backwards": first we find all the candidate variable
        # uses, and then if there are any we check for assignment of those names
        # inside the loop body.
        immediately_called = self._immediately_called_functions(loop_node)
        safe_functions = []
        suspicious_variables = []
        for node in ast.walk(loop_node):
            # check if function is immediately consumed to avoid false alarm
            if isinstance(node, ast.Call):
                # check for filter&reduce
                if (
                    isinstance(node.func, ast.Name)
                    and node.func.id in ("filter", "reduce", "map")
                ) or (
                    isinstance(node.func, ast.Attribute)
                    and node.func.attr == "reduce"
                    and isinstance(node.func.value, ast.Name)
                    and node.func.value.id == "functools"
                ):
                    for arg in node.args:
                        if isinstance(arg, FUNCTION_NODES):
                            safe_functions.append(arg)

                # check for key=
                for keyword in node.keywords:
                    if keyword.arg == "key" and isinstance(
                        keyword.value, FUNCTION_NODES
                    ):
                        safe_functions.append(keyword.value)

            # mark `return lambda: x` as safe
            # does not (currently) check inner lambdas in a returned expression
            # e.g. `return (lambda: x, )
            if isinstance(node, ast.Return):
                if isinstance(node.value, FUNCTION_NODES):
                    safe_functions.append(node.value)

            # a function that is only ever *called* in the loop body cannot
            # outlive the iteration its free variables were assigned in
            if (
                isinstance(node, ast.FunctionDef)
                and not node.decorator_list
                and node.name in immediately_called
            ):
                safe_functions.append(node)

            # find unsafe functions
            if isinstance(node, FUNCTION_NODES) and node not in safe_functions:
                argnames = {
                    arg.arg for arg in ast.walk(node.args) if isinstance(arg, ast.arg)
                }
                if isinstance(node, ast.Lambda):
                    body_nodes = ast.walk(node.body)
                else:
                    body_nodes = itertools.chain.from_iterable(map(ast.walk, node.body))
                errors = []
                for name in body_nodes:
                    if isinstance(name, ast.Name) and name.id not in argnames:
                        if isinstance(name.ctx, ast.Load):
                            errors.append(name)
                        elif isinstance(name.ctx, ast.Store):
                            argnames.add(name.id)
                for err in errors:
                    if err.id not in argnames and err not in self._b023_seen:
                        self._b023_seen.add(err)  # dedupe across nested loops
                        suspicious_variables.append(err)

        if suspicious_variables:
            if isinstance(loop_node, (ast.For, ast.AsyncFor, ast.While)):
                reassigned_in_loop = set(self._get_assigned_names(loop_node))
            elif isinstance(
                loop_node, (ast.GeneratorExp, ast.SetComp, ast.ListComp, ast.DictComp)
            ):
                # For comprehensions, the iteration variables are implicitly reassigned
                reassigned_in_loop = set()
                for generator in loop_node.generators:
                    if isinstance(generator.target, ast.Name):
                        reassigned_in_loop.add(generator.target.id)
                    elif isinstance(generator.target, ast.Tuple):
                        reassigned_in_loop.update(
                            self._get_names_from_tuple(generator.target)
                        )
            else:
                reassigned_in_loop = set()

        for err in sorted(suspicious_variables, key=lambda n: n.id):
            if err.id in reassigned_in_loop:
                self.add_error("B023", err, err.id)

    def _immediately_called_functions(
        self,
        loop_node: (
            ast.For
            | ast.AsyncFor
            | ast.While
            | ast.GeneratorExp
            | ast.SetComp
            | ast.ListComp
            | ast.DictComp
        ),
    ) -> set[str]:
        """Names of functions defined in the loop that cannot outlive an iteration.

        A function defined in a loop is only subject to the late-binding gotcha
        B023 warns about if a reference to it survives the iteration it was
        created in. So a name is reported here -- and thus exempted -- only when
        every reference to it, anywhere in the enclosing scope, is a direct call
        that runs in the same iteration as the definition. Being appended to a
        list, returned, passed as an argument, or called from a nested function
        all let the function escape, and keep the warning.
        """
        body = getattr(loop_node, "body", None)
        if not isinstance(body, list):
            return set()

        # Only a plain `def` runs to completion when it is called. Calling an
        # `async def` builds a coroutine and calling a generator function builds
        # a generator: both defer the body, so the free variables are read after
        # the loop has moved on. A decorator may stash the original as well.
        candidates: dict[str, list[ast.FunctionDef]] = {}
        for statement in body:
            if (
                isinstance(statement, ast.FunctionDef)
                and not statement.decorator_list
                and not _defines_a_generator(statement)
            ):
                candidates.setdefault(statement.name, []).append(statement)
        if not candidates:
            return set()

        parents, names_used, called_names = self._scope_reference_index(loop_node)

        # the `else` suite of a loop runs once the loop is over, so a call there
        # cannot be the call that keeps the function inside its iteration
        in_body = set()
        for statement in body:
            for node in ast.walk(statement):
                in_body.add(id(node))

        safe: set[str] = set()
        for name, definitions in candidates.items():
            # matching a reference by its identifier alone is only sound while
            # the name has exactly one binding in this scope
            if len(definitions) != 1 or _is_rebound(name, names_used, parents):
                continue
            definition = definitions[0]
            # a definition nothing refers to still leaves its name bound after
            # the loop, so it can be called later with the last iteration's
            # values -- exactly the bug, so it stays reported
            references = names_used.get(name, ())
            if references and all(
                self._is_call_within_the_iteration(
                    reference, definition, loop_node, parents, called_names, in_body
                )
                for reference in references
            ):
                safe.add(name)
        return safe

    def _scope_reference_index(
        self, loop_node: ast.AST
    ) -> tuple[dict[int, ast.AST], dict[str, list[ast.Name]], set[int]]:
        """Parent links, name uses and call targets for the scope of `loop_node`.

        Built once per scope and cached: walking the scope again for every loop
        it contains turns a linear traversal into a quadratic one on files with
        many sequential loops.
        """
        scope: ast.AST = loop_node
        for ancestor in reversed(self.node_stack):
            if isinstance(ancestor, (ast.Module, ast.ClassDef, *FUNCTION_NODES)):
                scope = ancestor
                break

        cached = self._b023_scopes.get(id(scope))
        if cached is not None:
            return cached

        parents: dict[int, ast.AST] = {}
        names_used: dict[str, list[ast.Name]] = {}
        called_names: set[int] = set()
        for parent in ast.walk(scope):
            if isinstance(parent, ast.Call) and isinstance(parent.func, ast.Name):
                called_names.add(id(parent.func))
            for child in ast.iter_child_nodes(parent):
                parents[id(child)] = parent
            if isinstance(parent, ast.Name):
                names_used.setdefault(parent.id, []).append(parent)

        index = (parents, names_used, called_names)
        self._b023_scopes[id(scope)] = index
        return index

    def _is_call_within_the_iteration(
        self,
        reference: ast.Name,
        definition: ast.FunctionDef,
        loop_node: ast.AST,
        parents: dict[int, ast.AST],
        called_names: set[int],
        in_body: set[int],
    ) -> bool:
        """Is this reference a call that runs in the iteration that defined it?"""
        if id(reference) not in in_body:
            return False
        if not isinstance(reference.ctx, ast.Load):
            return False
        if id(reference) not in called_names:
            return False
        # a call placed above the `def` invokes the binding the previous
        # iteration left behind, which is the very bug B023 is about
        if (reference.lineno, reference.col_offset) < (
            definition.lineno,
            definition.col_offset,
        ):
            return False
        # a call reached through another deferred body happens whenever that
        # body is run, which may be long after the loop has finished
        node: ast.AST | None = parents.get(id(reference))
        while node is not None and node is not loop_node:
            if isinstance(node, (*FUNCTION_NODES, ast.GeneratorExp)):
                return False
            node = parents.get(id(node))
        return True

    def check_for_b024_and_b027(self, node: ast.ClassDef) -> None:  # noqa: C901
        """Check for inheritance from abstract classes in abc and lack of
        any methods decorated with abstract*"""

        def is_abc_class(value, name: str = "ABC"):
            # class foo(metaclass = [abc.]ABCMeta)
            if isinstance(value, ast.keyword):
                return value.arg == "metaclass" and is_abc_class(value.value, "ABCMeta")
            # class foo(ABC)
            # class foo(abc.ABC)
            return (isinstance(value, ast.Name) and value.id == name) or (
                isinstance(value, ast.Attribute)
                and value.attr == name
                and isinstance(value.value, ast.Name)
                and value.value.id == "abc"
            )

        def is_abstract_decorator(expr):
            return (isinstance(expr, ast.Name) and expr.id[:8] == "abstract") or (
                isinstance(expr, ast.Attribute) and expr.attr[:8] == "abstract"
            )

        def is_overload(expr):
            return (isinstance(expr, ast.Name) and expr.id == "overload") or (
                isinstance(expr, ast.Attribute) and expr.attr == "overload"
            )

        def empty_body(body) -> bool:
            def is_str_or_ellipsis(node):
                return isinstance(node, ast.Constant) and (
                    node.value is Ellipsis or isinstance(node.value, str)
                )

            # Function body consist solely of `pass`, `...`, and/or (doc)string literals
            return all(
                isinstance(stmt, ast.Pass)
                or (isinstance(stmt, ast.Expr) and is_str_or_ellipsis(stmt.value))
                for stmt in body
            )

        # don't check multiple inheritance
        # https://github.com/PyCQA/flake8-bugbear/issues/277
        if len(node.bases) + len(node.keywords) > 1:
            return

        # only check abstract classes
        if not any(map(is_abc_class, (*node.bases, *node.keywords))):
            return

        has_method = False
        has_abstract_method = False

        for stmt in node.body:
            # https://github.com/PyCQA/flake8-bugbear/issues/293
            # Ignore abc's that declares a class attribute that must be set
            if isinstance(stmt, ast.AnnAssign) and stmt.value is None:
                has_abstract_method = True
                continue

            # only check function defs
            if not isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
                continue
            has_method = True

            has_abstract_decorator = any(
                map(is_abstract_decorator, stmt.decorator_list)
            )

            has_abstract_method |= has_abstract_decorator

            if (
                not has_abstract_decorator
                and empty_body(stmt.body)
                and not any(map(is_overload, stmt.decorator_list))
            ):
                self.add_error("B027", stmt, stmt.name)

        if has_method and not has_abstract_method:
            self.add_error("B024", node, node.name)

    def check_for_b026(self, call: ast.Call) -> None:
        if not call.keywords:
            return

        starreds = [arg for arg in call.args if isinstance(arg, ast.Starred)]
        if not starreds:
            return

        first_keyword = call.keywords[0].value
        for starred in starreds:
            if (starred.lineno, starred.col_offset) > (
                first_keyword.lineno,
                first_keyword.col_offset,
            ):
                self.add_error("B026", starred)

    @staticmethod
    def _is_b031_group_materialization(node: ast.AST, group_name: str) -> bool:
        if isinstance(node, ast.Assign):
            targets = node.targets
        elif isinstance(node, ast.AnnAssign):
            targets = [node.target]
        else:
            return False

        value = node.value
        return (
            any(isinstance(t, ast.Name) and t.id == group_name for t in targets)
            and isinstance(value, ast.Call)
            and isinstance(value.func, ast.Name)
            and value.func.id in {"list", "tuple"}
            and len(value.args) == 1
            and isinstance(value.args[0], ast.Name)
            and value.args[0].id == group_name
            and not value.keywords
        )

    def _check_b031_group_usages(
        self,
        nodes: Sequence[ast.AST],
        group_name: str,
        num_usages: int = 0,
        repeated: bool = False,
    ) -> int:
        for node in nodes:
            num_usages = self._check_b031_group_usage(
                node, group_name, num_usages, repeated
            )
            if self._is_b031_group_materialization(node, group_name):
                # The RHS still consumes the generator. After the assignment,
                # a negative count marks a path where the name is reusable.
                return -1
        return num_usages

    def _check_b031_group_usage(
        self,
        node: ast.AST,
        group_name: str,
        num_usages: int,
        repeated: bool,
    ) -> int:
        if num_usages < 0:
            return num_usages

        if isinstance(node, ast.Name):
            if node.id == group_name and isinstance(node.ctx, ast.Load):
                num_usages += 1
                if repeated or num_usages > 1:
                    self.add_error("B031", node, node.id)
            return num_usages

        if isinstance(node, ast.If):
            num_usages = self._check_b031_group_usage(
                node.test, group_name, num_usages, repeated
            )
            # Only one branch can execute, so keep the largest path count
            # instead of adding usages from mutually exclusive branches.
            return max(
                self._check_b031_group_usages(
                    node.body, group_name, num_usages, repeated
                ),
                self._check_b031_group_usages(
                    node.orelse, group_name, num_usages, repeated
                ),
            )

        if isinstance(node, (ast.For, ast.AsyncFor)):
            num_usages = self._check_b031_group_usage(
                node.target, group_name, num_usages, repeated
            )
            num_usages = self._check_b031_group_usage(
                node.iter, group_name, num_usages, repeated
            )
            # Any body reference may run once per nested loop iteration.
            # A nested loop may never run, so its assignments are not definite.
            num_usages = max(
                num_usages,
                self._check_b031_group_usages(node.body, group_name, num_usages, True),
            )
            return self._check_b031_group_usages(
                node.orelse, group_name, num_usages, repeated
            )

        if isinstance(node, ast.While):
            num_usages = self._check_b031_group_usage(
                node.test, group_name, num_usages, repeated
            )
            # A while body can also consume the group on every iteration.
            num_usages = max(
                num_usages,
                self._check_b031_group_usages(node.body, group_name, num_usages, True),
            )
            return self._check_b031_group_usages(
                node.orelse, group_name, num_usages, repeated
            )

        for child in ast.iter_child_nodes(node):
            # Other constructs may contain optional or deferred execution.
            # Keep usage counts, but do not assume their assignments ran.
            num_usages = max(
                num_usages,
                self._check_b031_group_usage(child, group_name, num_usages, repeated),
            )
        return num_usages

    def _b031_groupby_is_itertools(self) -> bool:
        """Whether a bare ``groupby()`` in this module is ``itertools.groupby``."""
        if self._b031_bare_groupby_is_itertools is None:
            module = self.contexts[0].node if self.contexts else None
            # No module to inspect: keep the historical report.
            self._b031_bare_groupby_is_itertools = (
                _b031_module_groupby_is_itertools(module)
                if isinstance(module, ast.Module)
                else True
            )
        return self._b031_bare_groupby_is_itertools

    def check_for_b031(self, loop_node: ast.For) -> None:  # noqa: C901
        """Check that `itertools.groupby` isn't iterated over more than once.

        We emit a warning when the generator returned by `groupby()` is used
        more than once inside a loop body or when it's used in a nested loop.
        A bare ``groupby()`` counts only when that name is itertools or unbound.
        """
        # for <loop_node.target> in <loop_node.iter>: ...
        if isinstance(loop_node.iter, ast.Call):
            node = loop_node.iter
            if (
                isinstance(node.func, ast.Name)
                and node.func.id == "groupby"
                and self._b031_groupby_is_itertools()
            ) or (
                isinstance(node.func, ast.Attribute)
                and node.func.attr == "groupby"
                and isinstance(node.func.value, ast.Name)
                and node.func.value.id == "itertools"
            ):
                # We have an invocation of groupby which is a simple unpacking
                if isinstance(loop_node.target, ast.Tuple) and isinstance(
                    loop_node.target.elts[1], ast.Name
                ):
                    group_name = loop_node.target.elts[1].id
                else:
                    # Ignore any `groupby()` invocation that isn't unpacked
                    return

                self._check_b031_group_usages(loop_node.body, group_name)

    def _get_names_from_tuple(self, node: ast.Tuple) -> Iterator[str]:
        for dim in node.elts:
            if isinstance(dim, ast.Name):
                yield dim.id
            elif isinstance(dim, ast.Tuple):
                yield from self._get_names_from_tuple(dim)

    def _get_dict_comp_loop_and_named_expr_var_names(
        self, node: ast.DictComp
    ) -> Iterator[str]:
        finder = NamedExprFinder()
        for gen in node.generators:
            if isinstance(gen.target, ast.Name):
                yield gen.target.id
            elif isinstance(gen.target, ast.Tuple):
                yield from self._get_names_from_tuple(gen.target)

            finder.visit(gen.ifs)

        yield from finder.names.keys()

    def check_for_b035(self, node: ast.DictComp) -> None:
        """Check that a static key isn't used in a dict comprehension.

        Emit a warning if a likely unchanging key is used - either a constant,
        or a variable that isn't coming from the generator expression.
        """
        # `{**d for d in ...}` has no key on Python 3.15+, only an unpacked
        # expression, so there is no static key to report.
        if node.value is None:
            return
        if isinstance(node.key, ast.Constant):
            self.add_error("B035", node.key, node.key.value)
        elif isinstance(node.key, ast.Name):
            if node.key.id not in self._get_dict_comp_loop_and_named_expr_var_names(
                node
            ):
                self.add_error("B035", node.key, node.key.id)

    def check_for_b040_add_note(self, node: ast.Attribute) -> bool:
        if (
            node.attr == "add_note"
            and isinstance(node.value, ast.Name)
            and self.b040_caught_exception
            and node.value.id == self.b040_caught_exception.name
        ):
            self.b040_caught_exception.has_note = True
            return True
        return False

    def check_for_b040_usage(
        self, node: ast.expr | list[ast.expr] | list[ast.keyword] | None
    ) -> None:
        def superwalk(
            node: ast.AST | list[ast.AST] | list[ast.expr] | list[ast.keyword],
        ) -> Iterator[ast.AST]:
            if isinstance(node, list):
                for n in node:
                    yield from ast.walk(n)
            else:
                yield from ast.walk(node)

        if not self.b040_caught_exception or node is None:
            return

        for n in superwalk(node):
            if isinstance(n, ast.Name) and n.id == self.b040_caught_exception.name:
                self.b040_caught_exception = None
                break

    def _get_assigned_names(
        self, loop_node: ast.For | ast.AsyncFor | ast.While
    ) -> Iterator[str]:
        loop_targets = (ast.For, ast.AsyncFor, ast.comprehension)
        for node in children_in_scope(loop_node):
            if isinstance(node, (ast.Assign)):
                for child in node.targets:
                    yield from names_from_assignments(child)
            if isinstance(node, loop_targets + (ast.AnnAssign, ast.AugAssign)):
                yield from names_from_assignments(node.target)

    def check_for_b904(self, node: ast.Raise) -> None:
        """Checks `raise` without `from` inside an `except` clause.

        In these cases, you should use explicit exception chaining from the
        earlier error, or suppress it with `raise ... from None`.  See
        https://docs.python.org/3/tutorial/errors.html#exception-chaining
        """
        if (
            node.cause is None
            and node.exc is not None
            and not (isinstance(node.exc, ast.Name) and node.exc.id.islower())
            and any(isinstance(n, ast.ExceptHandler) for n in self.node_stack)
        ):
            self.add_error("B904", node, self.in_trystar)

    def walk_function_body(
        self, node: ast.FunctionDef | ast.AsyncFunctionDef
    ) -> Iterator[tuple[ast.AST, ast.AST]]:
        def _loop(parent: ast.AST, node: ast.AST) -> Iterator[tuple[ast.AST, ast.AST]]:
            if isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef)):
                return
            yield parent, node
            for child in ast.iter_child_nodes(node):
                yield from _loop(node, child)

        for child in node.body:
            yield from _loop(node, child)

    def check_for_b901(self, node: ast.FunctionDef) -> None:
        if node.name == "__await__":
            return

        # If the user explicitly wrote the 3-argument version of Generator as the
        # return annotation, they probably know what they were doing.
        if (
            node.returns is not None
            and isinstance(node.returns, ast.Subscript)
            and (
                is_name(node.returns.value, "Generator")
                or is_name(node.returns.value, "typing.Generator")
                or is_name(node.returns.value, "collections.abc.Generator")
            )
        ):
            slice = node.returns.slice
            if sys.version_info < (3, 9) and isinstance(slice, ast.Index):
                slice = slice.value
            if isinstance(slice, ast.Tuple) and len(slice.elts) == 3:
                return

        has_yield = False
        return_node = None

        for parent, x in self.walk_function_body(node):
            # Only consider yield when it is part of an Expr statement.
            if isinstance(parent, ast.Expr) and isinstance(
                x, (ast.Yield, ast.YieldFrom)
            ):
                has_yield = True

            if isinstance(x, ast.Return) and x.value is not None:
                return_node = x

        if has_yield and return_node is not None:
            self.add_error("B901", return_node)

    # taken from pep8-naming
    @classmethod
    def find_decorator_name(cls, d: ast.expr) -> str | None:
        if isinstance(d, ast.Name):
            return d.id
        elif isinstance(d, ast.Attribute):
            return d.attr
        elif isinstance(d, ast.Call):
            return cls.find_decorator_name(d.func)
        return None

    def check_for_b902(  # noqa: C901 (too complex)
        self, node: ast.FunctionDef | ast.AsyncFunctionDef
    ) -> None:
        def is_classmethod(decorators: set[str]) -> bool:
            return (
                any(name in decorators for name in self.b902_classmethod_decorators)
                or "abstractclassmethod" in decorators
                or node.name in B902_IMPLICIT_CLASSMETHODS
            )

        if len(self.contexts) < 2 or not isinstance(
            self.contexts[-2].node, ast.ClassDef
        ):
            return

        cls = self.contexts[-2].node

        decorators: set[str] = {
            d
            for d in (self.find_decorator_name(dec) for dec in node.decorator_list)
            if d is not None
        }

        if "staticmethod" in decorators or "abstractstaticmethod" in decorators:
            # TODO: maybe warn if the first argument is surprisingly `self` or
            # `cls`?
            return

        bases = {
            b.id if isinstance(b, ast.Name) else b.attr
            for b in cls.bases
            if isinstance(b, (ast.Name, ast.Attribute))
        }
        if any(basetype in bases for basetype in ("type", "ABCMeta", "EnumMeta")):
            if is_classmethod(decorators):
                expected_first_args = B902_METACLS
                kind = "metaclass class"
            else:
                expected_first_args = B902_CLS
                kind = "metaclass instance"
        else:
            if is_classmethod(decorators):
                expected_first_args = B902_CLS
                kind = "class"
            else:
                expected_first_args = B902_SELF
                kind = "instance"

        args = getattr(node.args, "posonlyargs", []) + node.args.args
        vararg = node.args.vararg
        kwarg = node.args.kwarg
        kwonlyargs = node.args.kwonlyargs

        if args:
            actual_first_arg = args[0].arg
            err_node = args[0]
        elif vararg:
            actual_first_arg = "*" + vararg.arg
            err_node = vararg
        elif kwarg:
            actual_first_arg = "**" + kwarg.arg
            err_node = kwarg
        elif kwonlyargs:
            actual_first_arg = "*, " + kwonlyargs[0].arg
            err_node = kwonlyargs[0]
        else:
            actual_first_arg = "(none)"
            err_node = node

        if actual_first_arg not in expected_first_args:
            if not actual_first_arg.startswith(("(", "*")):
                actual_first_arg = repr(actual_first_arg)
            self.add_error(
                "B902", err_node, actual_first_arg, kind, expected_first_args[0]
            )

    def check_for_b903(self, node: ast.ClassDef) -> None:
        # a namedtuple can't stand in for a subclass of something else, like an
        # exception or a dict
        if any(not (isinstance(b, ast.Name) and b.id == "object") for b in node.bases):
            return

        body = node.body
        if (
            body
            and isinstance(body[0], ast.Expr)
            and isinstance(body[0].value, ast.Constant)
            and isinstance(body[0].value.value, str)
        ):
            # Ignore the docstring
            body = body[1:]

        if (
            len(body) != 1
            or not isinstance(body[0], ast.FunctionDef)
            or body[0].name != "__init__"
        ):
            # only classes with *just* an __init__ method are interesting
            return

        # all the __init__ function does is a series of assignments to attributes
        for stmt in body[0].body:
            if not isinstance(stmt, ast.Assign):
                return
            targets = stmt.targets
            if len(targets) > 1 or not isinstance(targets[0], ast.Attribute):
                return
            if not isinstance(stmt.value, ast.Name):
                return

        self.add_error("B903", node)

    def check_for_b018(self, node: ast.AST) -> None:
        if not isinstance(node, ast.Expr):
            return
        if (
            isinstance(
                node.value,
                (
                    ast.List,
                    ast.Set,
                    ast.Dict,
                    ast.Tuple,
                ),
            )
            or (
                isinstance(node.value, ast.Constant)
                and (
                    isinstance(node.value.value, (int, float, complex, bytes, bool))
                    or node.value.value is None
                )
            )
            or (
                isinstance(node.value, ast.Call)
                and isinstance(node.value.func, ast.Name)
                and node.value.func.id in FUNCTIONS_WITHOUT_SIDE_EFFECTS
            )
            # a lambda that is neither assigned nor passed anywhere is never called
            or (isinstance(node.value, ast.Lambda) and not _lambda_defaults(node.value))
            or (
                (
                    (
                        isinstance(node.value, (ast.UnaryOp, ast.BinOp))
                        and _is_useless_operation(node.value)
                    )
                    # a generator expression is lazy, so its body never runs, but
                    # its first iterable is evaluated right away: `(x for x in f())`
                    # still calls `f`
                    or (
                        isinstance(node.value, ast.GeneratorExp)
                        and _is_useless_operation(node.value.generators[0].iter)
                    )
                    # and so are the defaults of a lambda: `lambda x=f(): x`
                    or (
                        isinstance(node.value, ast.Lambda)
                        and all(
                            map(_is_useless_operation, _lambda_defaults(node.value))
                        )
                    )
                    # `map()`, `filter()` and the like are lazy too, so the
                    # function or loop they were meant for never runs
                    or (
                        isinstance(node.value, ast.Call)
                        and isinstance(node.value.func, ast.Name)
                        and node.value.func.id in B018_LAZY_FUNCTIONS
                    )
                )
                # directly in a `try` or `with` block, an operation is often run
                # only to see it raise: `with pytest.raises(TypeError): "1" + 1`.
                # The same goes for the first iterable of a generator expression,
                # which `iter()` is called on, the defaults of a lambda, and the
                # arguments of a lazy builtin, which it checks right away:
                # `(x for x in 1)`, `lambda x=1 / 0: x` or `zip(1)`
                and not (
                    self.node_stack
                    and isinstance(self.node_stack[-1], B018_RAISING_BLOCKS)
                )
            )
        ):
            self.add_error("B018", node, node.value.__class__.__name__)

    def check_for_b021(self, node: ast.FunctionDef | ast.ClassDef) -> None:
        if (
            node.body
            and isinstance(node.body[0], ast.Expr)
            and isinstance(node.body[0].value, ast.JoinedStr)
        ):
            self.add_error("B021", node.body[0].value)

    def check_for_b022(self, node: ast.With) -> None:
        item = node.items[0]
        item_context = item.context_expr
        if (
            isinstance(item_context, ast.Call)
            and isinstance(item_context.func, ast.Attribute)
            and isinstance(item_context.func.value, ast.Name)
            and item_context.func.value.id == "contextlib"
            and item_context.func.attr == "suppress"
            and len(item_context.args) == 0
        ):
            self.add_error("B022", node)

    @staticmethod
    def _is_assertRaises_like(node: ast.withitem) -> bool:
        if not (
            isinstance(node, ast.withitem)
            and isinstance(node.context_expr, ast.Call)
            and isinstance(node.context_expr.func, (ast.Attribute, ast.Name))
        ):
            return False
        if isinstance(node.context_expr.func, ast.Name):
            # "with raises"
            return node.context_expr.func.id in B908_pytest_functions
        elif isinstance(node.context_expr.func, ast.Attribute) and isinstance(
            node.context_expr.func.value, ast.Name
        ):
            return (
                # "with pytest.raises"
                node.context_expr.func.value.id == "pytest"
                and node.context_expr.func.attr in B908_pytest_functions
            ) or (
                # "with self.assertRaises"
                node.context_expr.func.value.id == "self"
                and node.context_expr.func.attr in B908_unittest_methods
            )
        else:
            return False

    def check_for_b908(self, node: ast.With) -> None:
        if len(node.body) < 2:
            return
        for node_item in node.items:
            if self._is_assertRaises_like(node_item):
                self.add_error("B908", node)

    def check_for_b025(self, node: ast.Try | ast.TryStar) -> None:
        seen = []
        for handler in node.handlers:
            if isinstance(handler.type, (ast.Name, ast.Attribute)):
                name = ".".join(compose_call_path(handler.type))
                seen.append(name)
            elif isinstance(handler.type, ast.Tuple):
                # to avoid checking the same as B014, remove duplicates per except
                uniques = set()
                for entry in handler.type.elts:
                    name = ".".join(compose_call_path(entry))
                    uniques.add(name)
                seen.extend(uniques)
        # sort to have a deterministic output
        duplicates = sorted({x for x in seen if seen.count(x) > 1})
        for duplicate in duplicates:
            self.add_error("B025", node, duplicate, self.in_trystar)

    def check_for_b047(self, node: ast.Try | ast.TryStar) -> None:
        # Only builtin exceptions are checked, since we can't know the class
        # hierarchy of anything else from the AST.
        caught: list[tuple[str, type]] = []
        for handler in node.handlers:
            if handler.type is None:
                # a bare `except:` catches the same as `except BaseException:`
                names = ["BaseException"]
            else:
                names = [
                    e.id
                    for e in _flatten_excepthandler(handler.type)
                    if isinstance(e, ast.Name)
                ]

            current = []
            for name in names:
                exc = getattr(builtins, name, None)
                if not (
                    isinstance(exc, type) and _typesafe_issubclass(exc, BaseException)
                ):
                    continue
                for caught_name, caught_exc in caught:
                    # the same name caught twice is reported by B025
                    if (
                        name != caught_name or handler.type is None
                    ) and _typesafe_issubclass(exc, caught_exc):
                        self.add_error(
                            "B047", handler, name, caught_name, self.in_trystar
                        )
                        break
                current.append((name, exc))
            caught.extend(current)

    @staticmethod
    def _is_infinite_iterator(node: ast.expr) -> bool:
        if not (
            isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and isinstance(node.func.value, ast.Name)
            and node.func.value.id == "itertools"
        ):
            return False
        if node.func.attr in {"cycle", "count"}:
            return True
        elif node.func.attr == "repeat":
            if len(node.args) == 1 and len(node.keywords) == 0:
                # itertools.repeat(iterable)
                return True
            if (
                len(node.args) == 2
                and isinstance(node.args[1], ast.Constant)
                and node.args[1].value is None
            ):
                # itertools.repeat(iterable, None)
                return True
            for kw in node.keywords:
                # itertools.repeat(iterable, times=None)
                if (
                    kw.arg == "times"
                    and isinstance(kw.value, ast.Constant)
                    and kw.value.value is None
                ):
                    return True

        return False

    def check_for_b905(self, node: ast.Call) -> None:
        if not (isinstance(node.func, ast.Name) and node.func.id == "zip"):
            return
        for arg in node.args:
            if self._is_infinite_iterator(arg):
                return
        if not any(kw.arg == "strict" for kw in node.keywords):
            self.add_error("B905", node)

    def check_for_b912(self, node: ast.Call) -> None:
        # `map(strict=...)` was added in Python 3.14; emitting on older
        # interpreters would flag valid code.
        if sys.version_info < (3, 14):
            return
        if not (
            isinstance(node.func, ast.Name)
            and node.func.id == "map"
            and len(node.args) > 2
        ):
            return
        if not any(kw.arg == "strict" for kw in node.keywords):
            self.add_error("B912", node)

    def check_for_b913(self, node: ast.For) -> None:
        if not (
            isinstance(node.target, (ast.Tuple, ast.List))
            and isinstance(node.iter, ast.Call)
            and isinstance(node.iter.func, ast.Name)
            and node.iter.func.id == "zip"
        ):
            return

        targets = node.target.elts
        arguments = node.iter.args
        if (
            len(targets) != len(arguments)
            or any(isinstance(target, ast.Starred) for target in targets)
            or any(isinstance(argument, ast.Starred) for argument in arguments)
            or node.iter.keywords
        ):
            return

        if any(not isinstance(target, ast.Name) for target in targets):
            return

        underscore_indexes = [
            index for index, target in enumerate(targets) if target.id == "_"
        ]
        if not underscore_indexes or len(underscore_indexes) == len(targets):
            return

        # A single direct target has an unambiguous argument mapping wherever it
        # appears.  For repeated ``_`` targets, retain the conservative original
        # rule and only report a contiguous trailing group.
        if len(underscore_indexes) > 1 and underscore_indexes != list(
            range(underscore_indexes[0], len(targets))
        ):
            return

        if len(underscore_indexes) == 1:
            body_names = B913UsageFinder()
            body_names.visit(node.body + node.orelse)
            if "_" in body_names.names:
                return

        first_discarded = targets[underscore_indexes[0]]
        self.add_error("B913", first_discarded)

    def check_for_b906(self, node: ast.FunctionDef) -> None:
        if not node.name.startswith("visit_"):
            return

        if self._b906_in_libcst_visitor():
            return

        # extract what's visited
        class_name = node.name[len("visit_") :]

        # silence any DeprecationWarnings
        # that might come from accessing a deprecated AST node
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", category=DeprecationWarning)
            class_type = getattr(ast, class_name, None)

        if (
            # not a valid ast subclass
            class_type is None
            # doesn't have a non-empty '_fields' attribute - which is what's
            # iterated over in ast.NodeVisitor.generic_visit
            or not getattr(class_type, "_fields", None)
            # or can't contain any ast subnodes that could be visited
            # See https://docs.python.org/3/library/ast.html#abstract-grammar
            or class_type.__name__ in (
                "alias",
                "Constant",
                "Global",
                "MatchSingleton",
                "MatchStar",
                "Nonlocal",
                "TypeIgnore",
                # These ast nodes are deprecated, but some codebases may still use them
                # for backwards-compatibility with Python 3.7
                "Bytes",
                "Num",
                "Str",
            )
        ):
            return

        for n in itertools.chain.from_iterable(ast.walk(nn) for nn in node.body):
            if isinstance(n, ast.Call) and (
                (isinstance(n.func, ast.Attribute) and "visit" in n.func.attr)
                or (isinstance(n.func, ast.Name) and "visit" in n.func.id)
            ):
                break
        else:
            self.add_error("B906", node)

    def _b906_libcst_bindings_for(
        self, class_node: ast.ClassDef
    ) -> dict[str, str | None]:
        """Libcst bindings visible where ``class_node`` is defined.

        The class's bases are evaluated in the enclosing scope, so resolve
        them sequentially: module bindings up to the outermost enclosing
        class, then each enclosing class body up to the next class. The
        class's own body is not consulted -- it is not in scope for its
        bases. Classes inside functions/lambdas/comprehensions are left
        unresolved (still checked): their bases see function locals, which
        we do not model, so a local ``libcst = other`` must not be credited
        as the import (the shadowing issue raised on #590).
        """
        empty: dict[str, str | None] = {}
        if len(self.contexts) < 2 or not isinstance(self.contexts[0].node, ast.Module):
            return empty
        if not all(
            isinstance(context.node, (ast.Module, ast.ClassDef))
            for context in self.contexts[:-2]
        ):
            return empty
        module = cast(ast.Module, self.contexts[0].node)
        # Enclosing classes only: ``contexts[-2]`` is the class itself and
        # ``contexts[-1]`` is the method, neither is an enclosing scope for
        # the class's bases (its own body is not in scope for them).
        enclosing = [
            cast(ast.ClassDef, context.node) for context in self.contexts[1:-2]
        ]
        if self._b906_module_libcst is None:
            cache: dict[int, dict[str, str | None]] = {}

            def module_bindings(cutoff: ast.AST) -> dict[str, str | None]:
                key = id(cutoff)
                if key not in cache:
                    cache[key] = _b906_scope_bindings(module.body, cutoff, {})
                return cache[key]

            self._b906_module_libcst = module_bindings
        bindings = self._b906_module_libcst(enclosing[0] if enclosing else class_node)
        for index, outer in enumerate(enclosing):
            cutoff = enclosing[index + 1] if index + 1 < len(enclosing) else class_node
            bindings = _b906_scope_bindings(outer.body, cutoff, bindings)
        return bindings

    def _b906_in_libcst_visitor(self) -> bool:
        """Whether the function is a method of a class that directly inherits from
        libcst (e.g. ``libcst.CSTVisitor``). libcst visitors have no
        ``generic_visit`` and visit children automatically, so B906 does not apply.

        The base names must resolve to a libcst import in the scope where
        the class is defined; a name shadowed or rebound there (the Copilot
        review on #590) does not count.
        """
        if len(self.contexts) < 2 or not isinstance(
            self.contexts[-2].node, ast.ClassDef
        ):
            return False
        class_node = cast(ast.ClassDef, self.contexts[-2].node)
        bindings = self._b906_libcst_bindings_for(class_node)
        if not bindings:
            return False
        for base in class_node.bases:
            root = base
            while isinstance(root, ast.Attribute):
                root = root.value
            if not isinstance(root, ast.Name):
                continue
            if root is base and bindings.get(root.id) == "name":
                return True
            if root is not base and bindings.get(root.id) == "module":
                return True
        return False

    def check_for_b907(self, node: ast.JoinedStr) -> None:  # noqa: C901
        quote_marks = "'\""
        current_mark = None
        variable = None
        for value in node.values:
            if isinstance(value, ast.Constant) and isinstance(value.value, str):
                if not value.value:
                    continue

                # check for quote mark after pre-marked variable
                if (
                    current_mark is not None
                    and variable is not None
                    and value.value[0] == current_mark
                ):
                    self.add_error("B907", variable, ast.unparse(variable.value))
                    current_mark = variable = None
                    # don't continue with length>1, so we can detect a new pre-mark
                    # in the same string as a post-mark, e.g. `"{foo}" "{bar}"`
                    if len(value.value) == 1:
                        continue

                # detect pre-mark
                if value.value[-1] in quote_marks:
                    current_mark = value.value[-1]
                    variable = None
                    continue

            # detect variable, if there's a pre-mark
            if (
                current_mark is not None
                and variable is None
                and isinstance(value, ast.FormattedValue)
                and value.conversion != ord("r")
            ):
                # check if the format spec shows that this is numeric
                # or otherwise hard/impossible to convert to `!r`
                if (
                    isinstance(value.format_spec, ast.JoinedStr)
                    and value.format_spec.values  # empty format spec is fine
                ):
                    if (
                        # if there's variables in the format_spec, skip
                        len(value.format_spec.values) > 1
                        or not isinstance(value.format_spec.values[0], ast.Constant)
                        or not isinstance(value.format_spec.values[0].value, str)
                    ):
                        current_mark = variable = None
                        continue
                    format_specifier = value.format_spec.values[0].value

                    # if second character is an align, first character is a fill
                    # char - strip it
                    if len(format_specifier) > 1 and format_specifier[1] in "<>=^":
                        format_specifier = format_specifier[1:]

                    # strip out precision digits, so the only remaining ones are
                    # width digits, which will misplace the quotes
                    format_specifier = re.sub(r"\.\d*", "", format_specifier)

                    # skip if any invalid characters in format spec
                    invalid_characters = "".join(
                        (
                            "=",  # align character only valid for numerics
                            "+- ",  # sign
                            "0123456789",  # width digits
                            "z",  # coerce negative zero floating point to positive
                            "#",  # alternate form
                            "_,",  # thousands grouping
                            "bcdeEfFgGnoxX%",  # various number specifiers
                        )
                    )
                    if set(format_specifier).intersection(invalid_characters):
                        current_mark = variable = None
                        continue

                # otherwise save value as variable
                variable = value
                continue

            # if no pre-mark or variable detected, reset state
            current_mark = variable = None

    def check_for_b028(self, node: ast.Call) -> None:
        if (
            isinstance(node.func, ast.Attribute)
            and node.func.attr == "warn"
            and isinstance(node.func.value, ast.Name)
            and node.func.value.id == "warnings"
            and not any(kw.arg == "stacklevel" for kw in node.keywords)
            and all(
                kw.arg != "skip_file_prefixes"
                or (isinstance(kw.value, ast.Tuple) and not kw.value.elts)
                for kw in node.keywords
            )
            and len(node.args) < 3
            and not any(isinstance(a, ast.Starred) for a in node.args)
            and not any(kw.arg is None for kw in node.keywords)
        ):
            self.add_error("B028", node)

    def check_for_b032(self, node: ast.AnnAssign) -> None:
        if (
            node.value is None
            and hasattr(node.target, "value")
            and isinstance(node.target.value, ast.Name)
            and (
                isinstance(node.target, ast.Subscript)
                or (
                    isinstance(node.target, ast.Attribute)
                    and node.target.value.id != "self"
                )
            )
        ):
            self.add_error("B032", node)

    def check_for_b033(self, node: ast.Set) -> None:
        seen = set()
        for elt in node.elts:
            if not isinstance(elt, ast.Constant):
                continue
            if elt.value in seen:
                self.add_error("B033", elt, repr(elt.value))
            else:
                seen.add(elt.value)

    def check_for_b034(self, node: ast.Call) -> None:
        if not isinstance(node.func, ast.Attribute):
            return
        func = node.func
        if not isinstance(func.value, ast.Name) or func.value.id != "re":
            return

        def check(num_args: int, param_name: str) -> None:
            if len(node.args) > num_args:
                arg = node.args[num_args]
                self.add_error("B034", arg, func.attr, param_name)

        if func.attr in ("sub", "subn"):
            check(3, "count")
        elif func.attr == "split":
            check(2, "maxsplit")

    def check_for_b042(self, node: ast.ClassDef) -> None:  # noqa: C901 # too-complex
        def is_exception(s: str):
            for ending in "Exception", "Error", "Warning", "ExceptionGroup":
                if s.endswith(ending):
                    return True
            return False

        # A class must inherit from a super class to be an exception, and we also
        # require the class name or any of the base names to look like an exception name.
        # A parameterized generic base such as `ContextManager[T]` does not count as
        # that super class unless its own name looks like an exception name.
        concrete_bases = [b for b in node.bases if not isinstance(b, ast.Subscript)]
        if not (is_exception(node.name) and concrete_bases):
            for base in node.bases:
                if isinstance(base, ast.Subscript):
                    base = base.value
                if isinstance(base, ast.Name) and is_exception(base.id):
                    break
            else:
                return

        # if the user defines __str__ + a pickle dunder they're probably in the clear.
        has_pickle_dunder = False
        has_str = False
        for fun in node.body:
            if isinstance(fun, ast.FunctionDef) and fun.name in (
                "__getnewargs_ex__",
                "__getnewargs__",
                "__getstate__",
                "__setstate__",
                "__reduce__",
                "__reduce_ex__",
            ):
                if has_str:
                    return
                has_pickle_dunder = True
            elif isinstance(fun, ast.FunctionDef) and fun.name == "__str__":
                if has_pickle_dunder:
                    return
                has_str = True

        # iterate body nodes looking for __init__
        for fun in node.body:
            if not (isinstance(fun, ast.FunctionDef) and fun.name == "__init__"):
                continue
            if any(
                (isinstance(decorator, ast.Name) and decorator.id == "overload")
                or (
                    isinstance(decorator, ast.Attribute)
                    and decorator.attr == "overload"
                )
                for decorator in fun.decorator_list
            ):
                continue
            if fun.args.kwonlyargs or fun.args.kwarg:
                # kwargs cannot be passed to super().__init__()
                self.add_error("B042", fun)
                return
            # -1 to exclude the `self` argument
            expected_arg_count = (
                len(fun.args.posonlyargs)
                + len(fun.args.args)
                - 1
                + (1 if fun.args.vararg else 0)
            )
            if expected_arg_count == 0:
                # no arguments, don't need to call super().__init__()
                return

            # Look for super().__init__()
            # We only check top-level nodes instead of doing an `ast.walk`.
            # Small risk of false alarm if the user does something weird.
            for b in fun.body:
                if (
                    isinstance(b, ast.Expr)
                    and isinstance(b.value, ast.Call)
                    and isinstance(b.value.func, ast.Attribute)
                    and isinstance(b.value.func.value, ast.Call)
                    and isinstance(b.value.func.value.func, ast.Name)
                    and b.value.func.value.func.id == "super"
                    and b.value.func.attr == "__init__"
                ):
                    if len(b.value.args) != expected_arg_count:
                        self.add_error("B042", fun)
                    elif fun.args.vararg:
                        for arg in b.value.args:
                            if isinstance(arg, ast.Starred):
                                return
                        else:
                            # no Starred argument despite vararg
                            self.add_error("B042", fun)
                    return
            else:
                # no super().__init__() found
                self.add_error("B042", fun)
                return
        # no `def __init__` found, which is fine

    def check_for_b045(self, node: ast.For | ast.AsyncFor) -> None:
        # The stack belongs to the current scope: nested functions, classes,
        # and comprehensions cannot overwrite an enclosing loop's binding.
        outer_names = set()
        for ancestor, child in zip(self.node_stack, self.node_stack[1:], strict=False):
            if isinstance(ancestor, (ast.For, ast.AsyncFor)) and child in ancestor.body:
                outer_names.update(names_from_assignments(ancestor.target))
        for name in names_from_assignments(node.target):
            if name in outer_names and not name.startswith("_"):
                self.add_error("B045", node.target, name)

    def check_for_b044(self, node: ast.Assert) -> None:
        test = node.test
        if isinstance(test, ast.GeneratorExp):
            self.add_error("B044", node, "generator_expression", "`all()`")
        elif isinstance(test, ast.Lambda):
            self.add_error("B044", node, "lambda", "to call it")
        elif kind := _truthy_constant_kind(test):
            self.add_error("B044", node, kind, "the condition")
        elif isinstance(test, ast.JoinedStr):
            if any(
                isinstance(part, ast.Constant) and part.value for part in test.values
            ):
                self.add_error("B044", node, "f-string", "the condition")
        elif isinstance(test, (ast.List, ast.Set)):
            # a starred element like `[*a]` could be empty
            if any(not isinstance(elt, ast.Starred) for elt in test.elts):
                kind = f"non-empty {type(test).__name__.lower()}"
                self.add_error("B044", node, kind, "the condition")
        elif isinstance(test, ast.Dict):
            # a `None` key is a `**a` unpacking, which could be empty
            if any(key is not None for key in test.keys):
                self.add_error("B044", node, "non-empty dict", "the condition")
        # non-empty tuples are already reported by pyflakes (F631)

    def check_for_b046(self, node: ast.Call) -> None:
        if not (
            isinstance(node.func, ast.Attribute)
            and node.func.attr == "fromkeys"
            and ".".join(compose_call_path(node.func.value)) in B046_DICT_TYPES
        ):
            return

        if len(node.args) == 2:
            value = node.args[1]
        elif len(node.args) == 1:
            # OrderedDict.fromkeys() also takes the value as a keyword argument
            value = next((kw.value for kw in node.keywords if kw.arg == "value"), None)
        else:
            return

        if isinstance(
            value,
            (ast.List, ast.Dict, ast.Set, ast.ListComp, ast.DictComp, ast.SetComp),
        ) or (
            isinstance(value, ast.Call)
            and ".".join(compose_call_path(value.func)) in B006_MUTABLE_CALLS
        ):
            self.add_error("B046", value)

    def check_for_b909(self, node: ast.For) -> None:
        iterable = node.iter
        # the loop variable holding a key of the iterable, if there is one
        target: ast.expr | None = node.target
        # `d.keys()`, `d.values()` and `d.items()` are views of `d`, not copies
        if (
            isinstance(iterable, ast.Call)
            and isinstance(iterable.func, ast.Attribute)
            and iterable.func.attr in ("keys", "values", "items")
            and not iterable.args
            and not iterable.keywords
        ):
            if (
                iterable.func.attr == "items"
                and isinstance(target, (ast.Tuple, ast.List))
                and len(target.elts) == 2
            ):
                target = target.elts[0]
            elif iterable.func.attr != "keys":
                # a value or a (key, value) pair, so `d[target] = ...` can add a key
                target = None
            iterable = iterable.func.value

        if isinstance(iterable, ast.Name):
            name = _to_name_str(iterable)
            key = _to_name_str(target)
        elif isinstance(iterable, ast.Attribute):
            name = _to_name_str(iterable)
            key = _to_name_str(target)
        else:
            return

        if name is None or (key is None and target is not None):
            return

        checker = B909Checker(name, key)
        checker.visit(node.body)
        for mutation in itertools.chain.from_iterable(
            m for m in checker.mutations.values()
        ):
            self.add_error("B909", mutation)

    def check_for_b910(self, node: ast.Call) -> None:
        if (
            isinstance(node.func, ast.Name)
            and node.func.id == "defaultdict"
            and len(node.args) > 0
            and isinstance(node.args[0], ast.Name)
            and node.args[0].id == "int"
        ):
            self.add_error("B910", node)

    def check_for_b911(self, node: ast.Call) -> None:
        if (
            (isinstance(node.func, ast.Name) and node.func.id == "batched")
            or (
                isinstance(node.func, ast.Attribute)
                and node.func.attr == "batched"
                and isinstance(node.func.value, ast.Name)
                and node.func.value.id == "itertools"
            )
        ) and not any(kw.arg == "strict" for kw in node.keywords):
            self.add_error("B911", node)


def compose_call_path(node: ast.expr) -> Iterator[str]:
    if isinstance(node, ast.Attribute):
        yield from compose_call_path(node.value)
        yield node.attr
    elif isinstance(node, ast.Call):
        yield from compose_call_path(node.func)
    elif isinstance(node, ast.Name):
        yield node.id


def is_name(node: ast.expr, name: str) -> bool:
    if "." not in name:
        return isinstance(node, ast.Name) and node.id == name
    else:
        if not isinstance(node, ast.Attribute):
            return False
        rest, attr = name.rsplit(".", maxsplit=1)
        return node.attr == attr and is_name(node.value, rest)


class B909Checker(ast.NodeVisitor):
    # https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types
    MUTATING_FUNCTIONS = (
        "append",
        "sort",
        "reverse",
        "remove",
        "clear",
        "extend",
        "insert",
        "pop",
        "popitem",
        "setdefault",
        "update",
        "intersection_update",
        "difference_update",
        "symmetric_difference_update",
        "add",
        "discard",
    )

    def __init__(self, name: str, key: str | None) -> None:
        self.name = name
        # assigning to `name[key]` doesn't change its size; with no key loop
        # variable, every subscript assignment is reported
        self.key = key
        self.mutations: dict[
            int, list[ast.Assign | ast.AugAssign | ast.Delete | ast.Call]
        ] = defaultdict(list)
        self._conditional_block = 0

    def visit_Assign(self, node: ast.Assign) -> None:
        for target in node.targets:
            if (
                isinstance(target, ast.Subscript)
                and _to_name_str(target.value) == self.name
                and (self.key is None or _to_name_str(target.slice) != self.key)
            ):
                self.mutations[self._conditional_block].append(node)
        self.generic_visit(node)

    def visit_AugAssign(self, node: ast.AugAssign) -> None:
        if _to_name_str(node.target) == self.name:
            self.mutations[self._conditional_block].append(node)
        self.generic_visit(node)

    def visit_Delete(self, node: ast.Delete) -> None:
        for target in node.targets:
            if isinstance(target, ast.Subscript):
                name = _to_name_str(target.value)
            elif isinstance(target, (ast.Attribute, ast.Name)):
                name = ""  # ignore "del foo"
            else:
                name = ""  # fallback
                self.generic_visit(target)

            if name == self.name:
                self.mutations[self._conditional_block].append(node)

    def visit_Call(self, node: ast.Call) -> None:
        if isinstance(node.func, ast.Attribute):
            name = _to_name_str(node.func.value)
            function_object = name
            function_name = node.func.attr

            if (
                function_object == self.name
                and function_name in self.MUTATING_FUNCTIONS
            ):
                self.mutations[self._conditional_block].append(node)

        self.generic_visit(node)

    def visit_If(self, node: ast.If) -> None:
        self.visit(node.test)
        self._conditional_block += 1
        self.visit(node.body)
        self._conditional_block += 1
        self.visit(node.orelse)
        self._conditional_block += 1

    def visit(self, node: ast.AST | list[ast.stmt]) -> ast.AST | list[ast.stmt] | None:
        """Like super-visit but supports iteration over lists."""
        if not isinstance(node, list):
            return super().visit(node)

        for elem in node:
            if isinstance(elem, ast.Break):
                self.mutations[self._conditional_block].clear()
            self.visit(elem)
        return node


def _is_useless_operation(node: ast.expr) -> bool:
    """Whether a unary or arithmetic operation, used as a statement, does nothing.

    Every binary operator in it has to be arithmetic, and no operand may call,
    await, yield or assign: `f() + 1` still calls `f`. This also checks what a
    generator expression or a lambda evaluates right away.
    """
    for child in ast.walk(node):
        if isinstance(child, ast.BinOp) and not isinstance(
            child.op, B018_ARITHMETIC_OPERATORS
        ):
            return False
        if isinstance(
            child, (ast.Call, ast.Await, ast.Yield, ast.YieldFrom, ast.NamedExpr)
        ):
            return False
    return True


def _lambda_defaults(node: ast.Lambda) -> list[ast.expr]:
    """The defaults of a lambda, which are evaluated when it is created."""
    return [d for d in node.args.defaults + node.args.kw_defaults if d is not None]


def _dotted_name(node: ast.AST) -> str | None:
    """Return `"self.a.b"` for an attribute chain rooted in a name, else None."""
    parts = []
    while isinstance(node, ast.Attribute):
        parts.append(node.attr)
        node = node.value
    if not isinstance(node, ast.Name):
        return None
    parts.append(node.id)
    return ".".join(reversed(parts))


def _dotted_targets(target: ast.AST) -> Iterator[tuple[str, ast.Attribute]]:
    """Yield the attribute paths a `for` statement rebinds on each iteration."""
    if isinstance(target, (ast.Tuple, ast.List)):
        for element in target.elts:
            yield from _dotted_targets(element)
    elif isinstance(target, ast.Starred):
        yield from _dotted_targets(target.value)
    elif isinstance(target, ast.Attribute):
        name = _dotted_name(target)
        if name is not None:
            yield name, target


@attr.s
class NameFinder(ast.NodeVisitor):
    """Finds a name within a tree of nodes.

    After `.visit(node)` is called, `found` is a dict with all name nodes inside,
    key is name string, value is the node (useful for location purposes).
    """

    names: Dict[str, List[ast.Name]] = attr.ib(factory=dict)

    def visit_Name(  # noqa: B906 # names don't contain other names
        self, node: ast.Name
    ) -> None:
        self.names.setdefault(node.id, []).append(node)

    def visit(self, node):
        """Like super-visit but supports iteration over lists."""
        if not isinstance(node, list):
            return super().visit(node)

        for elem in node:
            super().visit(elem)
        return node


class B913UsageFinder(NameFinder):
    """Find loads of ``_`` that refer to a surrounding loop target."""

    @staticmethod
    def _binds_underscore(node: ast.expr) -> bool:
        return "_" in names_from_assignments(node)

    def visit_Name(self, node: ast.Name) -> None:  # noqa: B906
        if node.id == "_" and isinstance(node.ctx, ast.Load):
            super().visit_Name(node)

    def _visit_comprehension(
        self,
        generators: list[ast.comprehension],
        values: list[ast.expr],
    ) -> None:
        shadowed = False
        for index, generator in enumerate(generators):
            if index == 0 or not shadowed:
                self.visit(generator.iter)
            if not shadowed:
                self.visit(generator.target)
            if self._binds_underscore(generator.target):
                shadowed = True
            if not shadowed:
                self.visit(generator.ifs)
        if not shadowed:
            self.visit(values)

    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
        self._visit_comprehension(node.generators, [node.elt])

    def visit_ListComp(self, node: ast.ListComp) -> None:
        self._visit_comprehension(node.generators, [node.elt])

    def visit_SetComp(self, node: ast.SetComp) -> None:
        self._visit_comprehension(node.generators, [node.elt])

    def visit_DictComp(self, node: ast.DictComp) -> None:
        # `node.value` is None for `{**d for d in ...}` on Python 3.15+.
        values = [node.key] if node.value is None else [node.key, node.value]
        self._visit_comprehension(node.generators, values)

    def visit_AugAssign(self, node: ast.AugAssign) -> None:
        self.visit(node.value)
        if isinstance(node.target, ast.Name) and node.target.id == "_":
            self.names.setdefault("_", []).append(node.target)
        else:
            self.visit(node.target)


@attr.s
class NamedExprFinder(ast.NodeVisitor):
    """Finds names defined through an ast.NamedExpr.

    After `.visit(node)` is called, `found` is a dict with all name nodes inside,
    key is name string, value is the node (useful for location purposes).
    """

    names: Dict[str, List[ast.Name]] = attr.ib(factory=dict)

    def visit_NamedExpr(self, node: ast.NamedExpr) -> None:
        self.names.setdefault(node.target.id, []).append(node.target)
        self.generic_visit(node)

    def visit(self, node):
        """Like super-visit but supports iteration over lists."""
        if not isinstance(node, list):
            return super().visit(node)

        for elem in node:
            super().visit(elem)
        return node


class B008NamedExprFinder(NamedExprFinder):
    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
        self.visit(node.generators[0].iter)

    def visit_Lambda(self, node: ast.Lambda) -> None:  # noqa: B906
        self.visit(node.args.defaults)
        self.visit(
            [default for default in node.args.kw_defaults if default is not None]
        )


class FunctionDefDefaultsVisitor(ast.NodeVisitor):
    """Used by B006, B008, and B039. B039 is essentially B006+B008 but for ContextVar."""

    def __init__(
        self,
        error_code_calls: "Error",  # B006 or B039
        error_code_literals: "Error",  # B008 or B039
        b008_b039_extend_immutable_calls: set[str] | None = None,
        imported_names: dict[str, str | None] | None = None,
    ) -> None:
        self.b008_b039_extend_immutable_calls = (
            b008_b039_extend_immutable_calls or set()
        )
        self.error_code_calls = error_code_calls
        self.error_code_literals = error_code_literals
        self.imported_names = imported_names or {}
        for node in B006_MUTABLE_LITERALS + B006_MUTABLE_COMPREHENSIONS:
            setattr(self, f"visit_{node}", self.visit_mutable_literal_or_comprehension)
        self.errors: list[error] = []
        self.arg_depth = 0
        super().__init__()

    def visit_mutable_literal_or_comprehension(self, node: ast.expr) -> None:
        # Flag B006 iff mutable literal/comprehension is not nested.
        # We only flag these at the top level of the expression as we
        # cannot easily guarantee that nested mutable structures are not
        # made immutable by outer operations, so we prefer no false positives.
        # e.g.
        # >>> def this_is_fine(a=frozenset({"a", "b", "c"})): ...
        #
        # >>> def this_is_not_fine_but_hard_to_detect(a=(lambda x: x)([1, 2, 3]))
        #
        # We do still search for cases of B008 within mutable structures though.
        if self.arg_depth == 1:
            self.errors.append(self.error_code_calls(node.lineno, node.col_offset))
        # Check for nested functions.
        self.generic_visit(node)

    def visit_Call(self, node: ast.Call) -> None:
        call_path = ".".join(compose_call_path(node.func))
        if call_path in B006_MUTABLE_CALLS:
            self.errors.append(self.error_code_calls(node.lineno, node.col_offset))
            self.generic_visit(node)
            return

        if call_path in B008_IMMUTABLE_CALLS:
            self.generic_visit(node)
            return

        head, separator, tail = call_path.partition(".")
        if head not in self.imported_names:
            extended_call_paths = {call_path}
        elif (qualified_name := self.imported_names[head]) is None:
            extended_call_paths = set()
        else:
            resolved_call_path = qualified_name
            if separator:
                resolved_call_path = f"{resolved_call_path}.{tail}"
            extended_call_paths = {call_path, resolved_call_path}

        if extended_call_paths & self.b008_b039_extend_immutable_calls:
            self.generic_visit(node)
            return

        # Check if function call is actually a float infinity/NaN literal
        if call_path == "float" and len(node.args) == 1:
            try:
                value = float(ast.literal_eval(node.args[0]))
            except Exception:
                pass
            else:
                if math.isfinite(value):
                    self.errors.append(
                        self.error_code_literals(node.lineno, node.col_offset)
                    )
        else:
            self.errors.append(self.error_code_literals(node.lineno, node.col_offset))

        # Check for nested functions.
        self.generic_visit(node)

    def visit_NamedExpr(self, node: ast.NamedExpr) -> None:
        if isinstance(node.target, ast.Name) and node.target.id in self.imported_names:
            self.imported_names[node.target.id] = None
        self.generic_visit(node)

    def visit_Lambda(self, node) -> None:  # noqa: B906
        self.visit(node.args.defaults)
        self.visit(
            [default for default in node.args.kw_defaults if default is not None]
        )

    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
        self.visit(node.generators[0].iter)

    def visit(self, node) -> None:
        """Like super-visit but supports iteration over lists."""
        self.arg_depth += 1
        if isinstance(node, list):
            for elem in node:
                if elem is not None:
                    super().visit(elem)
        else:
            super().visit(node)
        self.arg_depth -= 1


class B020NameFinder(NameFinder):
    """Ignore names defined within the local scope of a comprehension."""

    def visit_GeneratorExp(self, node) -> None:
        self.visit(node.generators)

    def visit_ListComp(self, node) -> None:
        self.visit(node.generators)

    def visit_DictComp(self, node) -> None:
        self.visit(node.generators)

    def visit_comprehension(self, node) -> None:
        self.visit(node.iter)

    def visit_Lambda(self, node) -> None:
        self.visit(node.body)
        for lambda_arg in node.args.args:
            self.names.pop(lambda_arg.arg, None)


@attr.s
class B020AttributeFinder(B020NameFinder):
    """Dotted attribute paths, under the scope rules B020NameFinder uses for names.

    Collecting the paths with a plain `ast.walk` would ignore lexical scope: in
    `for obj.value in [obj.value for obj in objects]` the two `obj` bindings are
    different objects, and the comprehension-local one must not be matched
    against the loop target.
    """

    paths: set[str] = attr.ib(factory=set)

    def visit_Attribute(self, node: ast.Attribute) -> None:
        path = _dotted_name(node)
        if path is not None:
            self.paths.add(path)
        self.generic_visit(node)

    def visit_Lambda(self, node: ast.Lambda) -> None:
        super().visit_Lambda(node)
        for lambda_arg in node.args.args:
            prefix = f"{lambda_arg.arg}."
            self.paths = {path for path in self.paths if not path.startswith(prefix)}


B005_METHODS = {"lstrip", "rstrip", "strip"}

# Note: these are also used by B039
B006_MUTABLE_LITERALS = ("Dict", "List", "Set")
B006_MUTABLE_COMPREHENSIONS = ("ListComp", "DictComp", "SetComp")
B006_MUTABLE_CALLS = {
    "Counter",
    "OrderedDict",
    "collections.Counter",
    "collections.OrderedDict",
    "collections.defaultdict",
    "collections.deque",
    "defaultdict",
    "deque",
    "dict",
    "list",
    "set",
}
# Note: these are also used by B039
B008_IMMUTABLE_CALLS = {
    "tuple",
    "frozenset",
    "types.MappingProxyType",
    "MappingProxyType",
    "re.compile",
    "operator.attrgetter",
    "operator.itemgetter",
    "operator.methodcaller",
    "attrgetter",
    "itemgetter",
    "methodcaller",
}
B014_REDUNDANT_EXCEPTIONS = {
    "OSError": {
        # All of these are actually aliases of OSError since Python 3.3
        "IOError",
        "EnvironmentError",
        "WindowsError",
        "mmap.error",
        "socket.error",
        "select.error",
    },
    "ValueError": {
        "binascii.Error",
    },
}
# Objects whose `__isabstractmethod__` is read-only, so `@abstractmethod` can't be
# applied on top of them (B049).
B049_DESCRIPTORS = {"property", "classmethod", "staticmethod"}
B049_PROPERTY_ACCESSORS = {"setter", "getter", "deleter"}
B019_CACHES = {
    "functools.cache",
    "functools.lru_cache",
    "cache",
    "lru_cache",
    "async_lru.alru_cache",
    "alru_cache",
}
B046_DICT_TYPES = {
    "dict",
    "OrderedDict",
    "collections.OrderedDict",
}
B902_IMPLICIT_CLASSMETHODS = {"__new__", "__init_subclass__", "__class_getitem__"}
B902_SELF = ["self"]  # it's a list because the first is preferred
B902_CLS = ["cls", "klass"]  # ditto.
B902_METACLS = ["metacls", "metaclass", "typ", "mcs"]  # ditto.


class error(NamedTuple):
    lineno: int
    col: int
    message: str
    type: type
    vars: tuple[object, ...]


class Error:
    def __init__(self, message: str):
        self.message = message

    def __call__(self, lineno: int, col: int, vars: tuple[object, ...] = ()) -> error:
        return error(lineno, col, self.message, BugBearChecker, vars=vars)


error_codes = {
    # note: bare except* is a syntax error, so B001 does not need to handle it
    "B001": Error(
        message=(
            "B001 Do not use bare `except:`, it also catches unexpected "
            "events like memory errors, interrupts, system exit, and so on.  "
            "Prefer excepting specific exceptions  If you're sure what you're "
            "doing, be explicit and write `except BaseException:`."
        )
    ),
    "B002": Error(
        message=(
            "B002 Python does not support the unary prefix increment. Writing "
            "++n is equivalent to +(+(n)), which equals n. You meant n += 1."
        )
    ),
    "B003": Error(
        message=(
            "B003 Assigning to `os.environ` doesn't clear the environment. "
            "Subprocesses are going to see outdated variables, in disagreement "
            "with the current process. Use `os.environ.clear()` or the `env=` "
            "argument to Popen."
        )
    ),
    "B004": Error(
        message=(
            "B004 Using `hasattr(x, '__call__')` to test if `x` is callable "
            "is unreliable. If `x` implements custom `__getattr__` or its "
            "`__call__` is itself not callable, you might get misleading "
            "results. Use `callable(x)` for consistent results."
        )
    ),
    "B005": Error(
        message=(
            "B005 Using .strip() with a multi-character string that repeats "
            "characters is misleading the reader. It looks like stripping a "
            "substring, but the argument is treated as a set of characters. "
            "Move your character set to a constant if this is deliberate. Use "
            ".replace(), .removeprefix(), .removesuffix(), or regular "
            "expressions to remove string fragments."
        )
    ),
    "B006": Error(
        message=(
            "B006 Do not use mutable data structures for argument defaults.  They "
            "are created during function definition time. All calls to the function "
            "reuse this one instance of that data structure, persisting changes "
            "between them."
        )
    ),
    "B007": Error(
        message=(
            "B007 Loop control variable {!r} not used within the loop body. "
            "If this is intended, start the name with an underscore."
        )
    ),
    "B008": Error(
        message=(
            "B008 Do not perform function calls in argument defaults.  The call is "
            "performed only once at function definition time. All calls to your "
            "function will reuse the result of that definition-time function call.  If "
            "this is intended, assign the function call to a module-level variable and "
            "use that variable as a default value."
        )
    ),
    "B009": Error(
        message=(
            "B009 Do not call getattr with a constant attribute value, "
            "it is not any safer than normal property access."
        )
    ),
    "B010": Error(
        message=(
            "B010 Do not call setattr with a constant attribute value, "
            "it is not any safer than normal property access."
        )
    ),
    "B011": Error(
        message=(
            "B011 Do not call assert False since python -O removes these calls. "
            "Instead callers should raise AssertionError()."
        )
    ),
    "B012": Error(
        message=(
            "B012 return/continue/break inside finally blocks cause exceptions "
            "to be silenced. Exceptions should be silenced in except{0} blocks. Control "
            "statements can be moved outside the finally block."
        )
    ),
    "B013": Error(
        message=(
            "B013 A length-one tuple literal is redundant.  "
            "Write `except{1} {0}:` instead of `except{1} ({0},):`."
        )
    ),
    "B014": Error(
        message=(
            "B014 Redundant exception types in `except{3} ({0}){1}:`.  "
            "Write `except{3} {2}{1}:`, which catches exactly the same exceptions."
        )
    ),
    "B015": Error(
        message=(
            "B015 Result of comparison is not used. This line doesn't do "
            "anything. Did you intend to prepend it with assert?"
        )
    ),
    "B016": Error(
        message=(
            "B016 Cannot raise a literal. Did you intend to return it or raise "
            "an Exception?"
        )
    ),
    "B017": Error(
        message=(
            "B017 `assertRaises(Exception)` and `pytest.raises(Exception)` should "
            "be considered evil. They can lead to your test passing even if the "
            "code being tested is never executed due to a typo. Assert for a more "
            "specific exception (builtin or custom), or use `assertRaisesRegex` "
            "(if using `assertRaises`), or add the `match` keyword argument (if "
            "using `pytest.raises`), or use the context manager form with a target."
        )
    ),
    "B018": Error(
        message=(
            "B018 Found useless {} expression. Consider either assigning it to a "
            "variable or removing it."
        )
    ),
    "B019": Error(
        message=(
            "B019 Use of `functools.lru_cache`, `functools.cache` or "
            "`async_lru.alru_cache` on methods can lead to memory leaks. The cache "
            "may retain instance references, preventing garbage collection."
        )
    ),
    "B020": Error(
        message=(
            "B020 Found for loop that reassigns the iterable it is iterating "
            + "with each iterable value."
        )
    ),
    "B021": Error(
        message=(
            "B021 f-string used as docstring. "
            "This will be interpreted by python as a joined string rather than a docstring."
        )
    ),
    "B022": Error(
        message=(
            "B022 No arguments passed to `contextlib.suppress`. "
            "No exceptions will be suppressed and therefore this "
            "context manager is redundant."
        )
    ),
    "B023": Error(message="B023 Function definition does not bind loop variable {!r}."),
    "B024": Error(
        message=(
            "B024 {} is an abstract base class, but none of the methods it defines are"
            " abstract. This is not necessarily an error, but you might have forgotten to"
            " add the @abstractmethod decorator, potentially in conjunction with"
            " @classmethod, @property and/or @staticmethod."
        )
    ),
    "B025": Error(
        message=(
            "B025 Exception `{0}` has been caught multiple times. Only the first"
            " except{1} {0} will be considered and all other except{1} {0} catches can be"
            " safely removed."
        )
    ),
    "B026": Error(
        message=(
            "B026 Star-arg unpacking after a keyword argument is strongly discouraged, "
            "because it only works when the keyword parameter is declared after all "
            "parameters supplied by the unpacked sequence, and this change of ordering can "
            "surprise and mislead readers."
        )
    ),
    "B027": Error(
        message=(
            "B027 {} is an empty method in an abstract base class, but has no abstract"
            " decorator. Consider adding @abstractmethod."
        )
    ),
    "B028": Error(
        message=(
            "B028 No explicit stacklevel argument found. The warn method from the"
            " warnings module uses a stacklevel of 1 by default. This will only show a"
            " stack trace for the line on which the warn method is called."
            " It is therefore recommended to use a stacklevel of 2 or"
            " greater to provide more information to the user."
        )
    ),
    "B029": Error(
        message=(
            "B029 Using `except{0} ():` with an empty tuple does not handle/catch "
            "anything. Add exceptions to handle."
        )
    ),
    "B030": Error(
        message="B030 Except handlers should only be names of exception classes"
    ),
    "B031": Error(
        message=(
            "B031 Using the generator returned from `itertools.groupby()` more than once"
            " will do nothing on the second usage. Save the result to a list, if the"
            " result is needed multiple times."
        )
    ),
    "B032": Error(
        message=(
            "B032 Possible unintentional type annotation (using `:`). Did you mean to"
            " assign (using `=`)?"
        )
    ),
    "B033": Error(
        message=(
            "B033 Set should not contain duplicate item {}. Duplicate items will be"
            " replaced with a single item at runtime."
        )
    ),
    "B034": Error(
        message=(
            "B034 {} should pass `{}` and `flags` as keyword arguments to avoid confusion"
            " due to unintuitive argument positions."
        )
    ),
    "B035": Error(message="B035 Static key in dict comprehension {!r}."),
    "B036": Error(
        message="B036 Don't except `BaseException` unless you plan to re-raise it."
    ),
    "B037": Error(
        message="B037 Class `__init__` methods must not return or yield any values."
    ),
    "B039": Error(
        message=(
            "B039 ContextVar with mutable literal or function call as default. "
            "This is only evaluated once, and all subsequent calls to `.get()` "
            "will return the same instance of the default."
        )
    ),
    "B040": Error(
        message="B040 Exception with added note not used. Did you forget to raise it?"
    ),
    "B041": Error(message=("B041 Repeated key-value pair in dictionary literal.")),
    "B042": Error(
        message=(
            "B042 Exception class with `__init__` should pass all args to "
            "`super().__init__()` to work in edge cases of `pickle` and `copy.copy()`. "
            "It should also not take any kwargs."
        )
    ),
    "B043": Error(
        message=(
            "B043 Do not call delattr with a constant attribute value, "
            "it is not any safer than normal property access."
        )
    ),
    "B044": Error(message="B044 `assert <{0}>` is always true. Did you forget {1}?"),
    "B045": Error(
        message=(
            "B045 Loop control variable {} overrides a variable in an enclosing loop. "
            "Use a different name for the inner loop variable."
        )
    ),
    "B046": Error(
        message=(
            "B046 Mutable value passed to `dict.fromkeys()`. The same object is "
            "shared by every key, so changing it for one key changes it for all of "
            "them. Use a dict comprehension instead, e.g. `{{key: [] for key in keys}}`."
        )
    ),
    "B047": Error(
        message=(
            "B047 `{0}` is never caught by this handler, since the earlier "
            "`except{2} {1}` already catches it. Reorder the handlers or remove "
            "the unreachable one."
        )
    ),
    "B049": Error(
        message=(
            "B049 `@abstractmethod` is applied to the result of `@{0}`, which raises "
            "`AttributeError`. `@abstractmethod` must be the innermost decorator, "
            "listed after `@{0}`."
        )
    ),
    # Warnings disabled by default.
    "B901": Error(
        message=(
            "B901 Using `yield` together with `return x`. Use native "
            "`async def` coroutines or put a `# noqa` comment on this "
            "line if this was intentional."
        )
    ),
    "B902": Error(
        message=(
            "B902 Invalid first argument {} used for {} method. Use the "
            "canonical first argument name in methods, i.e. {}."
        )
    ),
    "B903": Error(
        message=(
            "B903 Data class should either be immutable or use __slots__ to "
            "save memory. Use collections.namedtuple to generate an immutable "
            "class, or enumerate the attributes in a __slots__ declaration in "
            "the class to leave attributes mutable."
        )
    ),
    "B904": Error(
        message=(
            "B904 Within an `except{0}` clause, raise exceptions with `raise ... from err` or"
            " `raise ... from None` to distinguish them from errors in exception handling. "
            " See https://docs.python.org/3/tutorial/errors.html#exception-chaining for"
            " details."
        )
    ),
    "B905": Error(message="B905 `zip()` without an explicit `strict=` parameter."),
    "B906": Error(
        message=(
            "B906 `visit_` function with no further calls to a visit function, which might"
            " prevent the `ast` visitor from properly visiting all nodes."
            " Consider adding a call to `self.generic_visit(node)`."
        )
    ),
    "B907": Error(
        message=(
            "B907 {!r} is manually surrounded by quotes, consider using the `!r` conversion"
            " flag."
        )
    ),
    "B908": Error(
        message=(
            "B908 assertRaises-type context should not contain more than one top-level"
            " statement."
        )
    ),
    "B909": Error(
        message=(
            "B909 editing a loop's mutable iterable often leads to unexpected results/bugs"
        )
    ),
    "B910": Error(
        message="B910 Use Counter() instead of defaultdict(int) to avoid excessive memory use"
    ),
    "B911": Error(
        message="B911 `itertools.batched()` without an explicit `strict=` parameter."
    ),
    "B912": Error(message="B912 `map()` without an explicit `strict=` parameter."),
    "B913": Error(
        message=(
            "B913 `zip()` values are discarded by unused `_` targets. "
            "If those iterables intentionally control loop length, use named "
            "variables; otherwise remove the arguments and targets."
        )
    ),
    "B950": Error(message="B950 line too long ({} > {} characters)"),
}


disabled_by_default = [
    "B901",
    "B902",
    "B903",
    "B904",
    "B905",
    "B906",
    "B908",
    "B909",
    "B910",
    "B911",
    "B912",
    "B913",
    "B950",
]