python-constricter 0.4.1__cp312-cp312-win32.whl

constricter/rules/recorded.py

@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: MIT
+"""What a finished function's scope says its `return`s, `yield`s and stores to `self`'s attributes give.
+
+Recorded for `constricter.fix.values.returned`, which types the function's calls and its class's attributes
+from them.
+"""
+
+import ast
+from typing import TYPE_CHECKING, Final
+
+from constricter.fix.core.known import ImportPlan, Inference
+from constricter.fix.values import bodies, entered, fills, stored
+from constricter.fix.values.inference import RETURNED, inference
+from constricter.fix.values.loops import looped
+from constricter.fix.values.targets import iterated
+from constricter.rules.scope import Scope, guesses_in
+from constricter.rules.syntax import FunctionDef, own_nodes
+from constricter.rules.walked import walk
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+_GENERATOR: Final = "collections.abc.Generator"
+
+
+def returns(scope: Scope, func: FunctionDef, module: ast.Module) -> list[stored.Recorded]:
+    """Record a finished function's `return` statements; a generator's one type instead (see `_generator`).
+
+    `module`: the function's, whose `yield`s say which functions to look in for one.
+
+    Returns:
+      Each one's value.
+
+    """
+    if isinstance(func, ast.FunctionDef) and bodies.is_generator(module, func):
+        return _generator(scope, func, bare=entered.is_manager(func))
+    return [
+        (None, frozenset()) if value is None else _recorded(scope, value) for value in scope.inferred.returns
+    ]
+
+
+def assigned(scope: Scope) -> list[stored.Assigned]:
+    """Record a finished function's `self.x = value` assignments, each value as a `return`'s is.
+
+    But a value reading a local bound more than once is unknown: the scope's type for it is its last
+    binding's, not what reaches the assignment (`x = None`, `if c: x = 1`, then `self.x = x`).
+
+    Returns:
+      Each attribute, and its value's inference and guesses.
+
+    """
+    return [
+        (attr, (None, frozenset()) if _rebound_in(scope, value) else _recorded(scope, value))
+        for attr, value in scope.inferred.assigned
+    ]
+
+
+def used(scope: Scope, func: FunctionDef, module: ast.Module) -> list[stored.Used]:
+    """Record a finished method's reads of the attributes its class binds to an empty container.
+
+    Each as `fills.stored` judges it; what one adds is typed as an assigned value is (see `assigned`).
+
+    Returns:
+      Each attribute, and what the read adds to it.
+
+    """
+    kinds: Mapping[str, str]
+    if not (kinds := stored.empties(module, func)):
+        return []
+    return [
+        (attr, _added(scope, use, kinds[attr]) if isinstance(use, fills.Fill) else (() if use else None))
+        for attr, use in fills.stored(func.body, kinds)
+    ]
+
+
+def _added(scope: Scope, use: fills.Fill, kind: str) -> stored.Added:
+    """Record what one fill of an empty container's attribute adds to it.
+
+    Returns:
+      Each part's inference and guesses (a `dict`'s key and value, any other's element).
+
+    """
+    values: list[ast.expr] = (
+        iterated(use.value) if use.spread else [part for part in (use.key, use.value) if part is not None]
+    )
+    if any(_rebound_in(scope, value) for value in values):
+        return ((None, frozenset()),)
+    origins: frozenset[str] = guesses_in(scope, values)[1]
+    return tuple(
+        (part, origins) for part in fills.added(use, kind, scope.settings.known, scope.inferred.types)
+    )
+
+
+def _recorded(scope: Scope, value: ast.expr) -> stored.Recorded:
+    """Record a value as its finished function's scope sees it.
+
+    Returns:
+      Its inference (`None` for an unknown value), and what that rests on if it's a guess.
+
+    """
+    found: Inference | None = inference(value, scope.settings.known, scope.inferred.types)
+    # What it rests on counts only for a typed value (see `returned`).
+    return found, frozenset() if found is None else guesses_in(scope, [value])[1]
+
+
+def _generator(scope: Scope, func: ast.FunctionDef, *, bare: bool = False) -> list[stored.Recorded]:
+    """Record what calling a generator function gives, if its `yield`s decide it.
+
+    Each a statement of its own (nothing is sent in), all of one type `T`, and no `return` of a
+    value: a `Generator[T, None, None]`, named as the module can; `bare`: `T` itself, what `with`
+    gives of one `@contextmanager` makes a manager.
+
+    Returns:
+      That type, as a lone `return`'s value; or nothing.
+
+    """
+    nodes: list[ast.AST] = list(own_nodes(func.body))
+    statements: set[int] = {id(node.value) for node in nodes if isinstance(node, ast.Expr)}
+    yields: list[ast.Yield | ast.YieldFrom] = [
+        node for node in nodes if isinstance(node, ast.Yield | ast.YieldFrom)
+    ]
+    if any(value is not None for value in scope.inferred.returns) or any(
+        id(node) not in statements for node in yields
+    ):
+        return []
+    found: list[stored.Recorded] = [_yielded(scope, node) for node in yields]
+    types: set[str | None] = {None if part is None else part.annotation for part, _ in found}
+    element: str | None = next(iter(types)) if len(types) == 1 else None
+    plan: ImportPlan | None = scope.settings.known.names.plan
+    spelled: str | None = None
+    if not bare and plan is not None and element is not None:
+        spelled = plan.spell(_GENERATOR)
+    if element is None or not (bare or spelled):
+        return []
+    text: str = element if bare else f"{spelled}[{element}, None, None]"
+    typed: Inference = Inference(text, "its `yield`s", frozenset({RETURNED}))
+    return [(typed, frozenset[str]().union(*(origins for _, origins in found)))]
+
+
+def _yielded(scope: Scope, node: ast.Yield | ast.YieldFrom) -> stored.Recorded:
+    """Record what one `yield` gives: its value, or (`yield from`) each element of it.
+
+    Unknown for a bare `yield`, and a value reading a local bound more than once (see `assigned`).
+
+    Returns:
+      Its inference, and what that rests on if it's a guess.
+
+    """
+    value: ast.expr | None = node.value
+    if value is None or _rebound_in(scope, value):
+        return None, frozenset()
+    if isinstance(node, ast.Yield):
+        return _recorded(scope, value)
+    found: Inference | None = looped(value, scope.settings.known, scope.inferred.types, inference)
+    return found, frozenset() if found is None else guesses_in(scope, iterated(value))[1]
+
+
+def _rebound_in(scope: Scope, value: ast.expr) -> bool:
+    """Check whether `value` reads a local of `scope` bound more than once.
+
+    Returns:
+      Whether it does.
+
+    """
+    return any(
+        isinstance(node, ast.Name) and node.id in scope.flow and len(scope.flow[node.id].bindings) > 1
+        for node in walk(value)
+    )

