fix(extractor): resolve AssociatedObject's binding before exempting it (#227, Codex P2)

IsAssociatedObjectAccess matched the identifier `AssociatedObject` purely by text,
so a local, a parameter, or a hidden member DECLARED in the Behavior subclass named
`AssociatedObject` — holding an injected publisher, not the inherited accessor —
would wrongly pass the self-owned-source gate (`void Wire(UiElement AssociatedObject)
{ AssociatedObject.Loaded += H; }`). That source is not co-lifetimed with the
behavior, so the subscription must stay flagged.

The name match now consults the symbol: the genuine base accessor is either
UNRESOLVED (null — the Interactivity assembly is absent on the runner, the normal
WPF case) or an INHERITED member (containing type is a base, not this class); a
local/parameter binding, or a member declared on this class, is a shadow and denies
the exemption. Conservative — an unresolvable symbol keeps today's behaviour.

New flagged control ShadowParamBehavior (a parameter named AssociatedObject) +
a CI assertion. Verified with the real extractor: all five controls warn, the three
positives stay silent; full-sample-set output still byte-identical to main.

Refs #227

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01U2AWb9N2VUsby2XpdftBcu

Author: claude

.github/workflows/ci.yml

@@ -909,6 +909,11 @@ jobs:
           # source before the `+=` — the stale declaration binding must not exempt.
           echo "$out" | grep -qE "AssociatedObjectSourceSample\.cs:[0-9]+: warning: \[OWN001\].*'ReassignedLocalBehavior'" \
             || { echo "FAIL: expected OWN001 when the AssociatedObject-bound local is reassigned before the +="; exit 1; }
+          # (4, Codex P2) a PARAMETER named `AssociatedObject` SHADOWS the inherited base
+          # accessor — the name matches by text, but the symbol is an injected parameter,
+          # so the exemption must resolve the binding, not just the name.
+          echo "$out" | grep -qE "AssociatedObjectSourceSample\.cs:[0-9]+: warning: \[OWN001\].*'ShadowParamBehavior'" \
+            || { echo "FAIL: expected OWN001 when a shadowing parameter is named AssociatedObject (#227)"; exit 1; }
           echo "OK: real C# -> facts -> OWN001 (subscription + timer + field + Subscribe + pool + local) + OWN014 (static-event region escape) + DI001 (captive dependency) + DI002 (scoped captured weakly) + DI003 (transient IDisposable captured by a singleton) + DI004 (transient IDisposable service-located from the root provider) + DI005 (scoped service cached from a created scope) + [OwnIgnore] suppression (silent-but-counted, SARIF suppressions) + #218 DP old->new subscription rotation (silent; controls flagged) + #225 empty-Dispose local exemption (silent; controls flagged) + #228 curated app-scoped source in App (silent; controls flagged) + #227 self-owned Behavior.AssociatedObject source (silent; controls flagged) at the C# location"
       - name: Flow-sensitive local IDisposables (--flow-locals, P-016 B0b/B2)
         run: |

frontend/roslyn/OwnSharp.Extractor/Program.cs

@@ -1040,20 +1040,42 @@ static bool IsBehaviorSubscriber(TypeDeclarationSyntax cls)
 };
 
 // #227: a bare/`this`-qualified read of the base-class `AssociatedObject` accessor —
-// `this.AssociatedObject` or `AssociatedObject`. Matched by NAME (the property is
-// inherited from the unresolved `Behavior` base), through casts/`!`. A member access
-// qualified with anything else (`other.AssociatedObject`) reaches ANOTHER object and
-// is not this behavior's own attached element, so it is rejected.
-static bool IsAssociatedObjectAccess(ExpressionSyntax expr)
+// `this.AssociatedObject` or `AssociatedObject`. The NAME is matched syntactically (the
+// property is inherited from the `Behavior` base, which does not resolve on the Linux
+// runner), through casts/`!`. A member access qualified with anything else
+// (`other.AssociatedObject`) reaches ANOTHER object and is rejected.
+//
+// But the name alone is not enough: a local, a parameter, or a hidden member DECLARED in
+// this class named `AssociatedObject` can SHADOW the inherited accessor and hold an
+// injected publisher (`void Wire(UiElement AssociatedObject) { AssociatedObject.Loaded +=
+// H; }`) — that source is NOT co-lifetimed with the behavior (Codex P2). So the symbol is
+// checked: the genuine base accessor is either UNRESOLVED (null — the Interactivity
+// assembly is absent, the normal WPF case) or an INHERITED member (containing type is a
+// base, not this class); a local/parameter binding, or a member declared on this class,
+// is a shadow and denies the exemption.
+static bool IsAssociatedObjectAccess(ExpressionSyntax expr, SemanticModel model,
+                                     TypeDeclarationSyntax clsNode)
 {
     expr = StripCasts(expr);
-    return expr switch
+    var nameMatches = expr switch
     {
         MemberAccessExpressionSyntax m => m.Name.Identifier.Text == "AssociatedObject"
             && m.Expression is ThisExpressionSyntax,
         IdentifierNameSyntax id => id.Identifier.Text == "AssociatedObject",
         _ => false,
     };
+    if (!nameMatches)
+        return false;
+    var sym = model.GetSymbolInfo(expr).Symbol;
+    if (sym is null)
+        return true;                       // unresolved inherited accessor (the WPF runner case)
+    if (sym is ILocalSymbol or IParameterSymbol)
+        return false;                      // a shadowing local/parameter, not the accessor
+    if (sym is IFieldSymbol or IPropertySymbol
+        && model.GetDeclaredSymbol(clsNode) is { } clsSym
+        && SymbolEqualityComparer.Default.Equals(sym.ContainingType, clsSym))
+        return false;                      // a hidden own member shadowing the accessor
+    return true;                           // an inherited (or resolvable base) accessor
 }
 
 // #227: does `expr` provably resolve to `this.AssociatedObject` — directly, or through
@@ -1070,7 +1092,7 @@ static bool ResolvesToAssociatedObject(ExpressionSyntax expr, SemanticModel mode
     if (depth > 4)
         return false;
     expr = StripCasts(expr);
-    if (IsAssociatedObjectAccess(expr))
+    if (IsAssociatedObjectAccess(expr, model, clsNode))
         return true;
     var sym = model.GetSymbolInfo(expr).Symbol;
     if (sym is ILocalSymbol local)

frontend/roslyn/samples/AssociatedObjectSourceSample.cs

@@ -141,4 +141,18 @@ protected void OnAttached()
 
         void OnLoaded(object? sender, EventArgs e) { }
     }
+
+    // CONTROL 4 (flagged, Codex P2): a PARAMETER named `AssociatedObject` SHADOWS the
+    // inherited base accessor — the identifier text matches, but the symbol is an
+    // injected parameter, not the co-lifetimed attached element, so the exemption must
+    // check the binding, not just the name.
+    public class ShadowParamBehavior : Behavior<UiElement>
+    {
+        public void Wire(UiElement AssociatedObject)
+        {
+            AssociatedObject.Loaded += OnLoaded;             // OWN001: shadowing parameter
+        }
+
+        void OnLoaded(object? sender, EventArgs e) { }
+    }
 }