python-constricter 0.3.5__py3-none-any.whl → 0.3.6__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.3.5"
+__version__ = "0.3.6"
 __all__ = [
     "COMMENT_TYPED_TARGET",
     "DEFAULT_CHECKS",

constricter/cli/command.py

@@ -31,6 +31,7 @@ from constricter.offences import (
     DEFAULT_CHECKS,
     Checks,
     Edit,
+    Fix,
     Offence,
 )
 from constricter.rules import parsed
@@ -184,7 +185,10 @@ def fix_file(path: Path, offences: Sequence[Offence]) -> int:
     return count
 
 
-HINT_ROUNDS: Final = 4  # with `--fix --infer-with`: how many times each file is fixed, at most
+HINT_ROUNDS: Final = 4  # with `--fix`: how many times a file is fixed, at most (see `_settled`)
+# The fix kinds a scope's check comes to late, once the scope is read: what was bound to such a
+# name's value before had no type yet, and has one once the fix is written.
+_LATE_KINDS: Final = frozenset({"optional", "filled"})
 
 
 def _shown_lines(raw: str, name: Path) -> dict[tuple[int | None, int], str]:
@@ -288,9 +292,8 @@ def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], option
     baselined: int
     offences, baselined = options.filter.unbaselined(name, offences)
     results: list[Result] = _results(raw, name, offences, options)
-    unsafe: bool = options.unsafe_fixes
     fixing: list[Offence] = [
-        r.offence for r in results if r.offence.edit is not None and (unsafe or not r.offence.unsafe)
+        r.offence for r in results if r.offence.edit is not None and options.guesses.applies(r.offence)
     ]
     if options.mode is Mode.DIFF:
         return CheckRun(text=_diff(raw, name, fixing))
@@ -378,9 +381,8 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
 
     With `--infer-with`, the type checker's server runs throughout: it's asked for every file's
     hints first, and with `--fix`, each file a round changed is asked again and checked again, as its
-    new annotations change what the checker infers, until a round changes nothing (at most
-    `HINT_ROUNDS`). A baseline records offences, and coverage counts annotations: hints change
-    neither, only what `--fix` offers.
+    new annotations change what the checker infers (see `_settled`). A baseline records offences,
+    and coverage counts annotations: hints change neither, only what `--fix` offers.
 
     Returns:
       The names, and what each file found.
@@ -398,7 +400,7 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
     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]
+        return names, _settled(paths, check, options, None)
     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)(
@@ -407,36 +409,7 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
         options.jobs,
         options.infer_memory,
     ) as session:
-        runs: list[FileRun]
-        modules: project.Index
-        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
-            for index, run in enumerate(runs)
-            if options.mode is Mode.FIX and isinstance(run, CheckRun) and run.fixed and paths[index] != STDIN
-        ]
-        for _ in range(HINT_ROUNDS - 1):
-            if not again:
-                break
-            redone: list[FileRun] = _checked_all(
-                [paths[i] for i in again],
-                check,
-                options,
-                session,
-                modules,
-            )[0]
-            index: int
-            run: FileRun
-            for index, run in zip(again, redone, strict=True):
-                runs[index] = merged(runs[index], run)
-            again = [index for index, run in zip(again, redone, strict=True) if cast("CheckRun", run).fixed]
+        runs: list[FileRun] = _settled(paths, check, options, session)
         checker: str
         path: Path
         for checker, path in session.abandoned:
@@ -445,6 +418,65 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
     return names, runs
 
 