constricter/rules/redundant.py

@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: MIT
+"""LVA007: a name annotated again with the type it already has, in the same straight-line block."""
+
+import ast
+from collections.abc import Callable, Iterator
+from typing import Final, cast
+
+from constricter.offences import REDUNDANT_TYPE, Edit, Fix, FixPolicy, Offence, at
+from constricter.rules.syntax import BRANCHING, child_statements
+from constricter.rules.walked import classes, of_type
+
+_KINDS: Final = frozenset({"redundant"})
+# The nodes with blocks of statements: all `_blocks` finds any in.
+_BLOCKED: Final = (
+    ast.Module,
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+    ast.ClassDef,
+    ast.With,
+    ast.AsyncWith,
+    *BRANCHING,
+)
+
+
+def redundant(tree: ast.Module, policy: FixPolicy | None = None) -> list[Offence]:
+    """Find a name annotated again with the type it already has, in the same straight-line block.
+
+    Every block (a function, module or class body; an `if`'s body and its `orelse`; ...) is checked
+    on its own: two branches that never run in the same pass typing a name the same way isn't
+    redundant, so they're not compared against each other. Each gets a fix, if `policy` allows it,
+    dropping the annotation (see `_dropped`).
+
+    Returns:
+      One offence (LVA007) per redundant re-annotation.
+
+    """
+    offences: list[Offence] = []
+    node: ast.AST
+    block: list[ast.stmt]
+    fixing: bool = (policy or FixPolicy()).allows(_KINDS)
+    in_class: set[int] = _class_level(tree)
+    for node in of_type(tree, *_BLOCKED):
+        for block in _blocks(node):
+            offences += _redundant_in(block, lambda stmt: fixing and id(stmt) not in in_class)
+    return offences
+
+
+def _class_level(tree: ast.Module) -> set[int]:
+    """Find the statements of every class body, through `if`/`try`/..., not in its methods.
+
+    `--fix` never edits them: a dataclass's annotations are its fields.
+
+    Returns:
+      Their `id`s.
+
+    """
+    return {id(stmt) for node in classes(tree) for stmt in _nested(node.body)}
+
+
+def _nested(body: list[ast.stmt]) -> Iterator[ast.stmt]:
+    """Walk `body`'s statements, and theirs through `if`/`try`/... (not a function's or class's).
+
+    Yields:
+      Each statement.
+
+    """
+    stmt: ast.stmt
+    for stmt in body:
+        yield stmt
+        yield from _nested(child_statements(stmt))
+
+
+def _blocks(node: ast.AST) -> Iterator[list[ast.stmt]]:
+    """Find the straight-line blocks of statements directly in `node`.
+
+    Yields:
+      Each one (an `if`'s body and its `orelse` separately, and likewise for the other compound
+      statements with more than one: they run in different passes, if at all).
+
+    """
+    body: list[ast.stmt]
+    orelse: list[ast.stmt]
+    handlers: list[ast.ExceptHandler]
+    finalbody: list[ast.stmt]
+    handler: ast.ExceptHandler
+    case: ast.match_case
+    match node:
+        case (
+            ast.Module(body=body)
+            | ast.FunctionDef(body=body)
+            | ast.AsyncFunctionDef(body=body)
+            | ast.ClassDef(body=body)
+            | ast.With(body=body)
+            | ast.AsyncWith(body=body)
+        ):
+            yield body
+        case (
+            ast.If(body=body, orelse=orelse)
+            | ast.For(body=body, orelse=orelse)
+            | ast.AsyncFor(body=body, orelse=orelse)
+            | ast.While(body=body, orelse=orelse)
+        ):
+            yield body
+            yield orelse  # empty when there's no `else`, which is harmless: nothing to find in it
+        case (
+            ast.Try(body=body, handlers=handlers, orelse=orelse, finalbody=finalbody)
+            | ast.TryStar(body=body, handlers=handlers, orelse=orelse, finalbody=finalbody)
+        ):
+            yield body
+            for handler in handlers:
+                yield handler.body
+            yield orelse
+            yield finalbody
+        case _:  # a `match`: the last of the kinds with blocks (`_BLOCKED`), the only ones asked about
+            for case in cast("ast.Match", node).cases:
+                yield case.body
+
+
+def _redundant_in(block: list[ast.stmt], fixable: Callable[[ast.stmt], bool]) -> list[Offence]:
+    """Find a name in `block` annotated the same way twice.
+
+    Returns:
+      One offence per repeat, at the later statement, with a fix where `fixable` says so.
+
+    """
+    offences: list[Offence] = []
+    seen: dict[str, str] = {}
+    stmt: ast.stmt
+    name: str
+    annotation: ast.expr
+    for stmt in block:
+        match stmt:
+            case ast.AnnAssign(target=ast.Name(id=name), annotation=annotation):
+                text: str = ast.unparse(annotation)
+                if seen.get(name) == text:
+                    edit: Fix | None = _dropped(stmt) if fixable(stmt) else None
+                    offences.append(Offence(*at(stmt), name, REDUNDANT_TYPE, edit))
+                seen[name] = text
+            case _:
+                pass
+    return offences
+
+
+def _dropped(stmt: ast.AnnAssign) -> Fix | None:
+    """Drop a repeated annotation: `x: int = 2` becomes `x = 2`.
+
+    Returns:
+      The fix (writing nothing over `: int`), or `None` for a bare declaration (`x: int`, whose
+      whole statement would have to go) or one spread over lines.
+
+    """
+    if stmt.value is None or stmt.annotation.end_lineno != stmt.target.lineno:
+        return None
+    return Fix(
+        "",
+        "the type it already has",
+        edit=Edit.REPLACE,
+        span=(stmt.target.end_col_offset or 0, stmt.annotation.end_col_offset or 0),
+        kinds=_KINDS,
+    )