Answer the Navigate To search that runs while the solution loads

.claude/rules/CcrOptout.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "**"
+---
+
+@../../.github/instructions/CcrOptout.instructions.md

.claude/rules/CodeGen.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/Compiler/CodeGen/**/*.{fs,fsi}"
+---
+
+@../../.github/instructions/CodeGen.instructions.md

.claude/rules/ComponentTests.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "tests/FSharp.Compiler.ComponentTests/**/*.fs"
+---
+
+@../../.github/instructions/ComponentTests.instructions.md

.claude/rules/DebugEmit.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/Compiler/AbstractIL/ilwritepdb.{fs,fsi}"
+---
+
+@../../.github/instructions/DebugEmit.instructions.md

.claude/rules/EngVersioning.md

@@ -0,0 +1,9 @@
+---
+paths:
+  - "eng/Packages.props"
+  - "eng/Versions.props"
+  - "eng/Version.Details.xml"
+  - "eng/Version.Details.props"
+---
+
+@../../.github/instructions/EngVersioning.instructions.md

.claude/rules/ExpertReview.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/Compiler/**/*.{fs,fsi}"
+---
+
+@../../.github/instructions/ExpertReview.instructions.md

.claude/rules/FSComp.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/Compiler/FSComp.txt"
+---
+
+@../../.github/instructions/FSComp.instructions.md

.claude/rules/FSharp.md

@@ -0,0 +1,8 @@
+---
+paths:
+  - "src/**/*.{fs,fsi,fsx}"
+  - "vsintegration/src/**/*.{fs,fsi}"
+  - "tests/**/*.{fs,fsi,fsx}"
+---
+
+@../../.github/instructions/FSharp.instructions.md

.claude/rules/FSharpCore.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/FSharp.Core/**/*.{fs,fsi}"
+---
+
+@../../.github/instructions/FSharpCore.instructions.md

.claude/rules/LSP.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/FSharp.Compiler.LanguageServer/**/*.{fs,fsi}"
+---
+
+@../../.github/instructions/LSP.instructions.md

.claude/rules/NoBloat.md

@@ -0,0 +1,10 @@
+---
+paths:
+  - "src/Compiler/**/*.{fs,fsi}"
+  - "vsintegration/src/**/*.{fs,fsi}"
+  - "tests/FSharp.Compiler.ComponentTests/**/*.fs"
+  - "tests/FSharp.Compiler.Service.Tests/**/*.fs"
+  - "vsintegration/tests/**/*.fs"
+---
+
+@../../.github/instructions/NoBloat.instructions.md

.claude/rules/Optimizer.md

@@ -0,0 +1,6 @@
+---
+paths:
+  - "src/Compiler/Optimize/**/*.{fs,fsi}"
+---
+
+@../../.github/instructions/Optimizer.instructions.md

.claude/rules/SyntaxTree.md

@@ -0,0 +1,9 @@
+---
+paths:
+  - "src/Compiler/SyntaxTree/SyntaxTree.{fs,fsi}"
+  - "src/Compiler/SyntaxTree/SyntaxTreeOps.{fs,fsi}"
+  - "src/Compiler/SyntaxTree/ParseHelpers.{fs,fsi}"
+  - "src/Compiler/pars.fsy"
+---
+
+@../../.github/instructions/SyntaxTree.instructions.md

.claude/rules/TypedTreePickle.md

@@ -0,0 +1,8 @@
+---
+paths:
+  - "src/Compiler/TypedTree/TypedTreePickle.{fs,fsi}"
+  - "src/Compiler/TypedTree/TypedTree.{fs,fsi}"
+  - "src/Compiler/Driver/CompilerImports.{fs,fsi}"
+---
+
+@../../.github/instructions/TypedTreePickle.instructions.md

.github/instructions/FSharp.instructions.md

