Did you know that file order matters in F#?

Author: nojaf

ReSharper.FSharp/src/FSharp/FSharp.Common/src/Checker/FcsProjectBuilder.fs

@@ -203,43 +203,59 @@ type FcsProjectBuilder(checkerService: FcsCheckerService, itemsContainer: IFShar
 
         let psiModule = psiModules.GetPrimaryPsiModule(project, targetFrameworkId)
 
-        let sourceFiles =
+        let projectItems: (VirtualFileSystemPath * BuildAction) array = x.GetProjectItemsPaths(project, targetFrameworkId)
+        
+        let tryFindPsiSourceFile name =
             psiModule.SourceFiles
-            |> Seq.filter(fun psiSourceFile ->
-                isNotNull psiSourceFile.PrimaryPsiLanguage
-                && psiSourceFile.PrimaryPsiLanguage.Name = "F#"
-            )
-            |> Seq.map (fun psiSourceFile ->
-                let name = psiSourceFile.GetLocation().FullPath
-                (*
-                
-                In order to create the snapshot, we need to ensure that Resharper read lock rules are respected when getting the source.
-                Today, this happens in DelegatingFileSystemShim.cs.
-                So we can rely on the file system (that is shimmed) and use FSharpFileSnapshot.CreateFromFileSystem.
-                
-                Alternatively we can construct the snapshot via getSource:
-                ```fsharp
-                let version = string psiSourceFile.Document.LastModificationStamp.Value
-
-                let getSource () =
-                    task {
-                        let mutable text = ""
-                        FSharpAsyncUtil.UsingReadLockInsideFcs(locks, fun () ->
-                            text <- psiSourceFile.Document.GetText()
-                        )
-                        return FSharp.Compiler.Text.SourceTextNew.ofString text
-                    }
-
-                ProjectSnapshot.FSharpFileSnapshot.Create(name, version, getSource)
-                ``` 
-
-                This also worked but for now going with the FileSystemShim seems better?
-                I favour the getSource option (or a better version of it) over the FileSystemShim 
-                as it makes it more explicit where the source is really coming from. 
-                However, I don't have enough understanding about the plugin to really make this judgement call.
-
-                *)
-                ProjectSnapshot.FSharpFileSnapshot.CreateFromFileSystem(name)
+            |> Seq.tryFind (fun sf -> sf.GetLocation().FullPath = name)
+        
+        let sourceFiles =
+            projectItems
+            |> Seq.choose (fun (virtualFileSystemPath, buildAction) ->
+                match buildAction, tryFindPsiSourceFile virtualFileSystemPath.FullPath with
+                | SourceFile, Some psiSourceFile ->
+                    let name = virtualFileSystemPath.FullPath
+                    (*
+                    
+                    In order to create the snapshot, we need to ensure that Resharper read lock rules are respected when getting the source.
+                    Today, this happens in DelegatingFileSystemShim.cs.
+                    So we can rely on the file system (that is shimmed) and use FSharpFileSnapshot.CreateFromFileSystem.
+                    
+                    Alternatively we can construct the snapshot via getSource:
+                    ```fsharp
+                    let version = string psiSourceFile.Document.LastModificationStamp.Value
+
+                    let getSource () =
+                        task {
+                            let mutable text = ""
+                            FSharpAsyncUtil.UsingReadLockInsideFcs(locks, fun () ->
+                                text <- psiSourceFile.Document.GetText()
+                            )
+                            return FSharp.Compiler.Text.SourceTextNew.ofString text
+                        }
+
+                    ProjectSnapshot.FSharpFileSnapshot.Create(name, version, getSource)
+                    ``` 
+
+                    This also worked but for now going with the FileSystemShim seems better?
+                    I favour the getSource option (or a better version of it) over the FileSystemShim 
+                    as it makes it more explicit where the source is really coming from. 
+                    However, I don't have enough understanding about the plugin to really make this judgement call.
+
+                    *)
+                    let getSource () =
+                        task {
+                            let mutable text = ""
+                            FSharpAsyncUtil.UsingReadLockInsideFcs(locks, fun () ->
+                                text <- psiSourceFile.Document.GetText()
+                            )
+                            return FSharp.Compiler.Text.SourceTextNew.ofString text
+                        }
+                    
+                    let hash = string (psiSourceFile.Document.GetText().GetHashCode())
+                    // let sf = ProjectSnapshot.FSharpFileSnapshot.CreateFromFileSystem(name)
+                    Some(ProjectSnapshot.FSharpFileSnapshot(name, hash, getSource))
+                | _ -> None
             )
             |> Seq.toList
 
@@ -277,7 +293,7 @@ type FcsProjectBuilder(checkerService: FcsCheckerService, itemsContainer: IFShar
                 originalLoadReferences = List.empty,
                 stamp = None
             )
-
+        
         let parsingOptions, errors =
             checkerService.Checker.GetParsingOptionsFromCommandLineArgs(otherOptions)
 

ReSharper.FSharp/src/FSharp/FSharp.Common/src/Checker/FcsProjectProvider.fs

@@ -15,6 +15,9 @@ open JetBrains.Application.Threading
 open JetBrains.Application.changes
 open JetBrains.DataFlow
 open JetBrains.Diagnostics
+open JetBrains.DocumentManagers
+open JetBrains.DocumentManagers.impl
+open JetBrains.DocumentModel
 open JetBrains.Lifetimes
 open JetBrains.ProjectModel
 open JetBrains.ProjectModel.Build
@@ -72,7 +75,8 @@ type FcsProjectProvider(lifetime: Lifetime, solution: ISolution, changeManager:
         scriptFcsProjectProvider: IScriptFcsProjectProvider,
         fsFileService: IFSharpFileService, fsItemsContainer: IFSharpItemsContainer,
         locks: IShellLocks, logger: ILogger, fcsAssemblyReaderShim: IFcsAssemblyReaderShim, psiModules: IPsiModules,
-        moduleReferencesResolveStore: IModuleReferencesResolveStore) as this =
+        moduleReferencesResolveStore: IModuleReferencesResolveStore,
+        solutionDocumentChangeProvider: SolutionDocumentChangeProvider) as this =
     inherit RecursiveProjectModelChangeDeltaVisitor()
 
     /// The main cache for FCS project model and related things.
@@ -464,6 +468,36 @@ type FcsProjectProvider(lifetime: Lifetime, solution: ISolution, changeManager:
         if isNotNull change && not change.IsClosingSolution  then
             x.VisitDelta(change)
 
+        let documentChange = obj.ChangeMap.GetChange<DocumentChange>(solutionDocumentChangeProvider)
+        if isNotNull documentChange then
+            let projectFile =
+                match documentChange with
+                | :? ProjectFileDocumentChange as change -> change.ProjectFile
+                | :? ProjectFileDocumentCopyChange as change -> change.ProjectFile
+                | _ -> null
+                
+            if isNotNull projectFile then
+                // call .Replace() ?
+                let impactedProjects =
+                    fcsProjects
+                    |> Seq.filter(fun (KeyValue(_, fcsProject)) ->
+                        fcsProject.ProjectSnapshot.SourceFiles
+                        |> List.exists (fun sf -> sf.FileName = projectFile.Location.FullPath))
+                
+                for KeyValue(fcsProjectKey, fcsProject) in impactedProjects do
+                    let updatedFiles =
+                        fcsProject.ProjectSnapshot.SourceFiles
+                        |> List.map (fun sf ->
+                            if sf.FileName <> projectFile.Location.FullPath then
+                                sf
+                            else
+                                FSharpFileSnapshot.CreateFromFileSystem(projectFile.Location.FullPath)
+                        )
+
+                    let updatedProject =
+                        { fcsProject with ProjectSnapshot = fcsProject.ProjectSnapshot.Replace(updatedFiles) }
+                    fcsProjects.Add(fcsProjectKey, updatedProject)
+        
         if dirtyProjects.Count = 0 then () else
 
         use cookie = WriteLockCookie.Create()

ReSharper.FSharp/test/src/FSharp.Tests.Common/src/Common.fs

@@ -228,6 +228,7 @@ type TestFcsProjectProvider(lifetime: Lifetime, checkerService: FcsCheckerServic
     do
         checkerService.FcsProjectProvider <- this
         lifetime.OnTermination(fun _ -> checkerService.FcsProjectProvider <- Unchecked.defaultof<_>) |> ignore
+        
 
     let mutable currentFcsProject = None
 
@@ -238,19 +239,21 @@ type TestFcsProjectProvider(lifetime: Lifetime, checkerService: FcsCheckerServic
     // todo: referenced projects
     // todo: unify with FcsProjectProvider check
     let areSameForChecking (newProject: FcsProject) (oldProject: FcsProject) =
-        let getReferencedProjectOutputs (options: FSharpProjectSnapshot) =
-            options.ReferencedProjects |> List.map (fun project -> project.OutputFile)
-
-        let newOptions = newProject.ProjectSnapshot
-        let oldOptions = oldProject.ProjectSnapshot
-
-        newOptions.ProjectFileName = oldOptions.ProjectFileName &&
-        newOptions.SourceFiles = oldOptions.SourceFiles &&
-        newOptions.OtherOptions = oldOptions.OtherOptions &&
-        newOptions.ReferencesOnDisk = oldOptions.ReferencesOnDisk &&
-        getReferencedProjectOutputs newOptions = getReferencedProjectOutputs oldOptions
+        false
+        // let getReferencedProjectOutputs (options: FSharpProjectSnapshot) =
+        //     options.ReferencedProjects |> List.map (fun project -> project.OutputFile)
+        //
+        // let newOptions = newProject.ProjectSnapshot
+        // let oldOptions = oldProject.ProjectSnapshot
+        //
+        // newOptions.ProjectFileName = oldOptions.ProjectFileName &&
+        // newOptions.SourceFiles = oldOptions.SourceFiles &&
+        // newOptions.OtherOptions = oldOptions.OtherOptions &&
+        // newOptions.ReferencesOnDisk = oldOptions.ReferencesOnDisk &&
+        // getReferencedProjectOutputs newOptions = getReferencedProjectOutputs oldOptions
 
     let getFcsProject (psiModule: IPsiModule) =
+        
         lock this (fun _ ->
             let newFcsProject = getNewFcsProject psiModule
             match currentFcsProject with