feat(extractor): load extra reference assemblies via OWN_EXTRA_REF_DIRS (WPF unlock)

The extractor built its reference set purely from the runtime TPA, so WPF
framework events/timers (Button.Click, DispatcherTimer.Tick) couldn't bind and
fell out as OWN050 on real WPF apps — blinding the flagship subscription/timer
detectors. Now it also loads *.dll from each dir in OWN_EXTRA_REF_DIRS (colon-
separated), deduped by simple name against the TPA so System.* isn't double-
referenced. Unset => unchanged behaviour (the whole existing suite is the guard).

mine-on-push materializes the WindowsDesktop ref pack on Linux (a net8.0-windows
/UseWPF stub restores it via EnableWindowsTargeting -> 47 ref dlls) and exports
the dir as OWN_EXTRA_REF_DIRS. Re-mining ScreenToGif with the pack loaded.

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

Author: claude

.github/workflows/mine-on-push.yml

@@ -30,15 +30,12 @@ jobs:
       - uses: actions/setup-dotnet@v4
         with:
           dotnet-version: "8.0.x"
-      - name: Probe WPF reference assemblies (TEMP — for the WPF unlock)
-        continue-on-error: true
+      - name: Materialize WPF reference assemblies (WPF profile)
         run: |
-          root="${DOTNET_ROOT:-/usr/share/dotnet}"
-          echo "DOTNET_ROOT=$root"
-          echo "::group::Already in the SDK packs?"
-          find "$root/packs" -ipath '*WindowsDesktop.App.Ref*' -name 'PresentationFramework.dll' 2>/dev/null | head || echo "(none in SDK packs)"
-          echo "::endgroup::"
-          echo "::group::Restore a net8.0-windows/UseWPF stub (EnableWindowsTargeting)"
+          # The WindowsDesktop ref pack isn't in the Linux SDK, but a net8.0-windows
+          # /UseWPF stub restores it cross-platform (EnableWindowsTargeting). Export
+          # the ref dir so the extractor (OWN_EXTRA_REF_DIRS) can resolve WPF events
+          # and timers instead of dropping them as OWN050.
           tmp=$(mktemp -d)
           printf '%s\n' \
             '<Project Sdk="Microsoft.NET.Sdk">' \
@@ -47,18 +44,15 @@ jobs:
             '    <UseWPF>true</UseWPF>' \
             '    <EnableWindowsTargeting>true</EnableWindowsTargeting>' \
             '  </PropertyGroup>' \
-            '</Project>' > "$tmp/probe.csproj"
-          dotnet restore "$tmp/probe.csproj" 2>&1 | tail -8 || echo "RESTORE FAILED"
-          echo "::endgroup::"
-          echo "::group::Where did the WPF ref assemblies land?"
-          d=$(find "$root/packs/Microsoft.WindowsDesktop.App.Ref" -type d -name 'net8.0' 2>/dev/null | head -1)
-          [ -z "$d" ] && d=$(find "$HOME/.nuget/packages/microsoft.windowsdesktop.app.ref" -type d -name 'net8.0' 2>/dev/null | head -1)
-          echo "WPF ref dir: ${d:-NONE FOUND}"
+            '</Project>' > "$tmp/wpfref.csproj"
+          dotnet restore "$tmp/wpfref.csproj" >/dev/null 2>&1 || echo "wpf-ref restore failed (continuing without)"
+          d=$(find "$HOME/.nuget/packages/microsoft.windowsdesktop.app.ref" -type d -name 'net8.0' 2>/dev/null | sort | tail -1)
           if [ -n "$d" ]; then
-            echo "count of ref dlls: $(find "$d" -name '*.dll' | wc -l)"
-            ls "$d" | grep -iE 'Presentation|WindowsBase|System.Xaml|System.Windows' | head -20
+            echo "OWN_EXTRA_REF_DIRS=$d" >> "$GITHUB_ENV"
+            echo "WPF refs ready: $d ($(find "$d" -name '*.dll' | wc -l) dlls)"
+          else
+            echo "WPF refs NOT found — the mine will run without them (OWN050 on framework types)"
           fi
-          echo "::endgroup::"
       - name: Read & validate the target
         id: target
         run: |

corpus/mine-target.txt

@@ -2,4 +2,5 @@
 # First non-comment line: a GitHub "owner/repo" or an https git URL. One repo/run.
 # Optional lines: ref=<branch|tag|sha>, paths=<subdir of the target to scan>.
 # Bump this file (commit + push) to kick off a mine; read the result in the run log.
+# cycle: re-mine WITH the WPF reference pack loaded (OWN_EXTRA_REF_DIRS).
 NickeManarin/ScreenToGif

frontend/roslyn/OwnSharp.Extractor/Program.cs

@@ -415,11 +415,28 @@ t is "IDisposable" or "IAsyncDisposable" or "CancellationTokenSource"
 // in-project types and BCL events; external types (WPF/DevExpress) stay
 // unresolved and are surfaced as OWN050 "unchecked", never guessed as leaks.
 // Error-tolerant: compile diagnostics are irrelevant — we only read symbols.
-var references = ((AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string) ?? "")
+var tpa = ((AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string) ?? "")
     .Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)
     .Where(p => p.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
-    .Select(p => (MetadataReference)MetadataReference.CreateFromFile(p))
     .ToList();
+var refNames = new HashSet<string>(tpa.Select(Path.GetFileName), StringComparer.OrdinalIgnoreCase);
+var references = tpa.Select(p => (MetadataReference)MetadataReference.CreateFromFile(p)).ToList();
+// P-004 WPF profile: widen the reference set with assemblies named by the
+// OWN_EXTRA_REF_DIRS env var (colon-separated dirs) — e.g. the WindowsDesktop ref
+// pack — so framework events/timers (Button.Click, DispatcherTimer.Tick) resolve to
+// real symbols instead of surfacing as OWN050 on a WPF app. Additive and best-
+// effort: unset => unchanged behaviour; a DLL whose simple name a TPA reference
+// already provides is skipped so System.* is not double-referenced from two packs.
+foreach (var dir in (Environment.GetEnvironmentVariable("OWN_EXTRA_REF_DIRS") ?? "")
+             .Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries))
+{
+    if (!Directory.Exists(dir)) continue;
+    var added = 0;
+    foreach (var dll in Directory.EnumerateFiles(dir, "*.dll"))
+        if (refNames.Add(Path.GetFileName(dll)))
+        { references.Add(MetadataReference.CreateFromFile(dll)); added++; }
+    Console.Error.WriteLine($"extractor: +{added} extra references from {dir}");
+}
 var compilation = CSharpCompilation.Create(
     "own", parsed.Select(p => p.tree), references,
     new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));