@@ -0,0 +1,90 @@
+---
+applyTo:
+  - "src/**/*.{fs,fsi,fsx}"
+  - "vsintegration/src/**/*.{fs,fsi}"
+  - "tests/**/*.{fs,fsi,fsx}"
+---
+
+# Writing F#
+
+Which constructs to reach for. Code shape and comments are NoBloat's; naming and the abbreviation glossary belong to `docs/coding-standards.md` and `DEVGUIDE.md`.
+
+These rules govern code you write or touch. Do not sweep the codebase to apply them – `CONTRIBUTING.md`: *"DO NOT submit large code formatting changes without discussing with the team first."*
+
+## Tools
+
+When the IDE's F# semantic tools are unavailable, use the `F#` MCP server (`.mcp.json`, FsLangMCP) for navigation, symbol discovery, diagnostics and cross-project usage search. Prefer its semantic tools over plain text search for F#-specific work.
+
+## Strings
+
+- Prefer interpolated strings over `sprintf` and `String.Format`. Use `$"""…"""` when the text itself contains quotes.
+- Format specifiers are valid in interpolated strings and help type inference: `$"count %d{n}"`.
+- `nameof` over a string literal that names a value, member or type.
+- An explicit `StringComparison` on every `Equals`, `StartsWith`, `EndsWith`, `Contains`, `IndexOf` and `Compare`, and an explicit comparer on every `HashSet<string>` and `Dictionary<string, _>`. `Ordinal` by default, `OrdinalIgnoreCase` for identifiers and paths. Culture-sensitive comparison is a decision, never a default.
+
+## Values and types
+
+- `voption` – `ValueSome`/`ValueNone` – over `option` when the value does not escape; it is this compiler's option type. Exception: when an API hands you `'T option` (`Seq.tryHead`, `List.tryFind`), unwrap with `Option.defaultValue`/`Option.defaultWith` directly – do not insert `ValueOption.ofOption` just to switch modules.
+- `struct ('T1 * 'T2)` tuples and `[<Struct>]` types on allocation-sensitive paths.
+- Anonymous struct records (`struct {| … |}`) over bare tuples for multi-value returns of internal helpers. Public FCS surface is governed by `.fsi` files and compatibility – do not change it for style.
+- The compiler generates `IsCaseName` properties (`IsDefault`, `IsCustom`) for DU cases – use them for a specific-case check instead of a full `match`.
+- Deconstruct `KeyValuePair` with the `KeyValue` active pattern: `for KeyValue(k, v) in map do …`.
+- `[<InlineIfLambda>]` on `inline` higher-order helpers whose lambda argument must not become a closure.
+
+## Lambdas and collections
+
+- Prefer the `_.Property` shorthand in pipeline position: `tys |> List.map _.Type`. Complex expressions (`fun x -> x.Name = name`, `fun x -> x.A, x.B`) cannot use it. Never add a space – `_.MethodCall ()` breaks parsing. Unrelated to the `member _.Foo` self-identifier.
+- Eta-reduce: `Seq.map (fun x -> someFunction x)` must become `Seq.map someFunction`.
+- Prefer a single traversal – one `fold`, loop, or comprehension – to a chain of transformations: it allocates nothing per element, where a chain allocates at every stage.
+- When the chain reads better than one pass, route it through `Seq` and materialize once at the end – a `List`/`Array` chain allocates a whole intermediate collection per stage, a `Seq` chain only an enumerator.
+- Concatenate with `[ yield! xs; yield! ys ]` / `seq { yield! xs; yield! ys }` rather than `@` or `Seq.append` – `@` forces both sides to lists and is O(n).
+- Cast sequence items with `Seq.cast<Target>`, not `Seq.map (fun item -> item :> Target)`.
+
+## Async and exceptions
+
+- `src/Compiler` targets `netstandard2.0`: prefer `async { }` and the repo's `cancellable { }` (`src/Compiler/Utilities/Cancellable.fs`). `task { }` appears only in `Service/FSharpProjectSnapshot.fs` and `Service/FSharpWorkspaceQuery.fs` – avoid it elsewhere in new core code.
+- `vsintegration` runs on the VS threading model where `task { }` is at home. When an override must return non-generic `Task`, annotate explicitly – `override _.M(…) : Task = task { … }` – never cast through pipelines.
+- Thread cancellation through; see `ExpertReview.instructions.md`.
+- `reraise ()` does not compile inside a `task`/`async` CE (FS0413). There, rethrow with `ExceptionDispatchInfo.Capture(ex).Throw()`; outside CEs plain `reraise ()` is correct.
+
+## Nullness
+
+Enabled in `src/Compiler`, `src/FSharp.Build`, `src/FSharp.Compiler.LanguageServer`. There:
+
+- Declare non-nullable; check for `null` at entry points. Trust C#/F# annotations – no null checks where the type system says a value cannot be null.
+- Prefer `match x with | null -> … | x -> …` over `isNull` – the match narrows the type, `isNull` does not.
+- Use `withNull` to hint nullability instead of boxing (`isNull (box f)`).
+- Before suppressing a nullness warning (3261, 3262, …), escalate in order: `nonNull value` (runtime assert, fail fast) → `Unchecked.nonNull value` (null provably impossible upstream) → inline `#nowarn`/`#warnon` pair, centralised in one interop helper rather than scattered across call sites.
+
+## Warning suppression
+
+Inline `#nowarn "NN"` / `#warnon "NN"` pairs around the smallest possible scope – they are valid anywhere in an `.fs` file, not only at the top. File-level suppression is a last resort.
+
+## Classes (mostly `vsintegration`)
+
+- Initializer syntax over post-construction property assignment: `MyType(ctorArg, MutableProp1 = v1, MutableProp2 = (5 |> string))` – settable properties by name after positional arguments, computed values in parentheses.
+- Extension members consumable from C#: `[<AutoOpen; Extension>]` module, `[<Extension; CompiledName "…">]` on each member.
+- Prefer a root module (`module Ns.FeatureExtensions`) over `namespace` + a static holder type for extension files; name it after the single target type plus `Extensions`, or after the feature when there are several targets.
+- XML doc comments that use markup (`<see/>`, `<c/>`) need their text wrapped in `<summary>`.
+
+## Opens
+
+Sort into blank-line-separated groups, alphabetically within each: `System.*` → `Microsoft.*` → `Internal.Utilities.*` → `FSharp.Compiler.*` (see the top of `src/Compiler/Service/TransparentCompiler.fs`). `open type` last within its group; type and module aliases at the very end.
+
+## Do not mistake for conventions
+
+This codebase implements every F# feature, so finding one here is no evidence that it is used here. These have no foothold – introducing them is a new pattern, not a continuation:
+
+- `while!` and `and!` – no uses at all; the matches are the parser and the checker implementing them.
+- `[<TailCall>]` – a handful of deliberate assertions on specific recursive functions, not a habit.
+
+## The language version is not uniform
+
+`FSharp.Profiles.props` sets `LangVersion=preview`, but not under `Configuration=Proto` and not when `BUILDING_USING_DOTNET=true`. The compiler bootstraps, so a feature this repository is *adding* cannot be used in its own source until it ships in the SDK compiler named by `global.json` – otherwise the Proto stage fails.
+
+- `src/FSharp.Build` is pinned to `LangVersion 9`; it can load in Visual Studio against an older FSharp.Core.
+- `src/FSharp.Core` leaves nullness off and is bound by `docs/fsharp-core-notes.md`.
+
+## Tests
+
+The ComponentTests DSL and its pipeline are covered by `ComponentTests.instructions.md`. Name tests with backticked spaces: ``let ``Issue 12345 - brief description`` () = …``.

