python-constricter 0.2.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

constricter/__init__.py

@@ -25,7 +25,7 @@ from constricter.offences import (
 )
 from constricter.rules.checker import Coverage, annotation_coverage, check_source, check_tree
 
-__version__ = "0.2.7"
+__version__ = "0.2.8"
 __all__ = [
     "COMMENT_TYPED_TARGET",
     "DEFAULT_CHECKS",

constricter/cli/command.py

@@ -9,7 +9,7 @@ import io
 import json
 import sys
 import tokenize
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import replace
 from functools import partial
 from pathlib import Path
@@ -23,8 +23,8 @@ from constricter.cli.protocol import HintError
 from constricter.cli.report import Format, Result, fix_reasons, render, statistics
 from constricter.cli.runs import BaselineRun, CheckRun, CoverageRun, FileRun
 from constricter.cli.workers import Workers
-from constricter.fix import fixes, project
-from constricter.fix.known import Hints, Outside, Returns
+from constricter.fix import callers, fixes, installed, project
+from constricter.fix.known import Callee, Hints, Outside, Returns
 from constricter.noqa import lines, unsuppressed
 from constricter.offences import (
     DEFAULT_CHECKS,
@@ -41,6 +41,7 @@ EXIT_CLEAN: Final = 0
 EXIT_FOUND: Final = 1
 EXIT_ERROR: Final = 2
 _ALL: Final = 100  # percent
+_PY: Final = ".py"  # a module the index names (not a notebook)
 
 
 def _encoding(path: Path, data: bytes) -> str:
@@ -264,7 +265,11 @@ def _check_path(path: Path, outside: Outside, options: Options) -> CheckRun:
     raw, checked, error = _read_checked(path, name, options.checks, outside)
     if error:
         return CheckRun(error=error)
-    return replace(_handled(path, (raw, name), checked.offences, options), returned=checked.returned)
+    return replace(
+        _handled(path, (raw, name), checked.offences, options),
+        returned=checked.returned,
+        calls=checked.calls,
+    )
 
 
 def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], options: Options) -> CheckRun:
@@ -350,8 +355,10 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     else:
         check = partial(_check_path, options=options)
     names: list[Path] = [options.input.name(path) for path in paths]
-    if not options.infer_with or options.mode in {Mode.COVERAGE, Mode.WRITE_BASELINE}:
+    if options.mode in {Mode.COVERAGE, Mode.WRITE_BASELINE}:
         return names, _checked_all(paths, check, options)[0]
+    if not options.infer_with:
+        return names, _called_again(paths, _checked_all(paths, check, options), check, options)[0]
     session: hints.Session
     # Imported only for `--infer-with`: it's slow to import, for every run's start.
     with cast("type[hints.Session]", importlib.import_module("constricter.cli.hints").Session)(
@@ -362,7 +369,13 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     ) as session:
         runs: list[FileRun]
         modules: project.Index