+def _settled(
+    paths: Sequence[Path],
+    check: Callable[[Path, Outside], FileRun],
+    options: Options,
+    session: "hints.Session | None",
+) -> list[FileRun]:
+    """Check every file, then again each one `--fix` changed in a way a second check would see.
+
+    Until a round changes nothing, `HINT_ROUNDS` at most: a second pass is then left nothing.
+
+    Returns:
+      What each file found, a file's rounds joined.
+
+    """
+    runs: list[FileRun]
+    modules: project.Index
+    runs, modules = _called_again(
+        paths,
+        _checked_all(paths, check, options, session),
+        check,
+        options,
+        session,
+    )
+    again: list[int] = [
+        index
+        for index, run in enumerate(runs)
+        if options.mode is Mode.FIX and paths[index] != STDIN and _unsettled(run, session)
+    ]
+    for _ in range(HINT_ROUNDS - 1):
+        if not again:
+            break
+        redone: list[FileRun] = _checked_all([paths[i] for i in again], check, options, session, modules)[0]
+        index: int
+        run: FileRun
+        for index, run in zip(again, redone, strict=True):
+            runs[index] = merged(runs[index], run)
+        again = [index for index, run in zip(again, redone, strict=True) if _unsettled(run, session)]
+    return runs
+
+
+def _unsettled(run: FileRun, session: "hints.Session | None") -> bool:
+    """Check whether a round of `--fix` changed a file in a way that changes what's inferred there.
+
+    Returns:
+      Whether it fixed anything, with a type checker's hints: its new annotations change them.
+      Without, whether it made a fix the scope's check comes to late (`_LATE_KINDS`): what's bound
+      to such a name's value was read before its type was known.
+
+    """
+    checked: CheckRun = cast("CheckRun", run)
+    return bool(checked.fixed) and (
+        session is not None
+        or any(
+            isinstance(made.offence.edit, Fix) and made.offence.edit.kinds & _LATE_KINDS
+            for made in checked.made
+        )
+    )
+
+
 def _called_again(
     paths: Sequence[Path],
     first: tuple[list[FileRun], project.Index],
@@ -618,7 +650,10 @@ def _report(options: Options, runs: Sequence[FileRun], files: int) -> int:
             parts.append(f"fixed {sum(run.fixed for run in checked)}")
             guesses: int
             if guesses := sum(r.offence.unsafe for r in results):
-                parts.append(f"{guesses} more with --unsafe-fixes")
+                likely: int = sum(r.offence.likely for r in results)
+                parts.append(
+                    f"{guesses} more with --unsafe-fixes" + f" ({likely} with --likely)" * bool(likely),
+                )
         if options.filter.baseline_file is not None:
             parts.append(f"{sum(run.baselined for run in checked)} baselined")
         _ = sys.stdout.write("; ".join(parts) + ".\n")

constricter/cli/hints.py

@@ -816,6 +816,6 @@ class Connection:
                     cast("IO[bytes]", self.process.stdin),
                     f"Content-Length: {len(body)}\r\n\r\n".encode() + body,
                 )
-            except OSError as error:
+            except (OSError, ValueError) as error:  # it has gone, or its input was closed to stop it
                 failure: str = f"{self.name} exited: {error}"
                 raise HintError(failure) from error

constricter/cli/options.py

@@ -332,6 +332,11 @@ def _parser() -> argparse.ArgumentParser:
         action="store_true",
         help="with --fix or --diff: also apply guesses (a call to a class that may be generic)",
     )
+    _ = parser.add_argument(
+        "--likely",
+        action="store_true",
+        help="with --fix or --diff: also apply the guesses measured to hold (see docs/LIKELY.md)",
+    )
     _ = parser.add_argument(
         "--fix-select",
         type=_fix_kinds,
@@ -563,13 +568,40 @@ class Output:
     output_file: Path | None = None
 
 
+class Guesses(Enum):
+    """Which guesses `--fix` and `--diff` apply: none, `--likely`'s, or every one (`--unsafe-fixes`)."""
+
+    NONE = "none"
+    LIKELY = "likely"
+    ALL = "all"
+
+    @classmethod
+    def of(cls, *, unsafe: bool, likely: bool) -> "Guesses":
+        """Read the two flags.
+
+        Returns:
+          `ALL` with `--unsafe-fixes`, whatever `--likely` says.
+
+        """
+        return cls.ALL if unsafe else cls.LIKELY if likely else cls.NONE
+
+    def applies(self, offence: Offence) -> bool:
+        """Check whether `offence`'s fix is one to apply.
+
+        Returns:
+          Whether it is: a certain one always.
+
+        """
+        return self is Guesses.ALL or not offence.unsafe or (self is Guesses.LIKELY and offence.likely)
+
+
 @dataclass(frozen=True)
 class Options:
     """The command's parsed options."""
 
     input: Input
     checks: Checks
-    unsafe_fixes: bool
+    guesses: Guesses
     filter: Filter
     output: Output
     mode: Mode
@@ -626,7 +658,7 @@ class Options:
                 min_python=cast("tuple[int, int] | None", args.min_python),
                 plain_bases=(*PLAIN_BASES, *cast("list[str]", args.fix_plain_bases)),
             ),
