Keep Navigate To's items on disk between sessions

docs/release-notes/.FSharp.Compiler.Service/11.0.200.md

@@ -1,5 +1,6 @@
 ### Added
 
+* `NavigableContainer` publishes its `File` and `Container` cases, so a consumer of `NavigateTo.GetNavigableItems` can take a container apart and rebuild one — needed to cache navigable items outside the process that produced them. ([PR #20529](https://github.com/dotnet/fsharp/pull/20529))
 * F# Interactive gains a JSON-RPC server mode, `--fsi-server-jsonrpc:<pipe name>`, in which a host submits interactions over a named pipe and receives structured results — diagnostics with positions, escaping exceptions, the values each interaction bound, and the session's own process id — instead of recovering them by looking for a `SERVER-PROMPT>` marker in the output text. Program output continues to flow through the redirected console streams. The pipe admits only the user running the session; `--fsi-server-client-pid:<pid>` names the host process whose exit ends the session. `FsiEvaluationSession` exposes both options as `JsonRpcServerPipeName` and `JsonRpcClientProcessId`. The mode is part of the .NET fsi only. ([PR #20396](https://github.com/dotnet/fsharp/pull/20396))
 
 ### Fixed
@@ -20,3 +21,7 @@
 * Add `SynExceptionDefnReprTrivia` with the range of the `exception` keyword to `SynExceptionDefnRepr`. ([Fantomas Issue #3483](https://github.com/fsprojects/fantomas/issues/3483), [PR #20612](https://github.com/dotnet/fsharp/pull/20612))
 * Add `WhenKeyword` to `SynMatchClauseTrivia` with the range of the `when` keyword in match clauses. ([PR #20734](https://github.com/dotnet/fsharp/pull/20734))
 * Add `OfKeyword` to `SynUnionCaseTrivia` with the range of the `of` keyword in union cases and exception definitions. ([PR #20635](https://github.com/dotnet/fsharp/pull/20635))
+
+### Breaking Changes
+
+* `FSharp.Compiler.EditorServices.Structure.getOutliningRanges` now takes the source lines as `ReadOnlyMemory<char>[]` instead of `string[]`, so a caller that already holds the whole text can slice it instead of building a string per line. Callers passing a `string[]` can migrate with `Array.map (fun line -> line.AsMemory())`.

docs/release-notes/.VisualStudio/18.vNext.md

@@ -4,11 +4,14 @@
 * Code-fixes for FS3888 (compiler-semantic attribute on the `.fs` but not the `.fsi`): copy the attribute into the `.fsi`, or remove it from the `.fs`. ([Issue #19560](https://github.com/dotnet/fsharp/issues/19560), [PR #19880](https://github.com/dotnet/fsharp/pull/19880))
 * Expand `<inheritdoc/>` in IDE tooltips, completion, and signature help, inheriting XML documentation from base classes, interfaces, overridden members, and constructors. ([Issue #19175](https://github.com/dotnet/fsharp/issues/19175), [PR #19188](https://github.com/dotnet/fsharp/pull/19188))
 * Added a **Tools > Options > F# Tools > Compiler** option, **"Use the .NET SDK F# compiler for builds"**, on by default. Visual Studio uses the .NET SDK F# compiler when the project supplies SDK paths, matching `dotnet build`. Otherwise, it uses the bundled .NET Framework compiler. Turn the option off to use the bundled compiler for all projects. Changes are saved on Apply or OK; Cancel discards unsaved changes. Command-line builds are unaffected. ([Issue #20484](https://github.com/dotnet/fsharp/issues/20484), [PR #20485](https://github.com/dotnet/fsharp/pull/20485))
+* Navigate To (Ctrl+T) keeps the declarations it finds in each F# file in the solution's `.vs` folder, under a checksum of the file's text — and, for a file with `#if`, of the defines it was parsed with — so the next session reads them back instead of parsing the file again, including while the solution is still loading. ([PR #20689](https://github.com/dotnet/fsharp/pull/20689))
+* F# types, modules, members and values now appear in the GitHub Copilot Chat `#` mention picker, and attach their declaration source as context. ([PR #20409](https://github.com/dotnet/fsharp/pull/20409))
 
 ### Fixed
 
 * Go To Definition no longer blocks the UI thread with a bare `Task.Wait`: the synchronous `IFSharpGoToDefinitionService` call now waits through the cancellable threaded-wait dialog, and the editor's `TaskCompletionSource` bridges run their continuations on the thread pool instead of inline on whichever thread finished the check, so repeated F12 on a large solution no longer starves semantic classification and other main-thread work. ([PR #20482](https://github.com/dotnet/fsharp/pull/20482))
 * Peek Definition on an F# symbol whose definition lives in metadata no longer deadlocks Visual Studio. Peek holds the main thread in `JoinableTaskFactory.Run` without pumping messages while it asks the language service for the definition, and generating the metadata document needs that same thread; Peek now stops at definitions that already have a document, and Go To Definition, which owns the wait it makes, still opens the generated one. ([PR #20503](https://github.com/dotnet/fsharp/pull/20503))
+* Navigate To lists F# declarations while the solution is still loading. Until now the search that runs during load skipped F# entirely, and the full search that follows it is never started, so nothing F# declares could be found until the next search. ([PR #20492](https://github.com/dotnet/fsharp/pull/20492))
 * Improve Find All References performance by throttling parallel typechecks. ([PR #20128](https://github.com/dotnet/fsharp/pull/20128))
 * Fixed Rename incorrectly renaming `get` and `set` keywords for properties with explicit accessors. ([Issue #18270](https://github.com/dotnet/fsharp/issues/18270), [PR #19252](https://github.com/dotnet/fsharp/pull/19252))
 * Fixed Find All References crash when F# project contains non-F# files like `.cshtml`. ([Issue #16394](https://github.com/dotnet/fsharp/issues/16394), [PR #19252](https://github.com/dotnet/fsharp/pull/19252))
@@ -23,6 +26,8 @@
 * Build a single-file project's `OtherOptions` reference flags with one array comprehension instead of two `Array.ofSeq` calls and an `Array.append`. ([PR #20499](https://github.com/dotnet/fsharp/pull/20499))
 * Fix syntax coloring being lost for a whole file when one symbol resolves into metadata that could not be read. ([Issue #20269](https://github.com/dotnet/fsharp/issues/20269), [PR #20274](https://github.com/dotnet/fsharp/pull/20274))
 * Go To Definition into an F# project built with a path map (`DeterministicSourcePaths` or `PathMap`) opens its source instead of a generated signature: the IDE no longer applies `--pathmap` to the project options it checks with. ([PR #20470](https://github.com/dotnet/fsharp/pull/20470))
+* Go To All (Ctrl+T) on a multi-targeted F# project no longer parses and reads every file once per target framework: the first instance searches every file, the others only the files they alone compile or that use conditional compilation, and a file's text is read only for a matched declaration. ([PR #20483](https://github.com/dotnet/fsharp/pull/20483))
+* Go To All (Ctrl+T) on a multi-targeted F# project no longer parses every file once per target framework: a file whose parse holds no conditional directives does not depend on the defines, so every instance reuses the one parse, and a file's text is read only for a matched declaration. ([PR #20483](https://github.com/dotnet/fsharp/pull/20483))
 
 ### Changed
 

eng/Packages.props

@@ -65,6 +65,9 @@
          ComponentModelHost would otherwise stay at 17.x; that 17.x/18.x split makes S/IComponentModel ambiguous
          (CS0433). Pin to the SDK 18.9.496 version so those types resolve to a single assembly. -->
     <PackageVersion Include="Microsoft.VisualStudio.ComponentModelHost" Version="18.9.453" />
+    <!-- Copilot chat contracts. Kept on the 18.9.x wave so its MessagePack and editor dependencies match the pins
+         above. Compile-only: at runtime the VS-installed contract assembly wins through Copilot's binding redirect. -->
+    <PackageVersion Include="Microsoft.VisualStudio.Copilot" Version="18.9.918" />
     <PackageVersion Include="Microsoft.VisualStudio.Designer.Interfaces" Version="18.9.438" />
     <PackageVersion Include="Microsoft.VisualStudio.Editor" Version="$(VisualStudioEditorPackagesVersion)" />
     <PackageVersion Include="Microsoft.VisualStudio.Extensibility.Build" Version="17.13.39620" />

src/Compiler/Service/ServiceNavigation.fsi

@@ -99,8 +99,12 @@ type NavigableContainerType =
     | Type
     | Exception
 
-[<Sealed>]
 type NavigableContainer =
+    | File of fileName: string
+    /// A container declared inside a file: its kind, its name one element per dotted part, and the
+    /// container it is declared in, ending at the file.
+    | Container of containerType: NavigableContainerType * nameParts: string list * parent: NavigableContainer
+
     /// The kind of container.
     member Type: NavigableContainerType
 

src/Compiler/Service/ServiceStructure.fs

@@ -2,6 +2,7 @@
 
 namespace FSharp.Compiler.EditorServices
 
+open System
 open Internal.Utilities.Library
 open FSharp.Compiler.Syntax
 open FSharp.Compiler.SyntaxTreeOps
@@ -186,27 +187,35 @@ module Structure =
         }
 
     type LineNumber = int
-    type LineStr = string
 
     type CommentType =
         | SingleLine
         | XmlDoc
 
+    /// Determine if a line is a single line or xml documentation comment.
+    /// Kept at module scope: a local recursive function capturing a `ReadOnlySpan<char>`-typed
+    /// helper as a closure field would need to instantiate `FSharpFunc<ReadOnlySpan<char>, _>`,
+    /// which the CLR disallows for byref-like type arguments (FS0412).
+    let commentTypeOf (line: ReadOnlySpan<char>) =
+        if line.StartsWithOrdinal("///") then ValueSome XmlDoc
+        elif line.StartsWithOrdinal("//") then ValueSome SingleLine
+        else ValueNone
+
     [<NoComparison>]
     type CommentList =
         {
-            Lines: ResizeArray<LineNumber * LineStr>
+            Lines: ResizeArray<LineNumber>
             Type: CommentType
         }
 
-        static member New ty lineStr =
+        static member New ty lineNum =
             {
                 Type = ty
-                Lines = ResizeArray [ lineStr ]
+                Lines = ResizeArray [ lineNum ]
             }
 
     /// Returns outlining ranges for given parsed input.
-    let getOutliningRanges (sourceLines: string[]) (parsedInput: ParsedInput) =
+    let getOutliningRanges (sourceLines: ReadOnlyMemory<char>[]) (parsedInput: ParsedInput) =
         let acc = ResizeArray()
 
         /// Validation function to ensure that ranges yielded for outlining span 2 or more lines
@@ -661,7 +670,7 @@ module Structure =
                     | r :: rest, last :: _ when
                         r.StartLine = last.EndLine + 1
                         || sourceLines[last.EndLine .. r.StartLine - 2]
-                           |> Array.forall System.String.IsNullOrWhiteSpace
+                           |> Array.forall (fun line -> line.Span.IsWhiteSpace())
                         ->
                         loop rest res (r :: currentBulk)
                     | r :: rest, _ -> loop rest (currentBulk :: res) [ r ]
@@ -719,7 +728,7 @@ module Structure =
 
         let collectConditionalDirectives directives sourceLines =
             // Adds a fold region from prevRange.Start to the line above nextLine
-            let addSectionFold (prevRange: range) (nextLine: int) (sourceLines: string array) =
+            let addSectionFold (prevRange: range) (nextLine: int) (sourceLines: ReadOnlyMemory<char>[]) =
                 let startLineIndex = nextLine - 2
 
                 if startLineIndex >= 0 then
@@ -753,7 +762,7 @@ module Structure =
                 | ConditionalDirectiveTrivia.Else r -> ValueSome r
                 | _ -> ValueNone
 
-            let rec group directives stack (sourceLines: string array) =
+            let rec group directives stack (sourceLines: ReadOnlyMemory<char>[]) =
                 match directives with
                 | [] -> ()
                 | ConditionalDirectiveTrivia.If _ as ifDirective :: directives -> group directives (ifDirective :: stack) sourceLines
@@ -822,50 +831,42 @@ module Structure =
             collectOpens decls
             List.iter parseDeclaration decls
 
-        /// Determine if a line is a single line or xml documentation comment
-        let (|Comment|_|) (line: string) =
-            if line.StartsWithOrdinal("///") then Some XmlDoc
-            elif line.StartsWithOrdinal("//") then Some SingleLine
-            else None
-
-        let getCommentRanges trivia (lines: string[]) =
-            let rec loop (lastLineNum, currentComment, result as state) (lines: string list) lineNum =
-                match lines with
-                | [] -> state
-                | lineStr :: rest ->
-                    match lineStr.TrimStart(), currentComment with
-                    | Comment commentType, Some comment ->
+        let getCommentRanges trivia (lines: ReadOnlyMemory<char>[]) =
+            let rec loop (lastLineNum, currentComment, result as state) lineNum =
+                if lineNum = lines.Length then
+                    state
+                else
+                    match commentTypeOf (lines[lineNum].Span.TrimStart()), currentComment with
+                    | ValueSome commentType, Some comment ->
                         loop
                             (if comment.Type = commentType && lineNum = lastLineNum + 1 then
-                                 comment.Lines.Add(lineNum, lineStr)
+                                 comment.Lines.Add lineNum
                                  lineNum, currentComment, result
                              else
-                                 let comments = CommentList.New commentType (lineNum, lineStr)
+                                 let comments = CommentList.New commentType lineNum
                                  lineNum, Some comments, comment :: result)
-                            rest
                             (lineNum + 1)
-                    | Comment commentType, None ->
-                        let comments = CommentList.New commentType (lineNum, lineStr)
-                        loop (lineNum, Some comments, result) rest (lineNum + 1)
-                    | _, Some comment -> loop (lineNum, None, comment :: result) rest (lineNum + 1)
-                    | _ -> loop (lineNum, None, result) rest (lineNum + 1)
+                    | ValueSome commentType, None ->
+                        let comments = CommentList.New commentType lineNum
+                        loop (lineNum, Some comments, result) (lineNum + 1)
+                    | ValueNone, Some comment -> loop (lineNum, None, comment :: result) (lineNum + 1)
+                    | ValueNone, None -> loop (lineNum, None, result) (lineNum + 1)
 
             let comments =
-                let _, lastComment, comments = loop (-1, None, []) (List.ofArray lines) 0
+                let _, lastComment, comments = loop (-1, None, []) 0
 
                 match lastComment with
                 | Some comment -> comment :: comments
                 | _ -> comments
                 |> List.rev
 
             comments
-            |> List.filter (fun comment -> comment.Lines.Count > 1)
-            |> List.map (fun comment ->
-                let lines = comment.Lines
-                let startLine, startStr = lines[0]
-                let endLine, endStr = lines[lines.Count - 1]
-                let startCol = startStr.IndexOf '/'
-                let endCol = endStr.TrimEnd().Length
+            |> Seq.filter (fun comment -> comment.Lines.Count > 1)
+            |> Seq.map (fun comment ->
+                let startLine = comment.Lines[0]
+                let endLine = comment.Lines[comment.Lines.Count - 1]
+                let startCol = lines[startLine].Span.IndexOf '/'
+                let endCol = lines[endLine].Span.TrimEnd().Length
 
                 let scopeType =
                     match comment.Type with

src/Compiler/Service/ServiceStructure.fsi

@@ -2,6 +2,7 @@
 
 namespace FSharp.Compiler.EditorServices
 
+open System
 open FSharp.Compiler.Syntax
 open FSharp.Compiler.Text
 
@@ -79,4 +80,4 @@ module public Structure =
         }
 
     /// Returns outlining ranges for given parsed input.
-    val getOutliningRanges: sourceLines: string[] -> parsedInput: ParsedInput -> seq<ScopeRange>
+    val getOutliningRanges: sourceLines: ReadOnlyMemory<char>[] -> parsedInput: ParsedInput -> seq<ScopeRange>

src/Compiler/Utilities/illib.fs

@@ -7,6 +7,7 @@ open System.Collections.Generic
 open System.Collections.Concurrent
 open System.Diagnostics
 open System.IO
+open System.Linq
 open System.Threading
 open System.Threading.Tasks
 open System.Runtime.CompilerServices
@@ -112,6 +113,54 @@ module internal PervasiveAutoOpens =
         member inline x.IndexOfOrdinal(value: string, startIndex, count) =
             x.IndexOf(value, startIndex, count, StringComparison.Ordinal)
 
+    [<AbstractClass; Sealed>]
+    type ReadOnlySpanCharExtensions =
+
+        static member inline StartsWithOrdinal(str: ReadOnlySpan<char>, value: ReadOnlySpan<char>) =
+            str.StartsWith(value, StringComparison.Ordinal)
+
+        static member inline StartsWithOrdinal(str: ReadOnlySpan<char>, value: string) =
+            str.StartsWith(value.AsSpan(), StringComparison.Ordinal)
+
+        static member inline EndsWithOrdinal(str: ReadOnlySpan<char>, value: ReadOnlySpan<char>) =
+            str.EndsWith(value, StringComparison.Ordinal)
+
+        static member inline EndsWithOrdinal(str: ReadOnlySpan<char>, value: string) =
+            str.EndsWith(value.AsSpan(), StringComparison.Ordinal)
+
+        static member inline EndsWithOrdinalIgnoreCase(str: ReadOnlySpan<char>, value: ReadOnlySpan<char>) =
+            str.EndsWith(value, StringComparison.OrdinalIgnoreCase)
+
+        static member inline EndsWithOrdinalIgnoreCase(str: ReadOnlySpan<char>, value: string) =
+            str.EndsWith(value.AsSpan(), StringComparison.OrdinalIgnoreCase)
+
+        static member IndexOf(str: ReadOnlySpan<char>, value: char) =
+            let mutable index = -1
+            let mutable i = 0
+
+            while i < str.Length && index = -1 do
+                if str[i] = value then index <- i else i <- i + 1
+
+            index
+
+        static member inline IndexOfOrdinal(str: ReadOnlySpan<char>, value: ReadOnlySpan<char>) =
+            str.IndexOf(value, StringComparison.Ordinal)
+
+        static member inline IndexOfOrdinal(str: ReadOnlySpan<char>, value: string) =
+            str.IndexOf(value.AsSpan(), StringComparison.Ordinal)
+
+        static member inline IndexOfOrdinal(str: ReadOnlySpan<char>, value: ReadOnlySpan<char>, startIndex) =
+            str.Slice(startIndex).IndexOf(value, StringComparison.Ordinal)
+
+        static member inline IndexOfOrdinal(str: ReadOnlySpan<char>, value: string, startIndex) =
+            str.Slice(startIndex).IndexOf(value.AsSpan(), StringComparison.Ordinal)
+
+        static member inline IndexOfOrdinal(str: ReadOnlySpan<char>, value: ReadOnlySpan<char>, startIndex, count) =
+            str.Slice(startIndex, count).IndexOf(value, StringComparison.Ordinal)
+
+        static member inline IndexOfOrdinal(str: ReadOnlySpan<char>, value: string, startIndex, count) =
+            str.Slice(startIndex, count).IndexOf(value.AsSpan(), StringComparison.Ordinal)
+
     /// Get an initialization hole
     let getHole (r: _ ref) =
         match r.Value with