-        runs, modules = _checked_all(paths, check, options, session)
+        runs, modules = _called_again(
+            paths,
+            _checked_all(paths, check, options, session),
+            check,
+            options,
+            session,
+        )
         # The files the last round changed: only their hints can have changed.
         again: list[int] = [
             index
@@ -387,6 +400,67 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     return names, runs
 
 
+def _called_again(
+    paths: Sequence[Path],
+    first: tuple[list[FileRun], project.Index],
+    check: Callable[[Path, Outside], FileRun],
+    options: Options,
+    session: "hints.Session | None" = None,
+) -> tuple[list[FileRun], project.Index]:
+    """Check again the files whose functions' unannotated parameters every call passes one type.
+
+    Knowing those types (see `callers`), as guesses; a file among several of one module name isn't
+    (which its callers call can't be told). Then the other files calling those functions, knowing
+    what they now return. With `--fix` a file's rounds are joined; otherwise the last, knowing more,
+    stands.
+
+    Returns:
+      What each file found, and the index, with the parameters' types.
+
+    """
+    runs: list[FileRun]
+    modules: project.Index
+    runs, modules = first
+    found: dict[str, callers.Parameters] = callers.parameters(
+        (run.calls for run in runs if isinstance(run, CheckRun)),
+        modules,
+    )
+    names: list[str | None] = [project.module_name(path) if path.suffix == _PY else None for path in paths]
+    again: list[int]
+    if not (again := [at for at, name in enumerate(names) if name in found and names.count(name) == 1]):
+        return runs, modules
+    calling: list[int] = _calling(runs, found, again)
+    modules = callers.with_parameters(modules, found)
+    which: list[int]
+    for which in (again, calling):
+        redone: list[FileRun]
+        redone, modules = _checked_all([paths[at] for at in which], check, options, session, modules)
+        at: int
+        run: FileRun
+        for at, run in zip(which, redone, strict=True):
+            runs[at] = _merged(runs[at], run) if options.mode is Mode.FIX else run
+    return runs, modules
+
+
+def _calling(
+    runs: Sequence[FileRun],
+    found: Mapping[str, callers.Parameters],
+    again: Sequence[int],
+) -> list[int]:
+    """Find the files (not among `again`) calling a function whose parameters `found` types.
+
+    Returns:
+      Their indexes.
+
+    """
+    typed: set[Callee] = {(module, function) for module, functions in found.items() for function in functions}
+    return [
+        at
+        for at, run in enumerate(runs)
+        if at not in again and isinstance(run, CheckRun) and typed & run.calls.calls.keys()
+    ]
+
+
 def _checked_all(
     paths: Sequence[Path],
     check: Callable[[Path, Outside], FileRun],
@@ -412,6 +486,8 @@ def _checked_all(
         elif modules is None:
             modules = project.Index({}, []) if coverage else project.index(paths)
             collecting.indexed()
+        if not coverage:
+            modules = installed.with_installed(modules, installed.search_path())
         return schedule.checked(
             paths,
             check,

constricter/cli/hints.py

@@ -59,6 +59,12 @@ _LINE_BREAK: Final = re.compile(r"\r\n|\r|\n")  # the lines positions count, as
 _UTF16: Final = "utf-16"
 _UTF8: Final = "utf-8"
 _METHOD_NOT_FOUND: Final = -32601
+# A request the server dropped because a document changed under it (ty, as later files open): the
+# client is to ask again.
+_CONTENT_MODIFIED: Final = -32801
+_ASK_AGAIN: Final = 5  # how many times a hint request is asked again after that, at most
+_HINTS: Final = "textDocument/inlayHint"
+_MODIFIED: Final[_Object] = {}  # a hint request's answer, when it's to be asked again (by identity)
 _ID: Final = "id"
 _METHOD: Final = "method"
 _ERROR: Final = "error"
@@ -325,14 +331,14 @@ def command(checker: str) -> list[str]:
 
     """
     server: Server = SERVERS[checker]
-    name: str = server.executable
-    executable: str | None = shutil.which(name) or shutil.which(name, path=str(Path(sys.executable).parent))
-    if executable is None:
+    found: str | None
+    if (found := protocol.executable(checker)) is None:
+        install: str = f"`pip install {checker}`"
         message: str = (
-            f"--infer-with={checker} needs `{name}`, which isn't installed (`pip install {checker}`)"
+            f"--infer-with={checker} needs `{server.executable}`, which isn't installed ({install})"
         )
         raise HintError(message)
-    return [executable, *server.args]
+    return [found, *server.args]
 
 
 class Connection:
@@ -450,32 +456,51 @@ class Connection:
         text: str
         for path, text in files.items():
             self._opened(path.resolve().as_uri(), text)
-        asked: dict[int, Path] = {
-            self._ask(
-                "textDocument/inlayHint",
-                {
-                    "textDocument": {"uri": path.resolve().as_uri()},
-                    "range": {
-                        "start": {"line": 0, "character": 0},
-                        "end": {"line": len(lines[path]), "character": 0},
-                    },
-                },
-            ): path
-            for path in files
-        }
-        return _Asked(asked, lines)
+        return _Asked({self._ask_hints(path, lines[path]): path for path in files}, lines)
+
+    def _ask_hints(self, path: Path, lines: Sequence[str]) -> int:
+        """Ask for an open file's hints over the whole of it, without waiting for them.
+
+        Returns:
+          The request's number.
+
+        """
+        return self._ask(
+            _HINTS,
+            {
+                "textDocument": {"uri": path.resolve().as_uri()},
+                "range": {"start": {"line": 0, "character": 0}, "end": {"line": len(lines), "character": 0}},
+            },
+        )
 
     def answers(self, asked: "_Asked") -> _Found:
-        """Wait for the answers to hint requests `ask` sent.
+        """Wait for the answers to hint requests `ask` sent, asking again for those the server dropped.
 
         Returns:
           Each file's variable-type hints' texts, by where the name each types ends.
 
+        Raises:
+          HintError: The server dropped one `_ASK_AGAIN` times more (see `_CONTENT_MODIFIED`).
+
         """
-        answers: dict[int, _Json] = self._collect(set(asked.numbers), "textDocument/inlayHint")
-        return {
-            path: self._found(answers[number], asked.lines[path]) for number, path in asked.numbers.items()
-        }
+        found: _Found = {}
+        waiting: dict[int, Path] = asked.numbers
+        for _ in range(_ASK_AGAIN + 1):
+            answers: dict[int, _Json] = self._collect(set(waiting), _HINTS)
+            found.update(
+                (path, self._found(answers[number], asked.lines[path]))
+                for number, path in waiting.items()
+                if answers[number] is not _MODIFIED
+            )
+            waiting = {
+                self._ask_hints(path, asked.lines[path]): path
+                for number, path in waiting.items()
+                if answers[number] is _MODIFIED
+            }
+            if not waiting:
+                return found
+        error: str = f"{self.name} failed `{_HINTS}`: content modified, {_ASK_AGAIN + 1} times"
+        raise HintError(error)
 
     def _opened(self, uri: str, text: str) -> None:
         """Send a file's text: opening it, or (open already) replacing its whole text, if it's changed."""
@@ -586,6 +611,8 @@ class Connection:
         )
         if _ERROR in answer:
             failure: _Object = cast("_Object", answer[_ERROR])
+            if method == _HINTS and failure.get("code") == _CONTENT_MODIFIED:
+                return cast("int", answer[_ID]), _MODIFIED
             error: str = f"{self.name} failed `{method}`: {failure.get('message')}"
             raise HintError(error)
         return cast("int", answer[_ID]), answer.get("result")

constricter/cli/options.py

@@ -21,7 +21,7 @@ from constricter.cli.config import (
 )
 from constricter.cli.explain import explain
 from constricter.cli.paths import STDIN, excluded
-from constricter.cli.protocol import SERVERS
+from constricter.cli.protocol import SERVERS, runs
 from constricter.cli.report import Format, Result
 from constricter.offences import (
     LEVELS,
@@ -193,6 +193,16 @@ def _parser() -> argparse.ArgumentParser:
         default="strict",
         help="which codes are errors rather than warnings (default: strict)",
     )
+    _ = parser.add_argument(
+        "--max",
+        action="store_true",
+        help="the strictest check: suffocate everywhere, all scopes, the opt-in codes (command line only)",
+    )
+    _ = parser.add_argument(
+        "--max-fix",
+        action="store_true",
+        help="--max, --fix --unsafe-fixes, and every installed checker's hints (command line only)",
+    )
     _ = parser.add_argument(
         "--format",
         type=Format,
@@ -492,7 +502,7 @@ class Options:
             parser.set_defaults(**config_defaults(Path.cwd()))
         except ValueError as error:
             parser.error(str(error))
-        args: argparse.Namespace = parser.parse_args(argv)
+        args: argparse.Namespace = _maximal(parser.parse_args(argv))
         code: str | None
         if (code := cast("str | None", args.explain)) is not None:
             _ = sys.stdout.write(explain(code))
@@ -538,6 +548,30 @@ class Options:
         )
 
 
+def _maximal(args: argparse.Namespace) -> argparse.Namespace:
+    """Apply `--max-fix` (`--max`, every fix, every installed checker) and `--max`.
+
+    `--max`: `suffocate` for every path (over `per-path-levels`), all scopes, the opt-in codes.
+
+    Returns:
+      The arguments.
+
+    """
+    if cast("bool", args.max_fix):
+        args.max = args.fix = args.unsafe_fixes = True
+        chosen: list[str] = cast("list[str]", args.infer_with)
+        args.infer_with = [
+            *chosen,
+            *(checker for checker in SERVERS if checker not in chosen and runs(checker)),
+        ]
+    if cast("bool", args.max):
+        args.level = Level.SUFFOCATE.name.lower()
+        args.per_path_levels = {}
+        args.all_scopes = True
+        args.extend_select = [*cast("list[str]", args.extend_select), *sorted(OPT_IN)]
+    return args
+
+
 def _filter(parser: argparse.ArgumentParser, args: argparse.Namespace, mode: Mode) -> Filter:
     """Build the filter the options set, reading the baseline (the default one, if it exists).
 

constricter/cli/protocol.py

@@ -6,6 +6,10 @@ type is its label after its `:`; basedpyright is asked for variable types only.
 """
 
 import json
+import shutil
+import subprocess  # asks a checker whether it runs
+import sys
+from pathlib import Path
 from typing import IO, Final, NamedTuple, TypeAlias, cast
 
 Json: TypeAlias = dict[str, "Json"] | list["Json"] | str | int | float | bool | None
@@ -44,6 +48,59 @@ SERVERS: Final = {
     # Parallel already: more servers only repeat its work (sqlalchemy's: 0.9s with one, 0.7s with four).
     "ty": Server("ty", ("server",), 1),
 }
+_PROBE: Final = "--version"  # quick for both; basedpyright-langserver's exits 1 all the same
+_PROBE_TIMEOUT: Final = 10.0  # seconds it may take
+_CANT_RUN: Final = frozenset({126, 127})  # the shell's "can't execute" and "not found": a broken shim's
+
+
+def executable(checker: str) -> str | None:
+    """Find `checker`'s language server: on `PATH`, or beside this Python (an unactivated venv).
+
+    The first that runs (a version manager's shim can be found, and not run), else the first found.
+
+    Returns:
+      Its path, or `None` if it isn't installed.
+
+    """
+    name: str = SERVERS[checker].executable
+    found: list[str] = list(
+        dict.fromkeys(
+            path
+            for path in (shutil.which(name), shutil.which(name, path=str(Path(sys.executable).parent)))
+            if path is not None
+        ),
+    )
+    return next((path for path in found if _runs(path)), found[0] if found else None)
+
+
+def runs(checker: str) -> bool:
+    """Check that `checker` is installed, and runs.
+
+    Returns:
+      Whether it does.
+
+    """
+    found: str | None = executable(checker)
+    return found is not None and _runs(found)
+
+
+def _runs(path: str) -> bool:
+    """Check that an executable runs: its `--version` starts, whatever it answers.
+
+    Returns:
+      Whether it does.
+
+    """
+    try:
+        done: subprocess.CompletedProcess[bytes] = subprocess.run(
+            [path, _PROBE],
+            capture_output=True,
+            timeout=_PROBE_TIMEOUT,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    return done.returncode not in _CANT_RUN
 
 
 class HintError(Exception):

constricter/cli/runs.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from typing import TypeAlias
 
 from constricter.cli.report import Result
-from constricter.fix.known import Returns
+from constricter.fix.known import Observed, Returns
 from constricter.offences import Offence
 from constricter.rules.checker import Coverage
 
@@ -20,6 +20,7 @@ class CheckRun:
     text: str = ""  # --diff: the diff; --fix on standard input: the fixed source
     error: str = ""
     returned: Returns = field(default_factory=Returns)  # what its unannotated functions return
+    calls: Observed = field(default_factory=Observed)  # what it passes checked files' functions
 
 
 @dataclass(frozen=True)

constricter/cli/schedule.py

@@ -13,7 +13,7 @@ from typing import Final
 
 from constricter.cli.runs import CoverageRun, FileRun
 from constricter.cli.workers import Checking, Workers, check_share, first_done
-from constricter.fix import order, project
+from constricter.fix import callers, order, project
 from constricter.fix.known import Hints, Outside
 
 CYCLE_ROUNDS: Final = 3  # how many times to check again files calling each other's functions
@@ -35,6 +35,8 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         imported.returned,
         imported.guarded,
         imported.generics,
+        callers.callees(modules, path),
+        callers.own_parameters(modules, path),
     )
 
 

constricter/fix/callers.py

@@ -0,0 +1,153 @@
+# SPDX-License-Identifier: MIT
+"""Unannotated parameters typed by their callers: what every call in the checked files passes each one.
+
+Once every file is checked, each module's `Observed` calls to the checked files' open functions (see
+`modules.open_functions`) are matched to their parameters, as Python binds them. A parameter left
+unannotated is typed when every call passes it, each an argument of the same known type
+(`rules.calls` says which count); not if a call leaves it to its default, can't be matched, or
+unpacks its arguments, nor if the function escapes (a callback), and never for a function no file
+calls. The files defining them are then checked again knowing those types, as guesses (`callers`):
+a caller outside the checked files may pass anything.
+"""
+
+from collections.abc import Iterable, Mapping, Sequence
+from pathlib import Path
+from typing import Final, TypeAlias
+
+from constricter.fix import project
+from constricter.fix.known import Call, Callee, Observed, Origin, Passed, Seeds
+from constricter.fix.modules import SUFFIX, Index, Param
+
+KIND: Final = "callers"  # the guessing mechanism (`FIX_KINDS`)
+# A module's functions' typed parameters: each one's type and what it rests on, by name, by function.
+Parameters: TypeAlias = dict[str, dict[str, Passed]]
+_POSITIONAL: Final = frozenset({"p", "e"})
+_KEYWORD: Final = frozenset({"e", "k"})
+_UNPASSED: Final = ""  # a parameter a call leaves to its default
+
+
+def parameters(observations: Iterable[Observed], catalog: Index) -> dict[str, Parameters]:
+    """Type the checked files' functions' unannotated parameters by every call to them (see the docstring).
+
+    Returns:
+      Each typed parameter's type, by its function and module.
+
+    """
+    calls: dict[Callee, list[Call]] = {}
+    escaped: set[Callee] = set()
+    observed: Observed
+    for observed in observations:
+        escaped.update(observed.escaped)
+        callee: Callee
+        found: tuple[Call, ...]
+        for callee, found in observed.calls.items():
+            calls.setdefault(callee, []).extend(found)
+    typed: dict[str, Parameters] = {}
+    each: list[Call]
+    for callee, each in calls.items():
+        module: str
+        function: str
+        module, function = callee
+        params: tuple[Param, ...] | None = (
+            None
+            if callee in escaped or module not in catalog.modules
+            else catalog.modules[module].open.get(function)
+        )
+        types: dict[str, Passed]
+        if types := {} if params is None else _typed(params, each):
+            typed.setdefault(module, {})[function] = types
+    return typed
+
+
+def _typed(params: Sequence[Param], calls: Sequence[Call]) -> dict[str, Passed]:
+    """Type a function's unannotated parameters by `calls`: each one's, if every call passes it the same.
+
+    Returns:
+      Each typed parameter's type, and what its arguments' types rest on together.
+
+    """
+    bound: list[dict[str, Passed | None] | None] = [_bound(params, call) for call in calls]
+    found: dict[str, Passed] = {}
+    param: Param
+    for param in params:
+        name: str = param[0]
+        passed: list[Passed | None] = [
+            None if one is None else one.get(name, (_UNPASSED, frozenset())) for one in bound
+        ]
+        types: set[str | None] = {None if one is None else one[0] for one in passed}
+        only: str | None = types.pop() if len(types) == 1 else None
+        if not param[3] and only:
+            found[name] = (only, frozenset().union(*(one[1] for one in passed if one is not None)))
+    return found
+
+
+def _bound(params: Sequence[Param], call: Call) -> dict[str, Passed | None] | None:
+    """Bind a call's arguments' types to a function's parameters, as Python binds the arguments.
+
+    Returns:
+      Each parameter's argument's type (`None`: unknown), by name, a parameter it leaves to its
+      default missing; or `None` if they can't be bound (unpacked, too many, an unknown keyword, one
+      bound twice): a call that fails, or can't be read.
+
+    """
+    positional: list[str] = [param[0] for param in params if param[1] in _POSITIONAL]
+    if call.unpacked or len(call.positional) > len(positional):
+        return None
+    bound: dict[str, Passed | None] = dict(zip(positional, call.positional, strict=False))
+    keyword: str
+    typed: Passed | None
+    for keyword, typed in call.keywords:
+        if keyword in bound or not any(param[0] == keyword and param[1] in _KEYWORD for param in params):
+            return None
+        bound[keyword] = typed
+    return bound
+
+
+def callees(catalog: project.Index, path: Path) -> dict[str, Callee]:
+    """Find the checked files' functions the file at `path` may call whose parameters aren't all annotated.
+
+    Its own (`f`), and those it imports (`f`, `u.f`, through re-exports); not an installed package's.
+
+    Returns:
+      Each, as the file spells it, mapped to its module and name; nothing for a file `catalog` doesn't
+      have.
+
+    """
+    target: project.Module | None
+    if path.suffix != SUFFIX or (target := catalog.modules.get(project.module_name(path))) is None:
+        return {}
+    found: dict[str, Callee] = {name: (target.name, name) for name in target.open}
+    key: str
+    origin: Origin
+    for key, origin in project.spellings(catalog, target, project.OPEN):
+        defined: tuple[project.Module, str] | None = project.definition(catalog.modules, origin, project.OPEN)
+        if defined is not None and not defined[0].installed:
+            found[key] = (defined[0].name, defined[1])
+    return found
+
+
+def own_parameters(catalog: project.Index, path: Path) -> Seeds:
+    """Find what every call passes the unannotated parameters of the file at `path`'s functions.
+
+    Returns:
+      Each function's parameters' types, by name (see `with_parameters`).
+
+    """
+    target: project.Module | None = (
+        catalog.modules.get(project.module_name(path)) if path.suffix == SUFFIX else None
+    )
+    return {} if target is None else target.parameters
+
+
+def with_parameters(catalog: project.Index, found: Mapping[str, Seeds]) -> project.Index:
+    """Record what every call passes checked modules' functions' unannotated parameters (by module name).
+
+    Returns:
+      The index, with them.
+
+    """
+    modules: dict[str, project.Module] = dict(catalog.modules)
+    name: str
+    for name in found.keys() & modules.keys():
+        modules[name] = modules[name]._replace(parameters=found[name])
+    return project.Index(modules, catalog.names)

constricter/fix/doubts.py

@@ -3,7 +3,8 @@
 
 - A copy, attribute or subscript of a union may be narrowed where it's read (`if x is not None:`,
   `isinstance`), which a type checker sees and `--fix` doesn't; so may a comprehension's elements, by
-  its condition (`[c for c in cs if isinstance(c, Column)]`). Their fixes are guesses.
+  its condition (`[c for c in cs if isinstance(c, Column)]`), and a read whose type a call takes as
+  its own (`deque([x])`). Their fixes are guesses.
 - An ALL_CAPS module-level name is a constant to pyright, which keeps its literal's type
   (`Literal["r"]`) where `str` would widen it: a guess too, where the module passes it to a call
   or a default (see `passed`), for a parameter that may take only some values.
@@ -79,20 +80,22 @@ class Owner(NamedTuple):
     selfish: frozenset[str]  # its methods declared to return a bare `Self` (see `self_returns`)
 
 
-def doubts(value: ast.expr, found: Inference, *, constant: bool, narrowed: bool) -> frozenset[str]:
+def doubts(value: ast.expr, found: Inference, *, constant: bool, narrowed: frozenset[str]) -> frozenset[str]:
     """Find what makes `found`, a certain inference of `value`, a guess (see the module docstring).
 
-    `constant`: whether the value is bound to an ALL_CAPS module-level name; `narrowed`: whether the
-    function tests the value itself somewhere (`isinstance(x, C)`, `x is None`, `is_c(x)`), where a
-    type checker narrows it, whatever its type.
+    `constant`: whether the value is bound to an ALL_CAPS module-level name; `narrowed`: what the
+    function tests somewhere (`isinstance(x, C)`, `x is None`, `is_c(x)`), where a type checker
+    narrows it, whatever its type: the value itself, or a read whose type it takes (`found.reads`).
 
     Returns:
       The guessing mechanisms (`FIX_KINDS`) it then rests on; none if it stays certain.
 
     """
     kind: str | None = _READS.get(type(value))
-    if kind is not None and (narrowed or len(members(found.annotation) or ()) > 1):
+    if kind is not None and (ast.unparse(value) in narrowed or len(members(found.annotation) or ()) > 1):
         return frozenset({kind})
+    if narrowed.intersection(found.reads):
+        return frozenset({_READS[ast.Name]})
     if isinstance(value, _COMPREHENSIONS) and any(g.ifs for g in value.generators) and _has_union(found):
         return frozenset({_COMPREHENSION})
     if constant and _literal(value):

constricter/fix/imports.py

@@ -6,7 +6,7 @@ from collections.abc import Iterator
 from functools import lru_cache
 from typing import Final
 
-from constricter.fix.known import ImportPlan
+from constricter.fix.known import ImportPlan, Origin
 from constricter.rules.syntax import import_bindings
 from constricter.rules.walked import of_type
 
@@ -51,6 +51,19 @@ def plan(tree: ast.Module) -> ImportPlan:
     )
 
 
+def added_origin(statement: str) -> Origin:
+    """Read what an import `ImportPlan.spell` added binds: `from m import T`, or `import m`.
+
+    Returns:
+      Its origin: `("m", "T")`, or `("m", None)`.
+
+    """
+    module: str
+    name: str
+    module, _, name = statement.removeprefix("from ").removeprefix("import ").partition(" import ")
+    return module, name or None
+
+
 def _is_checking(test: ast.expr) -> bool:
     """Check whether an `if`'s test is `TYPE_CHECKING` (or `typing.TYPE_CHECKING`).