-            unsafe_fixes=cast("bool", args.unsafe_fixes),
+            guesses=Guesses.of(unsafe=cast("bool", args.unsafe_fixes), likely=cast("bool", args.likely)),
             filter=_filter(parser, args, mode),
             output=Output(
                 fmt=cast("Format", args.format),

constricter/cli/report.py

@@ -216,7 +216,9 @@ def _json(results: Sequence[Result]) -> Iterator[str]:
                     "annotation": r.offence.fix,
                     "reason": r.offence.reason,
                     "unsafe": r.offence.unsafe,
+                    "likely": r.offence.likely,
                     "kinds": sorted(r.offence.edit.kinds if r.offence.edit else ()),
+                    "imports": [*r.offence.edit.imports, *r.offence.edit.guarded] if r.offence.edit else [],
                 },
             }
             for r in results
@@ -366,7 +368,7 @@ def fix_reasons(results: Sequence[Result]) -> Iterator[str]:
 
     Yields:
       A line each: where, the name (`fixed`, for a fix `--fix` made), the annotation and its reason;
-      a guess left unmade says it needs `--unsafe-fixes`.
+      a guess left unmade says it needs `--unsafe-fixes`, or `--likely` where that applies it.
 
     """
     r: Result
@@ -374,7 +376,8 @@ def fix_reasons(results: Sequence[Result]) -> Iterator[str]:
         if r.offence.fix is not None:
             cell: str = "" if r.offence.cell is None else f"cell {r.offence.cell}:"
             where: str = f"{r.path}:{cell}{r.offence.line}:{r.offence.col + 1}"
-            guess: str = " (a guess: --unsafe-fixes)" if r.offence.unsafe and not r.fixed else ""
+            flag: str = "--likely" if r.offence.likely else "--unsafe-fixes"
+            guess: str = f" (a guess: {flag})" if r.offence.unsafe and not r.fixed else ""
             kinds: str = ", ".join(sorted(r.offence.edit.kinds if r.offence.edit else ()))
             written: str = f"`{r.offence.fix}`" if r.offence.fix else "drop its annotation"
             decided: str = f"{written}, from {r.offence.reason} [{kinds}]"

constricter/fix/core/fixes.py

@@ -3,6 +3,7 @@
 
 import contextlib
 import re
+import unicodedata
 from collections.abc import Sequence
 from operator import itemgetter
 from typing import Final, NamedTuple, TypeAlias
@@ -14,6 +15,8 @@ _HEADER: Final = 2  # a file's shebang and coding lines come first, if it has th
 _Present: TypeAlias = tuple[Sequence[str], int, frozenset[str]]
 _PRESENT: Final[dict[str | None, _Present]] = {}
 _HEADER_LINE: Final = re.compile(r"#!|#.*coding[:=]")
+_IDENTIFIER: Final = re.compile(r"\w+")
+_NORMAL: Final = "NFKC"  # how Python normalises an identifier: `ast` has a full-width `w` as `w`
 # Lines to insert, and the number of lines before them.
 _Run: TypeAlias = tuple[int, list[str]]
 # What orders the edits: a line, what's made there first (`_IMPORTS`, then an edit in the line,
@@ -74,13 +77,35 @@ def replacement(lines: Sequence[str], offence: Offence) -> Replacement | None:
             mark: str = f"  {MARK}" if fix.kinds & WIDEN_KINDS else ""
             return Replacement(fix.span[0], "", "", f"{indent}{offence.name}: {fix.annotation}{mark}{ending}")
         raw: bytes = lines[offence.line - 1].encode()
-        start: int = fix.span[0] if fix.edit is Edit.REPLACE else offence.col + len(offence.name.encode())
+        start: int = fix.span[0] if fix.edit is Edit.REPLACE else _name_end(raw, offence)
         end: int = fix.span[1] if fix.edit is Edit.REPLACE else start
         written: str = fix.annotation if fix.edit is Edit.REPLACE else f": {fix.annotation}"
         return Replacement(offence.line, raw[:start].decode(), raw[start:end].decode(), written)
     return None
 
 
+def _name_end(raw: bytes, offence: Offence) -> int:
+    """Find where the offence's name ends in its line `raw`, as the source spells it.
+
+    The source may spell it longer than `ast` has it, which normalises an identifier (a full-width
+    `w` is `w`).
+
+    Returns:
+      The column after it.
+
+    Raises:
+      IndexError: The line doesn't have the name there.
+
+    """
+    rest: str = raw[offence.col :].decode()
+    if rest.startswith(offence.name):
+        return offence.col + len(offence.name.encode())
+    spelled: re.Match[str] | None = _IDENTIFIER.match(rest)
+    if spelled is None or unicodedata.normalize(_NORMAL, spelled.group()) != offence.name:
+        raise IndexError(offence.col)
+    return offence.col + len(spelled.group().encode())
+
+
 def dropped(lines: Sequence[str], offence: Offence) -> Replacement | None:
     """Turn a fix's `drop` into a text edit: deleting those columns of its statement's line.
 

