Answer the Navigate To search that runs while the solution loads

[xperiandri]

Draft: it cannot build against the Roslyn this repository references yet. dotnet/roslyn#85213,
the contract this implements, merged on 2026-09-09, but main still builds against Roslyn
5.12.0-1.26428.6 (dotnet/roslyn@92a36ef, 2026-08-28), which predates it. It needs the next
dependency update from dotnet/roslyn. The diff also carries #20409, see What you are looking at.

Navigate To runs a search of its own while a solution is still loading, and F# contributes nothing to
it. NavigateToSearcher dispatches that phase through IAdvancedNavigateToSearchService, which the
F# language service does not implement, so every F# project is reported complete and searched not at
all. No full search follows — that is deliberate on the Roslyn side ("Telemetry shows no meaningful
change if we do a full search after this point") — so on a large solution Ctrl+T lists nothing F#
declares until the user searches again.

The search itself was never the problem: it is a parse away, and it needs no type checking. What it
lacked is the project's compilation options, which do not exist yet during load, so
GetFSharpParseResultsAsync raises. GetFSharpQuickParseResultsAsync parses with whatever parsing
options the project system has already produced, or defaults — a dictionary read, no reactor, no I/O,
which is what makes it safe to call for every document of every project while the solution loads.

Those defines can be the wrong ones, and the document's version does not change when the real options
arrive, so a version stamp alone would let an approximate parse answer the accurate search: a
declaration behind #if could be missed, or reported from a branch that never compiles. The cache
entry now carries whether it was approximate, and the accurate path refuses those and reparses. The
loading path takes either, since its contract allows out-of-date results.

SearchCachedDocumentsAsync follows the shape of the C# and VB service: priority documents and the
projects holding them are searched first, results are reported per document rather than per project so
the first ones appear while the rest are still parsing, and each project is reported complete once its
documents are done. The parses of every project take turns on one throttle that leaves a core free, so
a search during load cannot take the cores away from the load itself.

What you are looking at

The branch is main plus the commits of #20409, which adds FSharpNavigableItemsCache, the
per-document parse cache this extends, and two commits of its own:

• Give the quick parsing options the file they parse. A project with no options yet got quick
  parsing options with no source files, and ParseFile throws looking for the last compiland. Nothing
  parsed with them before a project had loaded; the loading search does.
• Answer the Navigate-To search that runs while the solution loads, the change itself.

Once #20409 merges, the diff is those two commits.

Verification

Against a local build of Roslyn that contains dotnet/roslyn#85213:

• NavigateToSearchWhileLoadingTests, three tests: the loading search finds a declaration where the
  accurate search raises for want of options; a file behind #if FOO read under the wrong defines
  returns nothing and does not poison the accurate search that follows once --define:FOO arrives;
  and every project is reported complete exactly once whether or not anything was found in it. With
  the approximate check removed, the first two fail.
• With NavigateToSearchServiceTests and CopilotContextProviderTests, 31 pass. The full
  FSharp.Editor.Tests run: 7219 passed, 2 skipped, 4 failed — fsiShouldTriggerCompletionInFsxFile
  and three type provider tests, which fail the same way on this branch's base without its commits.
• FSharp.Editor builds with -p:Optimize=true.

Checked live as well, on the branch this was first written on, with the Roslyn build deployed to the
experimental hive: on a 26-project mixed C#/F# solution, breaking in the F# implementation gives the
stack ProcessOrderedProjectsAsync → NavigateToSearcher.SearchCachedDocumentsAsync → the external
access adapter → here, with the active document and priority documents intact, and Ctrl+T lists F#
declarations immediately while the solution is still loading.

🤖 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:

Warning

No PR link found in some release notes, please consider adding it.

Change path	Release notes path	Description
`src/Compiler`	docs/release-notes/.FSharp.Compiler.Service/11.0.100.md	No current pull request URL (#20492) found, please consider adding it
`vsintegration/src`	docs/release-notes/.VisualStudio/18.vNext.md