python-constricter 0.4.1__cp313-cp313-win32.whl

constricter/fix/values/targets.py

@@ -0,0 +1,419 @@
+# SPDX-License-Identifier: MIT
+"""Types split over what a loop or an unpacking binds: a container's elements, a tuple's parts."""
+
+import ast
+import re
+from collections import Counter
+from collections.abc import Iterator, Mapping, Sequence
+from types import MappingProxyType
+from typing import Final, cast
+
+from constricter.fix.core.imports import rebound_names
+from constricter.fix.core.known import Inference
+from constricter.rules.annotations import node_name
+from constricter.rules.declarations import defined_type_vars
+from constricter.rules.quoted import written
+from constricter.rules.syntax import top_level
+from constricter.rules.walked import classes
+
+# Builtins that iterate over their (first) argument's elements, one to one.
+SAME_ELEMENTS: Final = frozenset({"reversed", "sorted"})
+DICT_VIEWS: Final = frozenset({"keys", "values", "items"})
+# What iterating each builtin that takes no type argument gives.
+_ELEMENTS: Final = {"str": "str", "bytes": "int", "bytearray": "int", "range": "int"}
+# Containers whose one type parameter is their elements'.
+# And the builtin iterators', what they yield (`zip[tuple[str, int]]`); `enumerate[T]` counts its `T`s.
+_ONE_ELEMENT_TYPE: Final = frozenset(
+    {"list", "List", "set", "Set", "frozenset", "FrozenSet", "zip", "map", "filter", "reversed"},
+)
+# What yields its first type parameter, however it's named (`Iterator[T]`, `abc.Generator[T, None, None]`).
+_YIELDING: Final = frozenset({"Iterable", "Iterator", "Generator"})
+# Mappings of keys to values, however they're named (`dict[K, V]`, `abc.Mapping[K, V]`).
+_MAPPINGS: Final = frozenset(
+    {
+        "dict",
+        "Dict",
+        "Mapping",
+        "MutableMapping",
+        "OrderedDict",
+        "defaultdict",
+        "DefaultDict",
+        "MappingProxyType",
+        "ChainMap",
+    },
+)
+RANGE: Final = "range"
+ENUMERATE: Final = "enumerate"
+ZIP: Final = "zip"
+MAP: Final = "map"  # yields what its function returns, whatever it's mapped over
+ITER: Final = "iter"  # yields its one argument's elements (with a sentinel, what its callable returns)
+FILTER: Final = "filter"  # yields its second argument's elements its predicate keeps
+ITERATORS: Final = frozenset({RANGE, ENUMERATE, ZIP, MAP, ITER, FILTER, *SAME_ELEMENTS})
+# The keywords each of `ITERATORS` takes that don't change what it yields (`sorted`'s only its order).
+_ITERATOR_KEYWORDS: Final = {
+    ENUMERATE: frozenset({"start"}),
+    ZIP: frozenset({"strict"}),
+    "sorted": frozenset({"key", "reverse"}),
+}
+# `tuple[T, ...]`'s two parts: the element type and the ellipsis.
+_ANY_LENGTH: Final = 2
+_NAMED_TUPLE: Final = ["NamedTuple"]  # the one base of a class whose annotated variables are its fields
+_PAIR: Final = 2  # a functional `NamedTuple`'s field: its name and type
+_TUPLES: Final = frozenset({"tuple", "Tuple"})
+_UNIONS: Final = frozenset({"Union", "Optional"})
+_UNION: Final = re.compile(r"\||\b(?:Union|Optional)\[")  # in a quoted alias
+_TYPE_ALIAS: Final = "TypeAlias"
+_NO_TUPLES: Final[Mapping[str, str]] = MappingProxyType({})
+
+
+def named_tuples(tree: ast.Module) -> dict[str, str]:
+    """Map each tuple type the module names to the tuple unpacking one gives.
+
+    A class defined once, directly under `NamedTuple` alone, with two fields or more: its fields'
+    types; or under a `NamedTuple("P", [("x", int), ...])` call alone, the call's. A type alias of a
+    tuple (`Pair: TypeAlias = tuple[int, str]`, `Pair = tuple[int, str]`, `type Pair = tuple[int,
+    str]`) at the module's top level, bound once there and naming none of its type variables: the
+    tuple.
+
+    Returns:
+      Each one's name, and the tuple's type as text.
+
+    """
+    found: dict[str, str] = _aliased_tuples(tree)
+    nodes: Sequence[ast.ClassDef] = classes(tree)
+    counts: Counter[str] = Counter(node.name for node in nodes)
+    node: ast.ClassDef
+    for node in nodes:
+        fields: list[str] | None = None
+        if counts[node.name] == 1 and [node_name(base) for base in node.bases] == _NAMED_TUPLE:
+            fields = [
+                written(stmt.annotation)
+                for stmt in node.body
+                if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name)
+            ]
+        elif counts[node.name] == 1 and len(node.bases) == 1:
+            fields = _called_fields(node.bases[0])
+        if fields is not None and len(fields) > 1:
+            found[node.name] = f"tuple[{', '.join(fields)}]"
+    return found
+
+
+def _called_fields(base: ast.expr) -> list[str] | None:
+    """Read the fields of a `NamedTuple("P", [("x", int), ("y", str)])` call as a base.
+
+    Returns:
+      Their types as written, in order; `None` for any other base, a `namedtuple(...)` call's
+      untyped fields included.
+
+    """
+    func: ast.expr
+    elts: list[ast.expr]
+    match base:
+        case ast.Call(
+            func=func,
+            args=[ast.Constant(value=str()), ast.List(elts=elts) | ast.Tuple(elts=elts)],
+            keywords=[],
+        ) if node_name(func) == _NAMED_TUPLE[0]:
+            pairs: list[list[ast.expr]] = [
+                list(elt.elts) for elt in elts if isinstance(elt, ast.Tuple) and len(elt.elts) == _PAIR
+            ]
+            if len(pairs) != len(elts) or any(not isinstance(name, ast.Constant) for name, _ in pairs):
+                return None
+            return [written(annotation) for _, annotation in pairs]
+        case _:
+            return None
+
+
+def _aliased_tuples(tree: ast.Module) -> dict[str, str]:
+    """Find the module's type aliases of a tuple (see `named_tuples`).
+
+    Returns:
+      Each one's name, and the tuple's type as text.
+
+    """
+    type_vars: frozenset[str] = defined_type_vars(tree)
+    return {
+        name: written(value)
+        for name, value in _aliases(tree)
+        if isinstance(value, ast.Subscript)
+        and node_name(value.value) in _TUPLES
+        and not type_vars & {node.id for node in ast.walk(value) if isinstance(node, ast.Name)}
+    }
+
+
+def aliased_unions(tree: ast.Module) -> dict[str, str]:
+    """Find the module's type aliases of a union: `Key = int | str`, `Key: TypeAlias = Union[int, str]`.
+
+    At its top level, bound once there. A value of one is narrowed as a union is, by a test or an
+    assignment, which its alias's name alone doesn't say.
+
+    Returns:
+      Each one's name, and the union as text.
+
+    """
+    return {
+        name: written(value)
+        for name, value in _aliases(tree)
+        if (isinstance(value, ast.BinOp) and isinstance(value.op, ast.BitOr))
+        or (isinstance(value, ast.Subscript) and node_name(value.value) in _UNIONS)
+        or (isinstance(value, ast.Constant) and isinstance(value.value, str) and _UNION.search(value.value))
+    }
+
+
+def _aliases(tree: ast.Module) -> list[tuple[str, ast.expr]]:
+    """Find what may be the module's type aliases: each name its top level binds once, as `_alias` reads it.
+
+    Returns:
+      Each one's name and value.
+
+    """
+    rebound: frozenset[str] = frozenset(rebound_names(tree))
+    read: Iterator[tuple[str, ast.expr] | None] = (_alias(stmt) for stmt in top_level(tree.body))
+    return [aliased for aliased in read if aliased is not None and aliased[0] not in rebound]
+
+
+def _alias(stmt: ast.stmt) -> tuple[str, ast.expr] | None:
+    """Read the name and value a statement binds as a type alias, if it may be one.
+
+    Returns:
+      Them: an assignment's to one name (annotated `TypeAlias`, or not at all), or a `type`
+      statement's; `None` for any other statement.
+
+    """
+    name: str
+    value: ast.expr
+    annotation: ast.expr
+    match stmt:
+        case ast.AnnAssign(target=ast.Name(id=name), annotation=annotation, value=ast.expr() as value) if (
+            node_name(annotation) == _TYPE_ALIAS
+        ):
+            return name, value
+        case ast.Assign(targets=[ast.Name(id=name)], value=value):
+            return name, value
+        case _ if type(stmt).__name__ == _TYPE_ALIAS:  # Python 3.12+'s `type X = ...`
+            return cast("ast.Name", getattr(stmt, "name", None)).id, cast(
+                "ast.expr",
+                getattr(stmt, "value", None),
+            )
+        case _:
+            return None
+
+
+def sole(argument: ast.expr) -> ast.expr:
+    """Read a one-parameter generic's type argument, written with a trailing comma or not.
+
+    `list[int,]` (as a formatter writes a long one split over lines) subscripts `list` with the
+    tuple `(int,)`; its element is still `int`.
+
+    Returns:
+      The type argument.
+
+    """
+    element: ast.expr
+    match argument:
+        case ast.Tuple(elts=[element]):
+            return element
+        case _:
+            return argument
+
+
+def element_type(container: str, reason: str, kinds: frozenset[str]) -> Inference | None:
+    """Infer the elements of a value typed `container`.
+
+    Returns:
+      Them, or `None` for a type whose elements aren't known from it alone.
+
+    """
+    # `container` is always `ast.unparse`'s own output, so it's always valid Python to parse back.
+    root: ast.expr = ast.parse(container, mode="eval").body
+    name: str
+    head: ast.expr
+    item: ast.expr
+    key: ast.expr
+    others: list[ast.expr]
+    match root:
+        case ast.Name(id=name) if name in _ELEMENTS:
+            return Inference(_ELEMENTS[name], reason, kinds)
+        case ast.Subscript(value=ast.Name(id=name), slice=item) if (
+            name in _ONE_ELEMENT_TYPE or name == ENUMERATE
+        ):
+            text: str = ast.unparse(sole(item))
+            return Inference(f"tuple[int, {text}]" if name == ENUMERATE else text, reason, kinds)
+        case ast.Subscript(value=head, slice=ast.Tuple(elts=[item, *_]) | item) if (
+            node_name(head) in _YIELDING
+        ):
+            return Inference(ast.unparse(item), reason, kinds)
+        case ast.Subscript(value=head, slice=ast.Tuple(elts=[key, _])) if node_name(head) in _MAPPINGS:
+            return Inference(ast.unparse(key), reason, kinds)
+        case ast.Subscript(value=ast.Name(id="tuple" | "Tuple"), slice=ast.Tuple(elts=[item, *others])) if (
+            # `tuple[T, ...]`, or one whose parts agree (`("a", "b")`): whichever it is, a `T`.
+            all(_is_ellipsis(other) or ast.unparse(other) == ast.unparse(item) for other in others)
+        ):
+            return Inference(ast.unparse(item), reason, kinds)
+        case _:
+            return None
+
+
+def dict_parts(annotation: str) -> tuple[str, str] | None:
+    """Read a `dict[K, V]`'s key and value types, or another mapping's (`Mapping[K, V]`).
+
+    Returns:
+      Them, as text, or `None` for any other annotation.
+
+    """
+    # `annotation` is always `ast.unparse`'s own output, so it's always valid Python to parse back.
+    head: ast.expr
+    key: ast.expr
+    value: ast.expr
+    match ast.parse(annotation, mode="eval").body:
+        case ast.Subscript(value=head, slice=ast.Tuple(elts=[key, value])) if node_name(head) in _MAPPINGS:
+            return ast.unparse(key), ast.unparse(value)
+        case _:
+            return None
+
+
+def counted(name: str, args: list[ast.expr]) -> list[ast.expr]:
+    """Pick the arguments whose elements one of `ITERATORS` yields.
+
+    `enumerate`'s first, `filter`'s second, the others' all.
+
+    Returns:
+      Them.
+
+    """
+    return args[:1] if name == ENUMERATE else args[1:] if name == FILTER else args
+
+
+def _is_ellipsis(node: ast.expr) -> bool:
+    return isinstance(node, ast.Constant) and node.value is Ellipsis
+
+
+def unpacked(
+    target: ast.expr,
+    annotation: str | None,
+    tuples: Mapping[str, str] = _NO_TUPLES,
+) -> list[tuple[ast.Name, str | None]]:
+    """Match an unpacking target's names with the parts of a value typed `annotation`.
+
+    A plain name takes the whole type; a tuple or list of targets takes a `tuple[A, B, ...]` of the
+    same length part by part, or each an element of anything else whose elements are known (a
+    `tuple[T, ...]`'s or `list[T]`'s `T`, a `str`'s `str`). A starred name takes a `list` of what's
+    left for it, if that's of one type. A shape that doesn't match gets `None`. `tuples`: the named
+    tuples the module names (see `named_tuples`), each split as its fields' tuple.
+
+    Returns:
+      Each name the target binds, with its type as text (or `None`).
+
+    """
+    elements: list[ast.expr]
+    value: ast.expr
+    match target:
+        case ast.Name():
+            return [(target, annotation)]
+        case ast.Tuple(elts=elements) | ast.List(elts=elements):
+            parts: list[str | None] = _parts(tuples.get(annotation or "", annotation), elements)
+            return [
+                pair
+                for element, part in zip(elements, parts, strict=True)
+                for pair in unpacked(element, part, tuples)
+            ]
+        case ast.Starred(value=value):
+            return unpacked(value, annotation, tuples)
+        case _:
+            return []
+
+
+def _parts(annotation: str | None, targets: Sequence[ast.expr]) -> list[str | None]:
+    """Split a value's type over the targets it's unpacked into.
+
+    Returns:
+      Each target's type as text, a starred one's a `list`; all `None` if `annotation` isn't a tuple
+      of that many, nor anything whose elements are known.
+
+    """
+    unknown: list[str | None] = [None] * len(targets)
+    if annotation is None:
+        return unknown
+    star: int | None = next(
+        (at for at, target in enumerate(targets) if isinstance(target, ast.Starred)),
+        None,
+    )
+    elements: list[ast.expr]
+    match ast.parse(annotation, mode="eval").body:
+        case ast.Subscript(value=ast.Name(id="tuple" | "Tuple"), slice=ast.Tuple(elts=elements)) if not (
+            len(elements) == _ANY_LENGTH and _is_ellipsis(elements[-1])
+        ):
+            return _fixed([ast.unparse(element) for element in elements], len(targets), star) or unknown
+        case _:
+            found: Inference | None
+            if (found := element_type(annotation, "", frozenset())) is None:
+                return unknown
+            each: list[str | None] = [found.annotation] * len(targets)
+            if star is not None:
+                each[star] = f"list[{found.annotation}]"
+            return each
+
+
+def _fixed(parts: list[str], count: int, star: int | None) -> list[str | None] | None:
+    """Split a fixed-length tuple's `parts` over `count` targets, the one at `star` starred (if any).
+
+    Returns:
+      Each target's type, the starred one's a `list` of the parts left for it where they agree
+      (else `None`); or `None` if the tuple hasn't a part for each target.
+
+    """
+    if star is None:
+        return [*parts] if len(parts) == count else None
+    if len(parts) < count - 1:
+        return None
+    after: int = len(parts) - (count - star - 1)
+    rest: set[str] = set(parts[star:after])
+    starred: str | None = f"list[{rest.pop()}]" if len(rest) == 1 else None
+    return [*parts[:star], starred, *parts[after:]]
+
+
+def iterator_call(iterable: ast.expr) -> tuple[str, list[ast.expr]] | None:
+    """Read a call to one of `ITERATORS` whose elements its positional arguments decide.
+
+    Its keywords must be ones that don't change what it yields (`enumerate`'s `start`, `zip`'s
+    `strict`, ...), and no argument starred: `zip(*rows)` yields as many parts as `rows` has.
+
+    Returns:
+      The iterator's name and its positional arguments, or `None` if `iterable` isn't such a call.
+
+    """
+    name: str
+    args: list[ast.expr]
+    keywords: list[ast.keyword]
+    match iterable:
+        case ast.Call(func=ast.Name(id=name), args=args, keywords=keywords) if (
+            args
+            and name in ITERATORS
+            and not any(isinstance(arg, ast.Starred) for arg in args)
+            and all(keyword.arg in _ITERATOR_KEYWORDS.get(name, ()) for keyword in keywords)
+        ):
+            return name, args
+        case _:
+            return None
+
+
+def iterated(iterable: ast.expr) -> list[ast.expr]:
+    """Find the values `looped` typed a loop over `iterable` from, to judge whether it guessed.
+
+    Through `enumerate` (its first argument), `zip`, `reversed`, `sorted` and a `dict` view to what
+    they iterate; a `range()` iterates nothing typed, and a `map()` yields what its function returns.
+
+    Returns:
+      Those values.
+
+    """
+    call: tuple[str, list[ast.expr]] | None
+    if (call := iterator_call(iterable)) is not None:
+        return [] if call[0] in {RANGE, MAP} else [part for arg in counted(*call) for part in iterated(arg)]
+    receiver: ast.expr
+    view: str
+    match iterable:
+        case ast.Call(func=ast.Attribute(value=receiver, attr=view), args=[]) if view in DICT_VIEWS:
+            return [receiver]
+        case _:
+            return [iterable]