constricter/fix/core/imports.py

@@ -3,6 +3,7 @@
 
 import ast
 import bisect
+import sys
 from collections.abc import Iterator, Mapping, Sequence
 from itertools import accumulate
 from typing import Final, TypeAlias, cast
@@ -11,9 +12,10 @@ from weakref import WeakKeyDictionary
 from constricter.fix.core.known import Checking, Guarded, ImportPlan, Origin, Returns
 from constricter.rules.annotations import roots
 from constricter.rules.syntax import FunctionDef, Start, import_bindings
-from constricter.rules.walked import of_type
+from constricter.rules.walked import classes, of_type
 
 _TYPE_CHECKING: Final = "TYPE_CHECKING"
+_STDLIB: Final = sys.stdlib_module_names
 _FUTURE: Final = "__future__"
 _ANNOTATIONS: Final = "annotations"  # `from __future__ import annotations` postpones them all
 # Each module's names, for as long as its tree lives: the index reads them, then the check.
@@ -52,11 +54,12 @@ def plan(tree: ast.Module) -> ImportPlan:
     values: frozenset[str]
     taken, values = taken_names(tree)
     bound: dict[str, str] = _bound(tree)
+    defined: dict[str, int] = _defined(tree)
     return ImportPlan(
         bound,
         taken,
         _after(tree),
-        _defined(tree),
+        defined,
         checking=Checking(
             _block(tree),
             _lazy(tree, bound),
@@ -72,6 +75,52 @@ def plan(tree: ast.Module) -> ImportPlan:
     )
 
 
+def nested_classes(tree: ast.Module) -> frozenset[str]:
+    """Name the classes defined in another class's body: bare, names of that body alone.
+
+    Returns:
+      Them.
+
+    """
+    return frozenset(
+        stmt.name for node in classes(tree) for stmt in node.body if isinstance(stmt, ast.ClassDef)
+    )
+
+
+def _private(statement: str) -> bool:
+    """Check whether an import to add takes a name its module keeps to itself (`from m import _T`).
+
+    Not the standard library's, whose stubs name such classes in what they declare
+    (`unittest.case._AssertRaisesContext`).
+
+    Returns:
+      Whether it does: one underscore before it, not a dunder's two.
+
+    """
+    module: str
+    name: str
+    module, _, name = statement.removeprefix("from ").rpartition(" import ")
+    return name.startswith("_") and not name.startswith("__") and module.partition(".")[0] not in _STDLIB
+
+
+def unwritable(annotation: str, planned: ImportPlan, nested: frozenset[str]) -> bool:
+    """Check whether the module can't write `annotation`, whatever it imports.
+
+    It names a class of `nested` (see `nested_classes`) the module binds nowhere else, which no
+    function names bare; or an import it needs would take another module's private name.
+
+    Returns:
+      Whether it can't.
+
+    """
+    if roots(annotation) & nested - planned.bound.keys() - planned.defined.keys():
+        return True
+    return any(
+        _private(statement)
+        for statement in (*guarded_imports(annotation, planned), *imports_of(annotation, planned))
+    )
+
+
 def added_origin(statement: str) -> Origin:
     """Read what an import `ImportPlan.spell` added binds: `from m import T`, or `import m`.
 

constricter/fix/core/known.py

@@ -31,6 +31,30 @@ else:
 
 _BUILTINS: Final = frozenset(dir(builtins))
 _DOT: Final = "."
+# The standard library's modules only some platforms have: a checker on another finds nothing in one.
+_PLATFORM: Final = frozenset(
+    {
+        "_winapi",
+        "crypt",
+        "fcntl",
+        "grp",
+        "msvcrt",
+        "nis",
+        "nt",
+        "ossaudiodev",
+        "posix",
+        "pty",
+        "pwd",
+        "readline",
+        "resource",
+        "spwd",
+        "syslog",
+        "termios",
+        "tty",
+        "winreg",
+        "winsound",
+    },
+)
 _NAME: Final = re.compile(r"[A-Za-z_]\w*")  # each name in a return's template
 # What a name refers to: a module and an attribute of it (`None`: the module itself).
 Origin: TypeAlias = tuple[str, str | None]
@@ -177,26 +201,39 @@ class ImportPlan:
     postponed: bool = False
     values: frozenset[str] = frozenset()  # names it binds as values somewhere (see `imports.taken_names`)
 
-    def spell(self, qualified: str) -> str | None:
+    def type_checking(self) -> str | None:
+        """Name `typing.TYPE_CHECKING` for a new block, by an import that runs: the module reads it.
+
+        Returns:
+          The name, or `None` if every way to write it is taken.
+
+        """
+        return self.spell("typing.TYPE_CHECKING", runs=True)
+
+    def spell(self, qualified: str, *, runs: bool = False) -> str | None:
         """Name `qualified` (`io.BufferedReader`) in this module, adding an import if it has to.
 
         Through an import it has (see `named`), for type checking alone too (`checking`, or one
         `guarded` already), else a new `from io import BufferedReader`, else a new `import io`, but
         only binding a name nothing in the module binds. Under `if TYPE_CHECKING:` for a module in
-        `checking.lazy`.
+        `checking.lazy`, and not at all for one only some platforms have. With `runs`, only through
+        an import that runs: the name is read as the module is imported (`TYPE_CHECKING` itself).
 
         Returns:
           The name, or `None` if every way to write it is taken.
 
         """
         found: str | None
-        if (found := self.named(qualified) or self._checked(qualified)) is not None:
+        if (found := self.named(qualified) or (None if runs else self._checked(qualified))) is not None:
             return found
         module: str
         name: str
         module, _, name = qualified.rpartition(".")
         statement: str = f"from {module} import {name}"
-        if module.partition(_DOT)[0] in self.checking.lazy:
+        top: str = module.partition(_DOT)[0]
+        if not runs and top in self.checking.lazy:
+            if top in _PLATFORM:
+                return None
             return name if self.guard(name, (module, name), statement) else None
         if self._free(name, statement):
             self.added[name] = statement

constricter/fix/index/modules.py

@@ -291,20 +291,26 @@ def _guarded(tree: ast.Module, name: str, *, is_package: bool) -> dict[str, Orig
     """Map the names module `name` imports under a top-level `if` or `try` (`if TYPE_CHECKING:`).
 
     Not what it binds at run time (`_names`): a type variable imported only for the checker is a type
-    variable all the same.
+    variable all the same. Not a name two of them bind to different things (one in each branch of an
+    `if`): which it is, another file can't say.
 
     Returns:
       What each refers to.
 
     """
-    return {
-        bound: origin
-        for stmt in tree.body
-        if isinstance(stmt, ast.If | ast.Try | ast.TryStar)
-        for node in ast.walk(stmt)
-        if isinstance(node, ast.Import | ast.ImportFrom)
-        for bound, origin in _imported(node, name, is_package=is_package).items()
-    }
+    found: dict[str, Origin] = {}
+    either: set[str] = set()
+    node: ast.AST
+    bound: str
+    origin: Origin
+    for node in (
+        n for stmt in tree.body if isinstance(stmt, ast.If | ast.Try | ast.TryStar) for n in ast.walk(stmt)
+    ):
+        if isinstance(node, ast.Import | ast.ImportFrom):
+            for bound, origin in _imported(node, name, is_package=is_package).items():
+                if found.setdefault(bound, origin) != origin:
+                    either.add(bound)
+    return {bound: origin for bound, origin in found.items() if bound not in either}
 
 
 def _bound(stmt: ast.stmt) -> Iterator[str]:

constricter/fix/index/project.py

@@ -910,6 +910,7 @@ def _spelled_classes(
         spelled: list[tuple[str, Origin]] = []
         if origin[1] is not None and origin[0] != target.name:
             spelled = [(local, origin)]
+            generics.update([local] * _is_generic(catalog.modules, origin))
         elif origin[1] is None:
             package: Module | None = catalog.modules.get(origin[0])
             spelled = [
@@ -934,7 +935,8 @@ def _spelled_classes(
 def _reexported_generics(modules: Mapping[str, Module], local: str, name: str) -> Iterator[str]:
     """Spell the generic classes module `name` re-exports (`from ._c import OrderedSet`) as `local.C`.
 
-    Only its own names, not its submodules': a package's `__init__` is where they're re-exported.
+    Only its own names, not its submodules': a package's `__init__` is where they're re-exported,
+    for type checking alone too, where it imports them only when they're asked for (pydantic's).
 
     Yields:
       Each spelling.
