Search each file of a multi-targeted F# project once in Find All References and Rename

[xperiandri]

Find All References and Rename on a symbol of a multi-targeted F# project did every piece of work once per target framework instance — measured at 86 instances of 26 project files (1246 documents) for a scope of two projects, with Roslyn's window hiding the duplicate results and the user only seeing the time.

Each project file's instances now share one full search plus the files that can differ between them — compiled only in one, or conditionally on a define the two disagree on; the rest of the search is skipped, and a use is reported once per range no matter how many instances or project files compile the file that has it. Rename needs no separate change: it already merges the edits of linked documents.

With the option that enables this off, every instance is still searched in full, but the concurrency bound now applies across the solution rather than per project. With it on, an instance can in principle resolve an overload differently without any #if — an extension member shadowed by a newer BCL intrinsic; turning the option off restores the full search.

No timings are claimed for the change itself: the instance count above is what the search scope becomes (86 → 26, plus the conditional and instance-only files of the other 60). The first commit (test helpers) is shared with #20462 and #20463.

🤖 Generated with Claude Code

[github-actions]

❗ Release notes required

You can open this PR in browser to add release notes: open in github.dev

---

✅ Found changes and release notes in following paths:

Change path	Release notes path	Description
`vsintegration/src`	docs/release-notes/.VisualStudio/18.vNext.md

[T-Gro]

🤖🕵️ [P1] Rename leaves the other target uncompilable when an earlier file changes a shared consumer’s inferred type. Compile these files in order in two instances, only one defining FOO, then rename A.Record.value from the instance without FOO: BASE returns three ranges; HEAD omits Second.fs, and renaming to renamed leaves FS0039 in the FOO instance. A consumer without directives still needs searching when its dependencies differ.

// First.fs
module First
module A =
    type Record = { value: int }
module B =
    type Record = { value: int }
#if FOO
let input : A.Record = { value = 1 }
#else
let input : B.Record = { value = 1 }
#endif

// Second.fs
module Second
let output = First.input.value

[xperiandri]

You are right, and I think your example rules out the narrower fix I would have reached for.

My first instinct was to keep the skip and tighten the predicate — compare the defines the two instances actually differ in, rather than asking whether the file contains any #if at all. Second.fs kills that: it has no directives, and nothing about the file itself says its meaning depends on FOO. The difference arrives through First.fs, so any predicate that looks at the candidate file alone is unsound. Making it sound means asking whether the file's transitive dependencies resolve identically in both instances, which is the type check I am trying to avoid running.

So the honest options are:

1. Skip an instance's file only when that instance is identical to the owner in both defines and file set. Correct, and it keeps the win for the case where two instances really are the same (the same defines under two target frameworks, which does happen), but on a genuinely multi-targeted project it degenerates to searching everything — the PR stops delivering what its title claims.
2. Drop the skip and find the saving somewhere that does not change results. For Find All References and Rename I do not see one: the cost here is the per-instance type check, and with different defines those check results genuinely differ, so there is nothing to share.

Unless you see a third option, I would rather withdraw this one than ship an unsound filter, and keep the sibling PR for Go To All, where the results come from parsing rather than checking — there the parse of a file with no directives really is instance-independent, so the same file can be parsed once and its items reused, and Roslyn's own NavigateToSearchResultComparer already collapses the duplicate results by file and span.

Two things I should own about the original: the (file, range) result dedup you would expect on the F# side was never there, which is why the filter was carrying that weight, and the #if predicate was far too loose a proxy for "same results" even before your dependency case.

How would you like to proceed?

[xperiandri]

Good catch, thanks — fixed in a670ed8. The per-file predicate was wrong: it only asked whether this file's own #if tests a differing define, but a file with no directives at all can still resolve differently when an earlier file's conditional compilation changes what a shared name means, exactly like your repro.

Replaced it with identicallyCompiledPrefix, which walks SourceFiles in compile order and stops at the first file that can diverge (either its own conditional compilation depends on a differing define, or the two instances' source-file lists themselves differ from that point on); only files before that point are skipped, everything from there on is searched in full.

Added your repro almost verbatim as a test (a file without directives is searched when an earlier file changes what its names mean): Chooser.fs picks A.Record/B.Record under #if FOO, Consumer.fs reads .value with no directives of its own; searching A.Record.value from the instance without FOO now still finds the use in Consumer.fs. Confirmed it fails on the old per-file rule and passes with the fix.

[xperiandri]

Walking back my "fixed in a670ed8" from a few minutes ago — I hadn't seen the fuller analysis above it on this thread when I posted that. identicallyCompiledPrefix does correctly handle the repro you gave, but it doesn't close the gap that reply already identified: it only tracks divergence through #if/file-set, not through referenced assemblies, so it's not actually sound in general.

I went and measured option 1 (skip only when the two instances are identical in both defines and file set) before trying to implement it, since it seemed worth checking whether it degenerates the way the analysis above predicted. It does, completely: built the same trivial two-file project as net472;net9.0, net8.0;net9.0, and compared what fsc.exe actually receives.

• Defines: net472 gets 17 (NETFRAMEWORK, NET47_OR_GREATER, …), net9.0 gets 15 (NETCOREAPP, NET9_0, NET9_0_OR_GREATER, …) — only DEBUG/TRACE in common. Even adjacent net8.0/net9.0 differ (each has its own exact-version symbol and a different _OR_GREATER boundary).
• References: net472 resolves 12, net9.0 resolves 165 — nowhere close by path (different TFM folder) or by count.

So for any two distinct real TargetFrameworks, both signals always say "different," every time — the SDK auto-injects framework-identifying defines specifically so code can branch on them. Option 1 isn't a narrower, safer version of the skip; it's a no-op dressed up as one, and it would ship silently doing nothing on exactly the projects the PR's own numbers were measured against.

I don't see a fourth option beyond the three you laid out, and I'm not going to invent a per-file soundness argument without running the check it's meant to avoid. Moved this to draft for now. Is there an angle I'm missing, or does this settle it — keep #20483 and close this one?

[github-actions]

🔍 Tooling Safety Check — Affects-Design-Time
Affects-Design-Time: Find References and Rename changes execute in IDE workflows.

Generated by PR Tooling Safety Check · gpt56 2.6M · ◷

[T-Gro]

🤖🕵️ If this fixes an issue or implements an RFC/suggestion, link it (Fixes #... when applicable). Otherwise, give a short management-level summary in simplified technical English: what user scenario improves and what this achieves.

Please apply this PR-description guidance. Remove the implementation inventory already visible in Files, but keep necessary scope, compatibility, and dependency caveats.