Let FSharpProjectSnapshot.FromOptions take reference stamps from the host

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

@@ -1,5 +1,6 @@
 ### Added
 
+* `FSharpProjectSnapshot.FromOptions` takes an optional `getReferenceStamp: string -> DateTime`, so a host that already tracks the last-write times of on-disk references can supply them instead of having every `-r:` stat'd again each time a snapshot is built. ([PR #20459](https://github.com/dotnet/fsharp/pull/20459))
 * 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

src/Compiler/Service/FSharpProjectSnapshot.fs

@@ -647,9 +647,13 @@ and [<Experimental("This FCS API is experimental and subject to change.")>] FSha
         ProjectSnapshotBase(projectConfig, referencedProjects, sourceFiles)
         |> FSharpProjectSnapshot
 
-    static member FromOptions(options: FSharpProjectOptions, getFileSnapshot, ?snapshotAccumulator) =
-        let snapshotAccumulator = defaultArg snapshotAccumulator (Dictionary())
-
+    static member private SnapshotOfOptions
+        (
+            options: FSharpProjectOptions,
+            getFileSnapshot,
+            snapshotAccumulator: Dictionary<FSharpProjectOptions, FSharpProjectSnapshot>,
+            getReferenceStamp: string -> DateTime
+        ) =
         async {
 
             // TODO: check if options is a good key here
@@ -665,7 +669,13 @@ and [<Experimental("This FCS API is experimental and subject to change.")>] FSha
                     |> Seq.map (function
                         | FSharpReferencedProject.FSharpReference(outputName, options) ->
                             async {
-                                let! snapshot = FSharpProjectSnapshot.FromOptions(options, getFileSnapshot, snapshotAccumulator)
+                                let! snapshot =
+                                    FSharpProjectSnapshot.SnapshotOfOptions(
+                                        options,
+                                        getFileSnapshot,
+                                        snapshotAccumulator,
+                                        getReferenceStamp
+                                    )
 
                                 return FSharpReferencedProjectSnapshot.FSharpReference(outputName, snapshot)
                             }
@@ -686,7 +696,7 @@ and [<Experimental("This FCS API is experimental and subject to change.")>] FSha
 
                             {
                                 Path = path
-                                LastModified = FileSystem.GetLastWriteTimeShim(path)
+                                LastModified = getReferenceStamp path
                             })
                     )
 
@@ -712,6 +722,22 @@ and [<Experimental("This FCS API is experimental and subject to change.")>] FSha
             return snapshotAccumulator[options]
         }
 