@@ -943,14 +945,8 @@ def _reexported_generics(modules: Mapping[str, Module], local: str, name: str) -
     module: Module | None = modules.get(name)
     reexported: str
     origin: Origin
-    for reexported, origin in ({} if module is None else module.names).items():
-        defined: tuple[Module, str] | None
-        if (
-            origin[1] is not None
-            and origin[0] != name
-            and (defined := definition(modules, origin, CLASS)) is not None
-            and defined[1] in defined[0].generics
-        ):
+    for reexported, origin in ({} if module is None else {**module.guarded, **module.names}).items():
+        if origin[1] is not None and origin[0] != name and _is_generic(modules, origin):
             yield f"{local}.{reexported}"
 
 

constricter/fix/tables/source.json

@@ -1,6 +1,6 @@
 {
 "basedpyright": "1.40.1",
-"digest": "831ff4b6298124e889d624018c974797d696b66243a1269bc73eea81b9124523",
+"digest": "5dda9baa09ec382c49b7aaa4208c9416110efc7e054e3affe61bc4a6d5c93495",
 "tables": [
 "aliases",
 "attributes",

constricter/fix/values/aliased.py

@@ -11,7 +11,8 @@ binds again, which is a variable to a type checker.
 
 `TypeAlias` is named as the module's imports can, else imported from `typing`, which has it from
 Python 3.10: certain where every Python the module runs on has it there (`min-python`), or the
-module imports the name already; else a guess.
+module imports the name already; a guess where `min-python` isn't known, and no fix where it says
+some Python lacks it.
 """
 
 import ast
@@ -111,6 +112,9 @@ def declared(
     aliases: frozenset[str]
     min_python: tuple[int, int] | None
     aliases, min_python = scope
+    older: bool = min_python is not None and min_python < _SINCE
+    if older and not _ALWAYS.intersection(plan.bound.values()):
+        return None
     copied: bool = isinstance(value, ast.Name) and value.id in aliases
     named: str | None = (
         hinted.type_alias(known, target.lineno)
@@ -119,9 +123,10 @@ def declared(
     )
     if named is None:
         return None
-    certain: bool = (min_python is not None and min_python >= _SINCE) or (
-        plan.bound.get(named.partition(".")[0]) in _ALWAYS
-    )
+    always: bool = plan.bound.get(named.partition(".")[0]) in _ALWAYS
+    if older and not always:
+        return None
+    certain: bool = min_python is not None or always
     return (
         Inference(named, _REASON, frozenset({KIND})),
         not certain,

constricter/fix/values/doubts.py

@@ -22,7 +22,7 @@ from functools import lru_cache
 from types import MappingProxyType
 from typing import Final, NamedTuple, TypeAlias, cast
 
-from constricter.fix.core.imports import checking, inner_imports, rebound_names
+from constricter.fix.core.imports import checking, inner_imports, nested_classes, rebound_names
 from constricter.fix.core.known import ImportPlan, Inference, Passed
 from constricter.fix.values.narrowed import Regions, regions
 from constricter.rules.annotations import generic_classes, node_name, roots
@@ -41,6 +41,7 @@ _READS: Final[dict[_Read, str]] = {
 # Where a function tests a value, a type checker may narrow it (`isinstance`, `is None`, a `TypeGuard`).
 _TESTS: Final = (ast.If, ast.While, ast.Assert, ast.IfExp, ast.comprehension, ast.Match)
 _SELF: Final = "Self"
+_STDLIB: Final = "stdlib"  # the fix kind of what typeshed declares
 _COMPREHENSION: Final = "comprehension"
 _LITERAL: Final = "literal"
 _NONE: Final = "None"
@@ -96,6 +97,9 @@ class Facts(NamedTuple):
     attributed: frozenset[str] = frozenset()
     # Its functions' parameters' types, where a `Callable` can list them (see `callables.signatures`).
     positional: Mapping[str, tuple[str, ...]] = MappingProxyType({})
+    nested: frozenset[str] = (
+        frozenset()
+    )  # the classes defined in a class's body (see `imports.nested_classes`)
 
 
 def facts(
@@ -127,6 +131,7 @@ def facts(
         _bound_vars(tree, type_vars),
         rebound_names(tree),
         [(stmt.lineno, stmt.col_offset) for stmt in inner_imports(tree)],
+        nested=nested_classes(tree),
     )
 
 
@@ -524,8 +529,8 @@ def _selfish(value: ast.expr, found: Inference, owner: Owner) -> str | None:
 
     `self`, or a `Self` method called on `self`, `cls` or `type(self)`; `type(self)` or
     `self.__class__`, a `type[Self]`; what `cls()`, either of those called, or `__new__` given one
-    constructs; and a
-    conditional of two of them (`self if inplace else self.copy()`).
+    constructs; a standard-library function's call given `self` that returns its class
+    (`copy.copy(self)`); and a conditional of two of them (`self if inplace else self.copy()`).
 
     Returns:
       Its annotation, `{}` standing for `Self`; or `None` if it isn't one.
@@ -534,6 +539,7 @@ def _selfish(value: ast.expr, found: Inference, owner: Owner) -> str | None:
     receiver: ast.expr
     method: str
     func: ast.expr
+    args: list[ast.expr]
     template: str | None = None
     match value:
         case ast.Name() | ast.Call(func=ast.Name()) | ast.Attribute() if (
@@ -548,6 +554,11 @@ def _selfish(value: ast.expr, found: Inference, owner: Owner) -> str | None:
             method in owner.selfish and _own(receiver, owner.first) is not None
         ):
             template = _SELF_ITSELF
+        # The class only by a type variable its argument binds: the standard library names no other's.
+        case ast.Call(args=[*args]) if _STDLIB in found.kinds and any(
+            _own(arg, owner.first) == _SELF_ITSELF for arg in args
+        ):
+            template = _SELF_ITSELF
         case ast.IfExp() if {_selfish(side, found, owner) for side in (value.body, value.orelse)} == {
             _SELF_ITSELF,
         }: