Namespace-aware C# type-reference resolution

[pbednarcik]

Summary

C# type references resolve by bare name, so when several types share a name across namespaces — routine in module-per-domain solutions, where each module declares its own XProfile / XConfiguration — the ranker ties and falls to the lexicographically-smallest ID. Measured on a real solution: all 9 references to one module's mapping profile bound to a sibling module's same-named profile, leaving the real target a dead-code false positive and giving the rival 9 phantom callers.

The evidence to disambiguate is already in the graph: every using directive is an EdgeImports off the file node, and every C# type carries Meta["scope_ns"]. This PR joins the two in a narrowing step that applies the compiler's own lookup order — written qualifier, then enclosing namespaces (deepest wins), then using directives — ahead of bestTypeCandidate's ranking. Same narrowing-only contract as phpNarrowByTargetFQN: when no candidate namespace is visible, the previous ranking stands untouched, so a binding can sharpen but never be lost.

Changes

• csharpNarrowByNamespace (csharp_ns_narrow.go), hooked beside the PHP narrow in resolveTypeOrFunc and resolveTypeRef. Only type/interface candidates in the dotnet family participate — methods carry scope_ns too and would otherwise steal the bind (or lose the edge on the type-only path). Per-file namespace sets are memoised behind an RWMutex (built lazily inside the parallel workers, cleared with the per-pass lookup caches — the importFilesByCaller discipline).
• Using evidence rides the file node as Meta["usings"], stamped at extraction with C# visibility semantics (aliases and using static excluded — they grant no bare-name namespace visibility). The per-directive import edges are not a stable source: resolveImport rewrites one to a file-node target whenever the namespace tail matches a directory basename — the standard folder-mirrors-namespace layout — which would silently and order-dependently empty the tier. Edge shapes remain a fallback for pre-stamp graphs.
• Enclosing namespaces outrank usings: the compiler searches inner scopes first, so an internal type in the file's own namespace must shadow a public same-named type in an imported one — the exported-first ranker was inverting that on real code.
• fix(csharp): C#10 file-scoped namespaces (namespace X;) never got scope_ns — the governed declarations are AST siblings of the directive, not children, so the ancestor walk missed them. Every type in such files was invisible to any namespace evidence (and to the scope_ns-keyed partial merge). Nested block namespaces now also join outer-to-inner (A.B, previously the bare inner segment).
• Qualified spellings keep their namespace: canonicalisation stripped A.B.Foo to Foo, discarding the one namespace fact the source states outright — and aggregator-style files qualify precisely because they import nothing. The dotted spelling rides Meta["target_fqn"] on reference, instantiates, and base-list edges (the key the PHP extractor already uses; the PHP reader now rejects dotted C# qualifiers) and narrows by dot-boundary suffix first, covering C#'s partially-qualified forms.

Known gaps (documented, not silent)

• Alias visibility (using X = Full.Name;) is not modelled — aliases are excluded from the using set rather than misread as namespace imports; a file importing only via aliases falls back to the previous ranking. global using counts for its declaring file only.
• Cross-assembly visibility (internal types across project boundaries) is not consulted — candidates are namespace-filtered, not assembly-filtered.
• A qualifier naming a nested type (Ns.Outer.Inner) reads Ns.Outer as a namespace; standard namespace-qualified spellings are unaffected.
• Types in the global namespace carry no scope_ns and never match a tier; they resolve exactly as before.
• Namespace sets are per file, not per site — a file declaring several sibling namespace blocks uses their union.

Real-world results (reference Autofac + EF solution, 10,375 files)

• The flagship misbind: 9/9 references to a module's mapping profile bound to the wrong module before, 9/9 to the right one after.
• Same-named-profile false dead-code positives: 39 → 2 — and both survivors were verified genuinely unregistered types (real dead code the misbinds had been masking).
• The enclosing-vs-imported case (internal own-namespace type vs public imported rival): 4/4 references corrected.
• A fully-qualified registration in an aggregator file (imports nothing, qualifies everything) bound exactly; it bound to an arbitrary same-named type before.
• Types in file-scoped-namespace files went from no scope_ns at all to fully resolvable.

Testing

• All tests pass (go test -race ./...) — Linux-equivalent scope; Windows dev box shows only the known pre-existing failures
• New tests: 10 resolver tests (using-directive pick, extends path, enclosing chain incl. deepest-wins, enclosing-beats-imported, full + partial qualifier, rewritten-import shape, method-decoy guard, external:: fallback, never-lose fallback) and 6 extractor tests (file-scoped + nested-block scope_ns, usings Meta incl. alias/static exclusion, qualified-spelling target_fqn on reference and base-list forms)

Checklist

• Code follows existing patterns (mirrors the PHP target-FQN narrow and the Razor using pass; cache mirrors importFilesByCaller)
• No unnecessary abstractions added