AGENTS.md

@@ -0,0 +1,3 @@
+# Agent Instructions
+
+See [`.github/copilot-instructions.md`](.github/copilot-instructions.md) for build, test, and coding rules for this repository.

CLAUDE.md

@@ -0,0 +1,18 @@
+@.github/copilot-instructions.md
+
+## Visual Studio first
+
+The `vs` MCP server reaches the Visual Studio instance holding this repo's solution. Where it and the shell both work, use it — it reports what the IDE's compiler and symbol graph know, not what the text files say.
+
+- Build with `build_solution` / `build_project` / `build_clean` rather than `dotnet build` or `msbuild`; the Build section above is the fallback for when no solution is loaded (`ide_get_workspace_folders` is empty).
+- Read errors from `ide_get_diagnostics`, not by parsing build output.
+- Navigate and rename with `nav_go_to_definition`, `nav_find_references`, `nav_search_workspace_symbols`, `nav_rename_symbol` — the symbol graph, not `grep` plus hand edits.
+- Format what you touched with `document_format` / `document_organize_imports` before reaching for `dotnet fantomas`.
+
+Before editing a file on disk, `document_check_dirty` it. An unsaved VS buffer is the real content: read it with `document_read_buffer` and `document_save` first, or the edit lands on stale text and the user's next save reverts it.
+
+`build_*` compiles whichever configuration the IDE has active, and `solution_set_configuration` changes it for the user's next manual build too — read `solution_get_configuration` before assuming `Debug`.
+
+`project_add_file` appends without a position, so it cannot place a new `<Compile Include>` correctly in an order-sensitive F# project: add those to the `.fsproj` by hand.
+
+Tests have no IDE path — the `vs` server exposes no Test Explorer tools (https://github.com/Corsinvest/cv4vs-agents/issues/192), so they run through `dotnet test` as described above.

docs/ide/file-watching.md

@@ -0,0 +1,66 @@
+# File watching in FSharp.Editor
+
+`vsintegration/src/FSharp.Editor/LanguageService/FileChangeWatcher.fs` is the F# counterpart of
+Roslyn's `FileChangeWatcher` and `ReferenceFileChangeTracker` (both internal to
+`Microsoft.VisualStudio.LanguageServices` and not exposed through `ExternalAccess.FSharp`).
+
+## What the workspace already gives us
+
+Not every on-disk change needs this watcher. A `-r:` that the Roslyn workspace holds as a
+`MetadataReference` is already watched by Roslyn: `ProjectSystemProjectFactory` advises every
+reference path, and when one changes it swaps the reference on the solution, which bumps
+`Project.Version`. `FSharpProjectOptionsReactor` sees that version through `isProjectInvalidated`,
+recomputes, and calls `InvalidateConfiguration` — measured in VS, that path wins the race against
+a watcher subscribed to the same file, because Roslyn batches over 500 ms where this tracker
+additionally debounces for 2 s.
+
+So a second subscription to the same reference set buys nothing. What the workspace does *not*
+cover is everything it has no document or reference for, and every stat FCS still performs
+internally:
+
+- `#load` sources of a script: not documents, not references, invisible to the workspace.
+- `IsReferencesInvalidated` on the incremental builder, which stats every reference on every
+  request.
+- `ReferencesOnDisk` on snapshot reuse, which did the same per comparison — the consumer below.
+
+## Shape
+
+- **Service.** `IVsAsyncFileChangeEx2`, obtained asynchronously; nothing ever blocks on the UI
+  thread. Callbacks arrive through `IVsFreeThreadedFileChangeEvents2` and stay on background
+  threads.
+- **Batching.** Subscribe/unsubscribe operations go through a single-consumer queue with a 500 ms
+  window (Roslyn's empirical value for solution open/close). Consecutive operations of the same
+  kind, and for file watches the same sink, are coalesced into one service call.
+- **Directory watches.** A context starts with recursive `.dll` watches on the places reference
+  assemblies live: `DOTNET_ROOT/packs` and the machine-wide `dotnet/packs`, the .NET Framework
+  reference assemblies, and the NuGet cache (`NUGET_PACKAGES` or `~/.nuget/packages`). A file
+  under one of them costs no cookie of its own. Roslyn does not watch the NuGet cache; a consumer
+  that watches every `-r:` uniformly wants it, since package assemblies are the bulk of them and
+  the alternative is a per-file advise for each.
+- **Per-file watches.** Paths outside those directories (project outputs, loose assemblies) get
+  an individual advise, ref-counted across consumers by `FSharpReferenceChangeTracker`. The
+  tracker also keeps the last-write stamp of each watched path (see Consumers).
+- **Debounce.** A rebuild writes a temp file and renames it, producing several notifications; the
+  tracker fires one callback per path after 2 s of quiet.
+
+## Consumers
+
+**Snapshot reference stamps.** `FSharpProjectOptionsReactor` watches the `-r:` set of every
+project it computes options for, diffed on recompute so an unchanged set touches nothing. The
+tracker keeps each path's last-write stamp inside its watch entry and drops it on the raw change
+notification, before the debounce. The `ReferencesOnDisk` guard in `createProjectSnapshot` reads
+stamps through `IReferenceStamps`, so the comparison that runs for every new `Project` instance is
+a dictionary read per reference instead of a stat. A path nobody watches is stat'd directly. A
+mismatch against the snapshot's own stamps (FCS stats when it builds a snapshot) drops the
+project's stamps, so a missed notification costs one re-stat pass rather than a rebuild per
+`Project` instance. The reactor watch exists for these stamps, not to invalidate the FCS build —
+Roslyn already does that, as the previous section says.
+
+Still to come:
+
+1. Scripts: watch `#load` sources so an edit outside the editor drops the cached options for
+   that document.
+2. `FSharpProjectSnapshot.FromOptions` stats every `-r:` when a snapshot is built from scratch;
+   an overload taking host-supplied stamps lets it read the same cache.
+3. A reference-change notification for the incremental builder on the FCS side, the analogue of
+   `useChangeNotifications` for sources, so `IsReferencesInvalidated` stops stat'ing at all.