a parameter its own body rebinds stands for no one value, so it keeps no bound

`body_parameter_constraints` already computes `single_bindings` — a name bound more than
once cannot stand for one value — and applied it to every local except the parameter
itself. this applies it there too, which is the rule the file already states rather than
an exception carved for this case.

measured over the 153 top-level stdlib modules, two binaries from one tree: 5041
diagnostics to 4790. **−254 by location and +3**, across 41 modules. the other 46 of the
49 added lines are the same diagnostic at the same file:line:col with a differently
rendered type, and read better for it — `has no attribute 'startswith'` on `object`
becomes `not defined on 'None' in union 'Unknown | str | None'`, which names the actual
bug in `inspect.getsourcefile`'s None return. all 3 genuinely new ones are correct.

of the 254 removed, about 249 are false positives and 5 are real. the strongest thing lost
is `code._showtraceback`, where `sys.exc_info()` gives `BaseException | None` against a
body calling `value.with_traceback(tb)` — and that only survived because the same body's
rebinding was not reachable above it.

⚠️ this masks rather than fixes. two of the three false-positive families it removes have
nothing to do with rebinding: a recovered protocol records no `__getitem__`, no operator
dunders and no `__iter__`, and a member called twice is pinned to the first call's
argument types. both still fire on a parameter nobody rebinds. a third family is genuinely
caused by rebinding — a rebind inside a loop retroactively hides a requirement at the loop
head, so `ast.visit_If` ends up contradicting its own recovered signature above the line
that rebinds.

the narrower rule — drop the bound only when the rebinding reads a member off the name —
was built and measured: 109 removals, a strict subset, and it loses the two `code.py`
signals anyway (`value = value.with_traceback(tb)` is that shape) while keeping ~145 of
the false positives. strictly worse on every axis.

Author: KotlinIsland

crates/ty_python_semantic/resources/mdtest/basedpython_sound_types.md

@@ -567,6 +567,50 @@ def f(x):
 f("anything")  # ok
 ```
 
+### a parameter its own body rebinds says nothing
+
+a name bound more than once cannot stand for one value, which is already why a reassigned local
+contributes nothing. a parameter is no different once its own body rebinds it: below the rebinding
+the name is whatever the rebinding produced, so what is done with it there requires nothing of what
+the caller passed
+
+keeping the requirements collected *above* the rebinding would not do either. walking a traceback
+requires only that the argument have a `tb_next`, so the rebinding lands on that member's type —
+which is `object`, because nothing said what it holds — and the read below it then fails against the
+bound the function itself produced
+
+```py
+def deepest(tb):
+    if tb.tb_next:
+        tb = tb.tb_next
+    return tb.tb_frame
+
+deepest("anything")  # ok
+```
+
+the same holds when the member is a method, which is the shape most of these take
+
+```py
+def rebound(x):
+    x.foo()
+    x = x.foo()
+    x.foo()
+
+rebound("anything")  # ok
+```
+
+the rebinding does not have to be reachable, or to come from the parameter, for the name to stop
+standing for one value
+
+```py
+def maybe(x, flag):
+    x.foo()
+    if flag:
+        x = 1
+
+maybe("anything", True)  # ok
+```
+
 ### a recursive call does not constrain
 
 ```py

crates/ty_python_semantic/src/types/inferred_signature.rs

@@ -393,8 +393,8 @@ pub(crate) fn body_parameter_constraints<'db>(
 
     // a name bound more than once cannot stand for one value: which of them a later use is
     // about is not a question this can answer
-    let single_bindings = index
-        .place_table(body_scope.file_scope_id(db))
+    let place_table = index.place_table(body_scope.file_scope_id(db));
+    let single_bindings: FxHashSet<Name> = place_table
         .symbols()
         .filter(|symbol| symbol.is_bound() && !symbol.is_reassigned())
         .map(|symbol| symbol.name().clone())
@@ -431,13 +431,26 @@ pub(crate) fn body_parameter_constraints<'db>(
     entries.extend(asserted_parameter_types(db, env, index, body_scope, node));
 
     // a parameter a nested scope captured keeps nothing: that body is checked against this
-    // bound, and this walk never saw what it does with the name
-    if !collector.captured.is_empty() {
-        entries.retain(|(parameter, _)| {
-            parameter_definition_name(db, *parameter)
-                .is_none_or(|name| !collector.captured.contains(&name))
-        });
-    }
+    // bound, and this walk never saw what it does with the name.
+    //
+    // a parameter its own body rebinds keeps nothing either, for the same reason a rebound
+    // local does. after
+    //
+    //     while tb.tb_next:
+    //         tb = tb.tb_next
+    //
+    // the name stands for whatever the rebinding produced, not for what the caller passed, so
+    // the uses below it are no requirement on the argument — and bounding the argument by them
+    // anyway makes the body fail against its own bound, because the rebinding lands on the
+    // member type the bound itself invented
+    entries.retain(|(parameter, _)| {
+        parameter_definition_name(db, *parameter).is_none_or(|name| {
+            !collector.captured.contains(&name)
+                && place_table
+                    .symbol_id(name.as_str())
+                    .is_some_and(|symbol| !place_table.symbol(symbol).is_reassigned())
+        })
+    });
 
     entries.sort_by_key(|(parameter, _)| *parameter);
 

docs/basedpython/features/sound-types.md

@@ -174,6 +174,19 @@ that a member's value was given to is read the same way: a name bound more than
 for one value, and a use under a narrowing is about something narrower than the value it was bound
 to
 
+a parameter its own body rebinds keeps nothing at all, for the same reason. the reads above the
+rebinding are not enough on their own: walking a linked structure asks only that the argument have
+the member it walks along, so the rebinding lands on that member — whose value nothing described —
+and the walk's next step would fail against the signature the function itself produced
+
+```python
+def deepest(tb):
+    if tb.tb_next:
+        tb = tb.tb_next
+    return tb.tb_frame
+# def deepest(tb)
+```
+
 ### an `assert` at the top of the body
 
 an `assert` there holds for every call that returns normally, so it is the author saying what they