constricter/fix/values/unchecked.py

@@ -0,0 +1,278 @@
+# SPDX-License-Identifier: MIT
+"""Where a guess, once declared, makes an error of what its function goes on to do with the name.
+
+A type checker takes a call of an unannotated function for anything, and checks nothing done with
+its value; declared, the value is held to its type. So a guess isn't offered where the function
+then takes an attribute its class hasn't (`cfg.verbose`, of a class whose attributes are set from
+outside it), nor a union's where it takes an attribute or an item of the name that no test narrows
+(`opt.cb`, of an `Option | None`). Nor where it uses a comparison of the name as more than a `bool`
+(`(when == index).any()`: the class compares element by element, whatever its stubs say), formats a
+`bytes` into a string (`f"{raw}"`, which mypy reports), or stores the name, or an item of it, in an
+attribute it stores something else in too (the attribute then has the name's type).
+"""
+
+import ast
+from collections.abc import Iterator, Mapping, Sequence
+from functools import lru_cache
+from typing import Final, NamedTuple, TypeAlias
+
+from constricter.fix.values.narrowed import Regions, read_narrowed, tested_lines
+from constricter.rules.syntax import FunctionDef
+from constricter.rules.walked import classes, walk
+
+# A use of a name: its line, and the attribute taken of it (none: an item).
+Use: TypeAlias = tuple[int, str]
+_DUNDER: Final = "__"
+# What gives a class attributes its body doesn't name.
+_DYNAMIC: Final = frozenset({"__getattr__", "__getattribute__", "setattr", "__dict__", "vars"})
+_OBJECT: Final = "object"
+_BYTES: Final = "bytes"
+_FORMAT: Final = "format"
+_BITWISE: Final = (ast.BitAnd, ast.BitOr, ast.BitXor)
+
+
+@lru_cache(maxsize=64)  # asked of each of a function's guesses
+def uses(function: FunctionDef) -> Mapping[str, tuple[Use, ...]]:
+    """Find where a function takes an attribute or an item of a name: `x.attr`, `x[0]`.
+
+    Returns:
+      Each such name's uses, the functions' inside it too.
+
+    """
+    found: dict[str, list[Use]] = {}
+    node: ast.AST
+    name: str
+    attr: str
+    for node in walk(function):
+        match node:
+            case ast.Attribute(value=ast.Name(id=name), attr=attr):
+                found.setdefault(name, []).append((node.value.lineno, attr))
+            case ast.Subscript(value=ast.Name(id=name)):
+                found.setdefault(name, []).append((node.value.lineno, ""))
+            case _:
+                pass
+    return {name: tuple(taken) for name, taken in found.items()}
+
+
+def unnarrowed(function: FunctionDef, name: str, regions: Regions) -> bool:
+    """Check whether a function takes an attribute or an item of `name` where no test narrows it.
+
+    Returns:
+      Whether it does: an error, for a name declared a union.
+
+    """
+    tested: frozenset[int] = tested_lines(function).get(name, frozenset())
+    return any(
+        line not in tested and not read_narrowed(regions, name, line, union=True)
+        for line, _ in uses(function).get(name, ())
+    )
+
+
+def misused(function: FunctionDef, name: str, annotation: str) -> bool:
+    """Check whether a function does with `name` what its type `annotation` makes an error of.
+
+    See `_compared`, `_formatted` and `_restored`.
+
+    Returns:
+      Whether it does.
+
+    """
+    found: _Misuses = _misuses(function)
+    return name in found.compared | found.restored or (annotation == _BYTES and name in found.formatted)
+
+
+class _Misuses(NamedTuple):
+    """The names a function compares, formats and stores as `misused` has it."""
+
+    compared: frozenset[str]
+    formatted: frozenset[str]
+    restored: frozenset[str]
+
+
+@lru_cache(maxsize=64)  # asked of each of a function's guesses
+def _misuses(function: FunctionDef) -> _Misuses:
+    compared: set[str] = set()
+    formatted: set[str] = set()
+    stored: dict[str, list[str]] = {}
+    target: ast.Attribute
+    value: ast.expr
+    node: ast.AST
+    for node in walk(function):
+        compared.update(_compared(node))
+        formatted.update(_formatted(node))
+        match node:
+            case ast.Assign(targets=[ast.Attribute() as target], value=value):
+                stored.setdefault(ast.unparse(target), []).append(_held(value))
+            case _:
+                pass
+    restored: set[str] = {name for names in stored.values() if len(set(names)) > 1 for name in names if name}
+    return _Misuses(frozenset(compared), frozenset(formatted), frozenset(restored))
+
+
+def _held(value: ast.expr) -> str:  # the name a stored value is, or is an item of; else nothing
+    name: str
+    match value:
+        case ast.Name(id=name) | ast.Subscript(value=ast.Name(id=name)):
+            return name
+        case _:
+            return ""
+
+
+def _compared(node: ast.AST) -> Iterator[str]:
+    """Name what `node` compares, where it uses the comparison as more than a `bool`.
+
+    An attribute or an item of it (`(a == b).any()`), or an operand of `&`, `|`, `^` or `~`.
+
+    Yields:
+      Each name compared.
+
+    """
+    used: list[ast.expr] = []
+    inner: ast.expr
+    left: ast.expr
+    right: ast.expr
+    op: ast.operator
+    match node:
+        case ast.Attribute(value=ast.Compare() as inner) | ast.Subscript(value=ast.Compare() as inner):
+            used.append(inner)
+        case ast.UnaryOp(op=ast.Invert(), operand=ast.Compare() as inner):
+            used.append(inner)
+        case ast.BinOp(left=left, op=op, right=right) if isinstance(op, _BITWISE):
+            used += [left, right]
+        case _:
+            pass
+    side: ast.expr
+    for inner in used:
+        if isinstance(inner, ast.Compare):
+            for side in (inner.left, *inner.comparators):
+                if isinstance(side, ast.Name):
+                    yield side.id
+
+
+def _formatted(node: ast.AST) -> Iterator[str]:
+    """Name what `node` formats into a string as `str()` would: `f"{x}"`, `"{}".format(x)`, `"%s" % x`.
+
+    Yields:
+      Each name; not one an f-string converts itself (`f"{x!r}"`).
+
+    """
+    given: list[ast.expr] = []
+    value: ast.expr
+    attr: str
+    args: list[ast.expr]
+    match node:
+        case ast.FormattedValue(value=value, conversion=-1):
+            given.append(value)
+        case ast.Call(func=ast.Attribute(value=ast.Constant(value=str()), attr=attr), args=args) if (
+            attr == _FORMAT
+        ):
+            given += args
+        case ast.BinOp(left=ast.Constant(value=str()), op=ast.Mod(), right=ast.Tuple(elts=args)):
+            given += args
+        case ast.BinOp(left=ast.Constant(value=str()), op=ast.Mod(), right=value):
+            given.append(value)
+        case _:
+            pass
+    for value in given:
+        if isinstance(value, ast.Name):
+            yield value.id
+
+
+def lacks(tree: ast.Module, function: FunctionDef, name: str, annotation: str) -> bool:
+    """Check whether a function takes an attribute of `name` that the class `annotation` names hasn't.
+
+    Returns:
+      Whether it does: `annotation` is one of the module's classes whose every attribute its own
+      body, and its bases', name (see `closed`), and one the function takes isn't among them.
+
+    """
+    known: frozenset[str] | None = closed(tree).get(annotation)
+    return known is not None and any(
+        attr and not attr.startswith(_DUNDER) and attr not in known
+        for _, attr in uses(function).get(name, ())
+    )
+
+
+@lru_cache(maxsize=4)  # asked of the same module's functions
+def closed(tree: ast.Module) -> Mapping[str, frozenset[str]]:
+    """Find the module's classes whose attributes are all in sight, and name them.
+
+    A class defined once, undecorated, with no base but others such, that neither answers for
+    attributes it doesn't name (`__getattr__`) nor sets them by name (`setattr`). Its attributes:
+    every name, attribute and string its body has, so what it binds, its `__slots__`, and what its
+    methods store (`self.x = ...`).
+
+    Returns:
+      Each such class's attributes, its bases' too.
+
+    """
+    defined: dict[str, list[ast.ClassDef]] = {}
+    node: ast.ClassDef
+    for node in classes(tree):
+        defined.setdefault(node.name, []).append(node)
+    found: dict[str, frozenset[str]] = {}
+    name: str
+    for name in defined:
+        _ = _close(name, defined, found, frozenset())
+    return found
+
+
+def _close(
+    name: str,
+    defined: Mapping[str, Sequence[ast.ClassDef]],
+    found: dict[str, frozenset[str]],
+    under: frozenset[str],
+) -> frozenset[str] | None:
+    """Name the attributes of the class `name`, if they're all in sight (see `closed`), into `found`.
+
+    `under`: the classes whose bases are being read, which a class can't be its own base through.
+
+    Returns:
+      Them, or `None`.
+
+    """
+    if name in found:
+        return found[name]
+    nodes: Sequence[ast.ClassDef] = defined.get(name, ())
+    if len(nodes) != 1 or name in under or nodes[0].decorator_list or nodes[0].keywords:
+        return None
+    attributes: set[str] | None = _attributes(nodes[0])
+    base: ast.expr
+    for base in nodes[0].bases:
+        inherited: frozenset[str] | None = (
+            frozenset()
+            if isinstance(base, ast.Name) and base.id == _OBJECT
+            else _close(base.id, defined, found, under | {name})
+            if isinstance(base, ast.Name)
+            else None
+        )
+        if attributes is None or inherited is None:
+            return None
+        attributes |= inherited
+    if attributes is None:
+        return None
+    found[name] = frozenset(attributes)
+    return found[name]
+
+
+def _attributes(node: ast.ClassDef) -> set[str] | None:
+    """Name what a class's own body gives its instances.
+
+    Returns:
+      Each attribute, or `None` if something in it may give others (see `_DYNAMIC`).
+
+    """
+    found: set[str] = set()
+    inner: ast.AST
+    for inner in walk(node):
+        if isinstance(inner, ast.Name):
+            found.add(inner.id)
+        elif isinstance(inner, ast.Attribute):
+            found.add(inner.attr)
+        elif isinstance(inner, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+            found.add(inner.name)
+        elif isinstance(inner, ast.alias):
+            found.add((inner.asname or inner.name).split(".")[0])
+        elif isinstance(inner, ast.Constant) and isinstance(inner.value, str):
+            found.add(inner.value)  # one of its `__slots__`
+    return None if found & _DYNAMIC else found