+    static member FromOptions(options: FSharpProjectOptions, getFileSnapshot, ?snapshotAccumulator) =
+        FSharpProjectSnapshot.SnapshotOfOptions(
+            options,
+            getFileSnapshot,
+            defaultArg snapshotAccumulator (Dictionary()),
+            FileSystem.GetLastWriteTimeShim
+        )
+
+    /// The snapshot `FromOptions` builds, with the last-modified time of every reference on disk answered by
+    /// the host rather than read from the file system: a host that already tracks those files - as an IDE
+    /// watching them does - knows the time without a call per reference per snapshot.
+    static member FromOptionsWithReferenceStamps
+        (options: FSharpProjectOptions, getFileSnapshot, getReferenceStamp: string -> DateTime, ?snapshotAccumulator)
+        =
+        FSharpProjectSnapshot.SnapshotOfOptions(options, getFileSnapshot, defaultArg snapshotAccumulator (Dictionary()), getReferenceStamp)
+
     static member FromOptions(options: FSharpProjectOptions, documentSource: DocumentSource) =
         FSharpProjectSnapshot.FromOptions(
             options,

tests/FSharp.Compiler.ComponentTests/FSharpChecker/ProjectSnapshot.fs

@@ -1,104 +1,61 @@
 module FSharpChecker.ProjectSnapshot
 
-open Xunit
 open System
+open System.IO
+open System.Threading.Tasks
+open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.CodeAnalysis.ProjectSnapshot
+open Xunit
 
-
-// TODO: restore tests
-
-//[<Fact>]
-//let WithoutImplFilesThatHaveSignatures () =
-
-//    let snapshot = FSharpProjectSnapshot.Create(
-//        projectFileName = "Dummy.fsproj",
-//        projectId = None,
-//        sourceFiles = [
-//            { FileName = "A.fsi"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "A.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "B.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "C.fsi"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "C.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//        ],
-//        referencesOnDisk = [],
-//        otherOptions = [],
-//        referencedProjects = [],
-//        isIncompleteTypeCheckEnvironment = true,
-//        useScriptResolutionRules = false,
-//        loadTime = DateTime(1234, 5, 6),
-//        unresolvedReferences = None,
-//        originalLoadReferences = [],
-//        stamp = None
-//    )
-
-//    let result = snapshot.WithoutImplFilesThatHaveSignatures
-
-//    let expected = [| "A.fsi"; "B.fs"; "C.fsi" |]
-
-//    Assert.Equal<string array>(expected, result.SourceFileNames |> List.toArray)
-
-//    Assert.Equal<byte array>(result.FullVersion, snapshot.SignatureVersion)
-
-//[<Fact>]
-//let WithoutImplFilesThatHaveSignaturesExceptLastOne () =
-
-//    let snapshot = FSharpProjectSnapshot.Create(
-//        projectFileName = "Dummy.fsproj",
-//        projectId = None,
-//        sourceFiles = [
-//            { FileName = "A.fsi"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "A.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "B.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "C.fsi"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "C.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//        ],
-//        referencesOnDisk = [],
-//        otherOptions = [],
-//        referencedProjects = [],
-//        isIncompleteTypeCheckEnvironment = true,
-//        useScriptResolutionRules = false,
-//        loadTime = DateTime(1234, 5, 6),
-//        unresolvedReferences = None,
-//        originalLoadReferences = [],
-//        stamp = None
-//    )
-
-//    let result = snapshot.WithoutImplFilesThatHaveSignaturesExceptLastOne
-
-//    let expected = [| "A.fsi"; "B.fs"; "C.fsi"; "C.fs" |]
-
-//    Assert.Equal<string array>(expected, result.SourceFileNames |> List.toArray)
-
-//    Assert.Equal<byte array>(result.FullVersion, snapshot.LastFileVersion)
-
-
-//[<Fact>]
-//let WithoutImplFilesThatHaveSignaturesExceptLastOne_2 () =
-
-//    let snapshot = FSharpProjectSnapshot.Create(
-//        projectFileName = "Dummy.fsproj",
-//        projectId = None,
-//        sourceFiles = [
-//            { FileName = "A.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "B.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//            { FileName = "C.fs"; Version = "1"; GetSource = Unchecked.defaultof<_> }
-//        ],
-//        referencesOnDisk = [],
-//        otherOptions = [],
-//        referencedProjects = [],
-//        isIncompleteTypeCheckEnvironment = true,
-//        useScriptResolutionRules = false,
-//        loadTime = DateTime(1234, 5, 6),
-//        unresolvedReferences = None,
-//        originalLoadReferences = [],
-//        stamp = None
-//    )
-
-//    let result = snapshot.WithoutImplFilesThatHaveSignaturesExceptLastOne
-
-//    let expected = [| "A.fs"; "B.fs"; "C.fs" |]
-
-//    Assert.Equal<string array>(expected, result.SourceFileNames |> List.toArray)
-
-//    Assert.Equal<byte array>(result.FullVersion, snapshot.LastFileVersion)
-
+#nowarn "57"
+
+let private projectOptions projectFileName references referencedProjects =
+    {
+        ProjectFileName = projectFileName
+        ProjectId = None
+        SourceFiles = [| Path.ChangeExtension(projectFileName, ".fs") |]
+        OtherOptions = [| for path in references -> $"-r:{path}" |]
+        ReferencedProjects = referencedProjects
+        IsIncompleteTypeCheckEnvironment = false
+        UseScriptResolutionRules = false
+        LoadTime = DateTime.UtcNow
+        UnresolvedReferences = None
+        OriginalLoadReferences = []
+        Stamp = None
+    }
+
+let private emptySource _ path =
+    async { return FSharpFileSnapshot.CreateFromString(path, "") }
+
+[<Fact>]
+let ``FromOptions takes reference stamps from the host, including referenced projects`` () : Task =
+    task {
+        let stamps =
+            dict
+                [
+                    "MainRef.dll", DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc)
+                    "LibRef.dll", DateTime(2026, 2, 2, 0, 0, 0, DateTimeKind.Utc)
+                ]
+
+        let lib = projectOptions "Lib.fsproj" [ "LibRef.dll" ] [||]
+
+        let main =
+            projectOptions "Main.fsproj" [ "MainRef.dll" ] [| FSharpReferencedProject.FSharpReference("Lib.dll", lib) |]
+
+        let! snapshot = FSharpProjectSnapshot.FromOptionsWithReferenceStamps(main, emptySource, (fun path -> stamps[path]))
+
+        let libSnapshot =
+            match snapshot.ReferencedProjects with
+            | [ FSharpReferencedProjectSnapshot.FSharpReference(_, lib) ] -> lib
+            | other -> failwith $"Expected one referenced project, got %A{other}"
+
+        Assert.Equal<ReferenceOnDisk list>(
+            [ { Path = "MainRef.dll"; LastModified = stamps["MainRef.dll"] } ],
+            snapshot.ReferencesOnDisk
+        )
+
+        Assert.Equal<ReferenceOnDisk list>(
+            [ { Path = "LibRef.dll"; LastModified = stamps["LibRef.dll"] } ],
+            libSnapshot.ReferencesOnDisk
+        )
+    }

tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.bsl

@@ -2507,6 +2507,7 @@ FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FS
 FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot] FromOptions(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, FSharp.Compiler.CodeAnalysis.DocumentSource)
 FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot] FromOptions(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpFileSnapshot]]], Microsoft.FSharp.Core.FSharpOption`1[System.Collections.Generic.Dictionary`2[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions,FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot]])
 FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot] FromOptions(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, System.String, Int32, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.CodeAnalysis.DocumentSource)
+FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot] FromOptionsWithReferenceStamps(FSharp.Compiler.CodeAnalysis.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpFileSnapshot]]], Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.DateTime], Microsoft.FSharp.Core.FSharpOption`1[System.Collections.Generic.Dictionary`2[FSharp.Compiler.CodeAnalysis.FSharpProjectOptions,FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot]])
 FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet] UnresolvedReferences
 FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Core.FSharpOption`1[FSharp.Compiler.CodeAnalysis.FSharpUnresolvedReferencesSet] get_UnresolvedReferences()
 FSharp.Compiler.CodeAnalysis.ProjectSnapshot+FSharpProjectSnapshot: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Stamp