refactor(extractor): parse XAML structurally for DataContext ownership (CodeRabbit)

Replace the textual regex in XamlDeclaresOwnedDataContext with structural XML parsing
(XDocument), per CodeRabbit's recommendation. Strictly more correct: it inspects only
the ROOT element's own `<Root.DataContext>` (a direct child, in the root's namespace)
and excludes the entire `x:` language namespace — so x:Static / x:Null / x:Reference
(external or shared values the view does NOT own) no longer count as construction,
closing a residual false-negative the regex left open. A malformed `.xaml` parses to
false (conservative). Drops the now-unused Regex import.

Also tighten the InjectedDcView CI assertion to require the OWN001 warning AND the
injected-source wording on that file's line specifically (CodeRabbit nitpick), so the
negative control cannot be satisfied by an unrelated finding.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Rg8kSk1YT14x7A1vo5zgED

Author: claude

.github/workflows/ci.yml

@@ -304,8 +304,8 @@ jobs:
           # negative control: a view whose XAML BINDS its DataContext (`<Binding/>`) does
           # NOT own the VM (it may be externally supplied), so the subscription must
           # still WARN — proving the gate keys off proven construction, not every cast.
-          echo "$out" | grep -qE "InjectedDcViewSample\.xaml\.cs:[0-9]+: warning: \[OWN001\]" \
-            || { echo "FAIL: a bound (unowned) DataContext subscription must still warn"; exit 1; }
+          echo "$out" | grep -qE "InjectedDcViewSample\.xaml\.cs:[0-9]+: warning: \[OWN001\].*injected dependency whose lifetime is unknown" \
+            || { echo "FAIL: a bound (unowned) DataContext subscription must still warn with the injected-source wording"; exit 1; }
           # P-006 DI001 (captive dependency): the registration + constructor graph
           # extracted from DiCaptiveSample.cs feeds ownlang/di.py. A singleton that
           # captures a scoped service — directly, transitively through a transient,

frontend/roslyn/OwnSharp.Extractor/Program.cs

@@ -24,7 +24,7 @@
 // repo (this is what the `own-check` script / GitHub Action do).
 
 using System.Text.Json;
-using System.Text.RegularExpressions;
+using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -243,40 +243,33 @@ BinaryExpressionSyntax b when b.IsKind(SyntaxKind.AsExpression) => b.Left,
 
 // P-004 WPF MVVM ownership: does this XAML construct its own DataContext inline —
 // `<Root.DataContext><vm:Foo/></Root.DataContext>` — so the view OWNS its view-model
-// (a collectable view<->VM cycle)? Restricted to the ROOT element's DataContext: the
-// code-behind's `this.DataContext` is the root's, so only the root's own constructed
-// DataContext proves ownership. A NESTED element's `<Grid.DataContext><ChildVm/>` sets
-// a DIFFERENT element's DataContext and must NOT exempt the view (Codex) — else a real
-// leak on the root's injected VM is silently dropped. True only when the root's
-// property-element child is a TYPE instantiation, not a binding / resource reference
-// (those point at an external or inherited value the view does NOT own). Matched
-// textually (no XAML parser): the property-element form `.DataContext>` denotes inline
-// construction; the `DataContext="{Binding}"` attribute form never matches.
-// Conservative — an unrecognised shape yields false (no exemption), never a
-// wrongly-suppressed leak.
+// (a collectable view<->VM cycle)? Parsed structurally (XAML is XML), restricted to the
+// ROOT element's own DataContext: the code-behind's `this.DataContext` is the root's, so
+// a nested `<Grid.DataContext><ChildVm/>` (a different element's) must NOT exempt the
+// view (Codex / CodeRabbit) — else a real leak on the root's injected VM is dropped.
+// True only when the root's DataContext child is a constructed object that the view owns:
+// NOT a binding / resource reference, and NOT an `x:`-namespace language object
+// (`x:Static`, `x:Null`, `x:Reference`, ...), which name an external/shared value. A
+// malformed `.xaml` yields false (conservative — no exemption, never a dropped leak).
 static bool XamlDeclaresOwnedDataContext(string xaml)
 {
-    // Strip comments / processing instructions so `<Foo.DataContext>` text inside a
-    // comment (or `<?xml?>`) cannot be mistaken for markup, nor skew the root search.
-    xaml = Regex.Replace(xaml, @"<!--.*?-->", " ", RegexOptions.Singleline);
-    xaml = Regex.Replace(xaml, @"<\?.*?\?>", " ", RegexOptions.Singleline);
-    // The root element is the view type (its x:Class is the code-behind). Find its tag
-    // (the first element open — not `</close>`), then match ONLY `<Root.DataContext>`.
-    var rootMatch = Regex.Match(xaml, @"<\s*([A-Za-z_][\w:]*)");
-    if (!rootMatch.Success)
+    XDocument doc;
+    try { doc = XDocument.Parse(xaml); }
+    catch (System.Xml.XmlException) { return false; }
+    var root = doc.Root;
+    if (root is null)
         return false;
-    var root = Regex.Escape(rootMatch.Groups[1].Value);
-    foreach (Match m in Regex.Matches(xaml,
-                 $@"<\s*{root}\s*\.\s*DataContext\s*>\s*<\s*(?:[\w]+:)?([\w.]+)"))
-    {
-        var name = m.Groups[1].Value;
-        var local = name.Contains('.') ? name[(name.LastIndexOf('.') + 1)..] : name;
-        if (local is not ("Binding" or "MultiBinding" or "PriorityBinding"
-                or "StaticResource" or "DynamicResource" or "RelativeSource"
-                or "TemplateBinding" or "Reference" or "Null"))
-            return true;
-    }
-    return false;
+    // The root's OWN `<Root.DataContext>` property-element (a direct child of the root,
+    // in the root's namespace) — not a nested element's, not another property.
+    var dc = root.Element(root.Name.Namespace + (root.Name.LocalName + ".DataContext"));
+    var child = dc?.Elements().FirstOrDefault();
+    if (child is null)
+        return false;
+    if (child.Name.NamespaceName == "http://schemas.microsoft.com/winfx/2006/xaml")
+        return false;   // x:Static / x:Null / x:Reference / x:Type / ...
+    return child.Name.LocalName is not ("Binding" or "MultiBinding" or "PriorityBinding"
+        or "StaticResource" or "DynamicResource" or "RelativeSource"
+        or "TemplateBinding" or "Reference" or "Null");
 }
 
 // P-004 severity tiering: of the subscriptions that survive the self-owned and