willitbite 0.1.0__tar.gz → 0.1.1__tar.gz

{willitbite-0.1.0 → willitbite-0.1.1}/CHANGELOG.md

@@ -5,6 +5,16 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-09-09
+
+### Fixed
+
+- Call sites written through an import alias (`from lib import collect as c`,
+  then `c(...)`) were invisible to the call-site pass. A warning whose only
+  visible caller supplied the argument could be cleared as `LATENT` while the
+  call that omits the argument sat in the same tree. Aliased calls are now
+  indexed under the imported name as well as the alias.
+
 ## [0.1.0] - 2026-09-08
 
 ### Added

{willitbite-0.1.0 → willitbite-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: willitbite
-Version: 0.1.0
+Version: 0.1.1
 Summary: Tell which of ruff's loop-closure and mutable-default warnings can actually reach you at runtime
 Project-URL: Homepage, https://github.com/muhzuhaib/willitbite
 Project-URL: Issues, https://github.com/muhzuhaib/willitbite/issues
@@ -180,12 +180,19 @@ inference, which this does not do, so a call counts whenever the called name mat
 appears. That over-matches, and the over-matching is deliberate: an unrelated `send` elsewhere can
 only add an omission, and an omission is the answer that keeps the warning.
 
-Three things count as no evidence at all, and each of them leaves a warning at `BITES`:
+Import aliases are resolved before the name match runs: `from lib import collect as c` followed by
+`c(...)` is counted as a call to `collect`, including through relative imports. This matters because
+an alias hides callers without adding any, and a caller the index cannot see counts as absent, which
+is the direction a false `LATENT` comes from.
+
+Four things count as no evidence at all, and each of them leaves a warning at `BITES`:
 
 - a `**kwargs` splat at the call site, which might be carrying the argument
 - a `*args` splat, which might be filling the position
 - **no caller anywhere**, which usually means a public entry point called from outside the tree you
   scanned, and is the case most likely to bite a stranger
+- a name that reaches the function some other way: a star import, a rebinding like
+  `handler = collect`, or dispatch that only exists at runtime
 
 The index is only built when something came back `BITES`, so a run that finds nothing reachable
 never pays for the scan.

{willitbite-0.1.0 → willitbite-0.1.1}/README.md

@@ -135,12 +135,19 @@ inference, which this does not do, so a call counts whenever the called name mat
 appears. That over-matches, and the over-matching is deliberate: an unrelated `send` elsewhere can
 only add an omission, and an omission is the answer that keeps the warning.
 
-Three things count as no evidence at all, and each of them leaves a warning at `BITES`:
+Import aliases are resolved before the name match runs: `from lib import collect as c` followed by
+`c(...)` is counted as a call to `collect`, including through relative imports. This matters because
+an alias hides callers without adding any, and a caller the index cannot see counts as absent, which
+is the direction a false `LATENT` comes from.
+
+Four things count as no evidence at all, and each of them leaves a warning at `BITES`:
 
 - a `**kwargs` splat at the call site, which might be carrying the argument
 - a `*args` splat, which might be filling the position
 - **no caller anywhere**, which usually means a public entry point called from outside the tree you
   scanned, and is the case most likely to bite a stranger
+- a name that reaches the function some other way: a star import, a rebinding like
+  `handler = collect`, or dispatch that only exists at runtime
 
 The index is only built when something came back `BITES`, so a run that finds nothing reachable
 never pays for the scan.

{willitbite-0.1.0 → willitbite-0.1.1}/src/willitbite/__init__.py

@@ -1,3 +1,3 @@
 """Decide which ruff warnings can actually reach you at runtime."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{willitbite-0.1.0 → willitbite-0.1.1}/src/willitbite/callsites.py

@@ -15,7 +15,10 @@ to a definition properly needs type inference, which this does not have. So a
 call is counted whenever the called name matches, wherever it appears. That
 over-matches: an unrelated ``send`` in another module is counted too. The
 over-matching is in the safe direction, because an extra caller can only ever
-add an omission and an omission is the answer that keeps the warning.
+add an omission and an omission is the answer that keeps the warning. Import
+aliases are resolved (``from lib import collect as c`` files ``c(...)`` under
+``collect`` too), because an alias hides callers without adding any, and
+hidden callers are the one direction this pass must never err in.
 
 **Everything unresolvable stays unresolved.** A ``**kwargs`` splat might be
 carrying the argument, a ``*args`` splat might be filling the position, and a
@@ -78,6 +81,29 @@ def python_files(root):
                 yield os.path.join(folder, name)
 
 
+def import_aliases(tree):
+    """Map each local alias in ``tree`` to the imported name it stands for.
+
+    ``from lib import collect as c`` makes ``c(...)`` a call to ``collect``, so
+    the index needs both spellings or the aliased callers vanish, and a caller
+    the index cannot see is a caller it counts as absent.
+
+    Only ``as`` bindings belong here. An import without one already matches by
+    its own name, and indexing it a second time would double-count its callers.
+    ``import lib as l`` aliases a module, not a function. A star import names
+    nothing at all. Relative imports work because the module path is never
+    consulted, only the name being imported.
+    """
+    aliases = {}
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ImportFrom) or node.module is None:
+            continue
+        for alias in node.names:
+            if alias.asname is not None:
+                aliases[alias.asname] = alias.name
+    return aliases
+
+
 def index(root):
     """Map every called name under ``root`` to the calls that use it.
 
@@ -95,12 +121,20 @@ def index(root):
                 tree = ast.parse(handle.read())
         except (OSError, SyntaxError, ValueError, UnicodeDecodeError):
             continue
+        aliases = import_aliases(tree)
         for node in ast.walk(tree):
             if not isinstance(node, ast.Call):
                 continue
             callee = node.func
             if isinstance(callee, ast.Name):
-                found[callee.id].append(Call(filename, node.lineno, node, False))
+                call = Call(filename, node.lineno, node, False)
+                found[callee.id].append(call)
+                # Also under the imported name, so the definition sees its
+                # aliased callers. Purely additive: the alias spelling stays
+                # indexed for any same-named function of its own.
+                resolved = aliases.get(callee.id)
+                if resolved is not None:
+                    found[resolved].append(call)
             elif isinstance(callee, ast.Attribute):
                 found[callee.attr].append(Call(filename, node.lineno, node, True))
     return found

{willitbite-0.1.0 → willitbite-0.1.1}/tests/test_callsites.py

@@ -179,6 +179,48 @@ def test_a_bound_method_call_that_omits_it_still_bites(tmp_path):
     assert v.kind == BITES
 
 
+# --------------------------------------------------------------------------
+# Import aliases.
+#
+# ``from lib import collect as c`` spells every call ``c(...)``. The pass
+# matches by name, so before aliases were resolved those callers were simply
+# absent from the index, and absence reads as safety here: a warning whose
+# only aliased caller omitted the argument came back LATENT with the call
+# that triggers it sitting in the same tree. These are the tests that earn
+# the feature.
+# --------------------------------------------------------------------------
+
+
+def test_a_call_through_an_import_alias_is_still_found(tmp_path):
+    v = decide(
+        tmp_path,
+        {
+            "lib.py": MUTATES,
+            "app.py": "from lib import collect as c\ncollect(1, [])\nc(2)\n",
+        },
+    )
+    assert v.kind == BITES
+
+
+def test_an_alias_supplying_the_argument_is_evidence_for_latent(tmp_path):
+    v = decide(
+        tmp_path,
+        {"lib.py": MUTATES, "app.py": "from lib import collect as c\nc(1, [])\n"},
+    )
+    assert v.kind == LATENT
+
+
+def test_a_relative_import_alias_resolves_the_same_way(tmp_path):
+    v = decide(
+        tmp_path,
+        {
+            "lib.py": MUTATES,
+            "pkg/app.py": "from ..lib import collect as c\ncollect(1, [])\nc(2)\n",
+        },
+    )
+    assert v.kind == BITES
+
+
 # --------------------------------------------------------------------------
 # The index itself.
 # --------------------------------------------------------------------------
@@ -210,6 +252,28 @@ def test_index_records_attribute_calls_under_the_attribute_name(tmp_path):
     assert len(calls["send"]) == 2
 
 
+def test_index_files_an_aliased_call_under_both_names(tmp_path):
+    calls = project(
+        tmp_path, {"app.py": "from lib import collect as c\nc(1)\nc(2)\n"}
+    )
+    assert len(calls["c"]) == 2
+    assert len(calls["collect"]) == 2
+
+
+def test_an_import_without_an_alias_is_indexed_exactly_once(tmp_path):
+    calls = project(
+        tmp_path, {"app.py": "from lib import collect\ncollect(1)\ncollect(2)\n"}
+    )
+    assert len(calls["collect"]) == 2
+
+
+def test_a_star_import_resolves_nothing(tmp_path):
+    """A star import names no local alias, so there is nothing to resolve."""
+    calls = project(tmp_path, {"app.py": "from lib import *\nc(1)\n"})
+    assert len(calls["c"]) == 1
+    assert len(calls["collect"]) == 0
+
+
 # --------------------------------------------------------------------------
 # The pass must not disturb anything else.
 # --------------------------------------------------------------------------