Fix for API changes (VirtualFileSystemPath)

Author: krasnotsvetov

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

@@ -31,11 +31,11 @@ module FcsCheckerService =
 
 
 type FcsProject =
-    { OutputPath: FileSystemPath
-      FileIndices: Dictionary<FileSystemPath, int>
+    { OutputPath: VirtualFileSystemPath
+      FileIndices: Dictionary<VirtualFileSystemPath, int>
       ProjectOptions: FSharpProjectOptions
       ParsingOptions: FSharpParsingOptions
-      ImplementationFilesWithSignatures: ISet<FileSystemPath> }
+      ImplementationFilesWithSignatures: ISet<VirtualFileSystemPath> }
 
     member x.IsKnownFile(sourceFile: IPsiSourceFile) =
         x.FileIndices.ContainsKey(sourceFile.GetLocation())
@@ -200,7 +200,7 @@ type IFcsProjectProvider =
 
 type IScriptFcsProjectProvider =
     abstract GetScriptOptions: IPsiSourceFile -> FSharpProjectOptions option
-    abstract GetScriptOptions: FileSystemPath * string -> FSharpProjectOptions option
+    abstract GetScriptOptions: VirtualFileSystemPath * string -> FSharpProjectOptions option
 
 
 type IFcsAssemblyReaderShim =

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

@@ -17,7 +17,7 @@ open JetBrains.Util
 open JetBrains.Util.Dotnet.TargetFrameworkIds
 
 type ReferencedModule =
-    { ReferencedPath: FileSystemPath
+    { ReferencedPath: VirtualFileSystemPath
       ReferencingModules: HashSet<IPsiModule> }
 
 module ReferencedModule =
@@ -96,7 +96,7 @@ type FcsProjectBuilder(checkerService: FcsCheckerService, itemsContainer: IFShar
         | _ -> "library"
 
     abstract GetProjectItemsPaths:
-        project: IProject * targetFrameworkId: TargetFrameworkId -> (FileSystemPath * BuildAction)[]
+        project: IProject * targetFrameworkId: TargetFrameworkId -> (VirtualFileSystemPath * BuildAction)[]
 
     default x.GetProjectItemsPaths(project, targetFrameworkId) =
         let projectMark = project.GetProjectMark().NotNull()
@@ -183,14 +183,14 @@ type FcsProjectBuilder(checkerService: FcsCheckerService, itemsContainer: IFShar
 
         let filePaths, implsWithSig, resources = x.GetProjectFilesAndResources(project, targetFrameworkId)
 
-        otherOptions.AddRange(resources |> Seq.map (fun (r: FileSystemPath) -> "--resource:" + r.FullPath))
-        let fileIndices = Dictionary<FileSystemPath, int>()
+        otherOptions.AddRange(resources |> Seq.map (fun (r: VirtualFileSystemPath) -> "--resource:" + r.FullPath))
+        let fileIndices = Dictionary<VirtualFileSystemPath, int>()
         Array.iteri (fun i p -> fileIndices.[p] <- i) filePaths
 
         let projectOptions =
             { ProjectFileName = $"{project.ProjectFileLocation}.{targetFrameworkId}.fsproj"
               ProjectId = None
-              SourceFiles = Array.map (fun (p: FileSystemPath ) -> p.FullPath) filePaths
+              SourceFiles = Array.map (fun (p: VirtualFileSystemPath ) -> p.FullPath) filePaths
               OtherOptions = otherOptions.ToArray()
               ReferencedProjects = Array.empty
               IsIncompleteTypeCheckEnvironment = false

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

@@ -37,7 +37,7 @@ type ScriptFcsProjectProvider(lifetime: Lifetime, logger: ILogger, checkerServic
             IPropertyEx.FlowInto(languageVersion, lifetime, flags, fun version -> getOtherFlags version)
             flags
 
-    let getOptions (path: FileSystemPath) source =
+    let getOptions (path: VirtualFileSystemPath) source =
         let path = path.FullPath
         let source = SourceText.ofString source
         lock getScriptOptionsLock (fun _ ->
@@ -58,7 +58,7 @@ type ScriptFcsProjectProvider(lifetime: Lifetime, logger: ILogger, checkerServic
                 None)
 
     interface IScriptFcsProjectProvider with
-        member x.GetScriptOptions(path: FileSystemPath, source) =
+        member x.GetScriptOptions(path: VirtualFileSystemPath, source) =
             getOptions path source
 
         member x.GetScriptOptions(file: IPsiSourceFile) =

ReSharper.FSharp/src/FSharp.Common/src/ProjectModel/FSharpFileService.fs

@@ -16,7 +16,7 @@ type FSharpFileService(settingsLocation: RiderAnyProductSettingsLocation, fileEx
             .Parent / "scratches"
 
     interface IFSharpFileService with
-        member x.IsScratchFile(path: FileSystemPath) =
+        member x.IsScratchFile(path: VirtualFileSystemPath) =
             path.Parent.Equals(scratchesDir)
 
         member x.IsScriptLike(file) =

ReSharper.FSharp/src/FSharp.Common/src/ProjectModel/FSharpLanguageLevelProvider.fs

@@ -46,7 +46,7 @@ type FSharpLanguageLevelProjectProperty(lifetime, locks, projectPropertiesListen
         projectPropertiesListener, projectSettings, persistentProjectItemProperties,
         settingsSchema.GetKey<FSharpLanguageProjectSettings>().TryFindEntryByMemberName("LanguageLevel"))
 
-    let compilerPathToLanguageLevels = ConcurrentDictionary<FileSystemPath, VersionMapping>()
+    let compilerPathToLanguageLevels = ConcurrentDictionary<VirtualFileSystemPath, VersionMapping>()
 
     let getFSharpProjectConfiguration (project: IProject) targetFrameworkId =
         project.ProjectProperties.TryGetConfiguration<IFSharpProjectConfiguration>(targetFrameworkId)
@@ -76,26 +76,26 @@ type FSharpLanguageLevelProjectProperty(lifetime, locks, projectPropertiesListen
         | Version (11, 0) -> VersionMapping(FSharpLanguageLevel.FSharp50, FSharpLanguageLevel.Preview)
         | _ -> null
 
-    let getCompilerVersion (fscPath: FileSystemPath) =
+    let getCompilerVersion (fscPath: VirtualFileSystemPath) =
         let assemblyNameInfo = AssemblyNameReader.GetAssemblyNameRaw(fscPath)
         assemblyNameInfo.Version
 
-    let getLanguageLevelByCompilerNoCache (fscPath: FileSystemPath): VersionMapping =
+    let getLanguageLevelByCompilerNoCache (fscPath: VirtualFileSystemPath): VersionMapping =
         if fscPath.IsEmpty then getVersionMappingByToolset () else
 
         let version = getCompilerVersion fscPath
         match getLanguageLevelByCompilerVersion version with
         | null -> getVersionMappingByToolset ()
         | mapping -> mapping
 
-    let getLanguageLevelByCompiler (fscPath: FileSystemPath): VersionMapping =
+    let getLanguageLevelByCompiler (fscPath: VirtualFileSystemPath): VersionMapping =
         compilerPathToLanguageLevels.GetOrAdd(fscPath, getLanguageLevelByCompilerNoCache)
 
-    let getFscPath (configuration: IFSharpProjectConfiguration): FileSystemPath =
-        if isNull configuration then FileSystemPath.Empty else
+    let getFscPath (configuration: IFSharpProjectConfiguration): VirtualFileSystemPath =
+        if isNull configuration then (VirtualFileSystemPath.GetEmptyPathFor InteractionContext.SolutionContext) else
 
         let path = configuration.PropertiesCollection.GetPropertyValueSafe(FSharpProperties.DotnetFscCompilerPath)
-        FileSystemPath.TryParse(path)
+        VirtualFileSystemPath.TryParse(path, InteractionContext.SolutionContext)
 
     let convertToLanguageLevel (configuration: IFSharpProjectConfiguration) version =
         match version with

ReSharper.FSharp/src/FSharp.Common/src/ProjectModel/FSharpProjectModelUtil.fs

@@ -29,11 +29,11 @@ let getReferencedModules (psiModule: IPsiModule) =
     |> Seq.map (fun reference -> reference.Module)
 
 module ModulePathProvider =
-    let outputPathKey = Key<FileSystemPath>("AssemblyReaderTest.outputPath")
+    let outputPathKey = Key<VirtualFileSystemPath>("AssemblyReaderTest.outputPath")
 
 [<SolutionComponent>]
 type ModulePathProvider() =
-    abstract GetModulePath: psiModule: IPsiModule -> FileSystemPath
+    abstract GetModulePath: psiModule: IPsiModule -> VirtualFileSystemPath
     default this.GetModulePath(psiModule) =
         match psiModule with
         | :? IAssemblyPsiModule as assemblyPsiModule ->
@@ -42,4 +42,4 @@ type ModulePathProvider() =
         | :? IProjectPsiModule as projectPsiModule ->
             projectPsiModule.Project.GetOutputFilePath(projectPsiModule.TargetFrameworkId)
 
-        | _ -> FileSystemPath.Empty
+        | _ -> (VirtualFileSystemPath.GetEmptyPathFor InteractionContext.SolutionContext)

ReSharper.FSharp/src/FSharp.Common/src/ProjectModel/FSharpScriptPsiModuleFactory.fs

@@ -43,13 +43,13 @@ type FSharpScriptPsiModulesProvider(lifetime: Lifetime, solution: ISolution, cha
         projectFileTypeCoordinator) as this =
 
     /// There may be multiple project files for a path (i.e. linked in multiple projects) and we must distinguish them.
-    let scriptsFromProjectFiles = OneToListMap<FileSystemPath, FSharpScriptPsiModule>()
+    let scriptsFromProjectFiles = OneToListMap<VirtualFileSystemPath, FSharpScriptPsiModule>()
 
     /// Psi modules for files coming from #load directives and do not present in the project model.
-    let scriptsFromPaths = Dictionary<FileSystemPath, FSharpScriptPsiModule>()
+    let scriptsFromPaths = Dictionary<VirtualFileSystemPath, FSharpScriptPsiModule>()
 
     /// References to assemblies and other source files for each known script path.
-    let scriptsReferences = Dictionary<FileSystemPath, ScriptReferences>()
+    let scriptsReferences = Dictionary<VirtualFileSystemPath, ScriptReferences>()
 
     let psiModules = List<IPsiModule>()
     let mutable psiModulesCollection = HybridCollection.Empty
@@ -67,21 +67,21 @@ type FSharpScriptPsiModulesProvider(lifetime: Lifetime, solution: ISolution, cha
         let platformInfo = platformInfos |> Seq.maxBy (fun info -> info.TargetFrameworkId.Version)
         platformInfo.TargetFrameworkId
 
-    let getScriptOptions (path: FileSystemPath) (document: IDocument) =
+    let getScriptOptions (path: VirtualFileSystemPath) (document: IDocument) =
         scriptOptionsProvider.GetScriptOptions(path, document.GetText())
         |> Option.orElseWith (fun _ -> failwithf "Could not get script options for: %O" path)
         |> Option.get
 
-    let getScriptReferences scriptPath scriptOptions =
-        let assembliesPaths = HashSet<FileSystemPath>()
+    let getScriptReferences (scriptPath: VirtualFileSystemPath) scriptOptions =
+        let assembliesPaths = HashSet<VirtualFileSystemPath>()
         for o in scriptOptions.OtherOptions do
             if o.StartsWith("-r:", StringComparison.Ordinal) then
-                let path = FileSystemPath.TryParse(o.Substring(3))
+                let path = VirtualFileSystemPath.TryParse(o.Substring(3), InteractionContext.SolutionContext)
                 if not path.IsEmpty then assembliesPaths.Add(path) |> ignore
 
-        let filesPaths = HashSet<FileSystemPath>()
+        let filesPaths = HashSet<VirtualFileSystemPath>()
         for file in scriptOptions.SourceFiles do
-            let path = FileSystemPath.TryParse(file)
+            let path = VirtualFileSystemPath.TryParse(file, InteractionContext.SolutionContext)
             if not path.IsEmpty && not (path.Equals(scriptPath)) then
                 filesPaths.Add(path) |> ignore
 
@@ -136,7 +136,7 @@ type FSharpScriptPsiModulesProvider(lifetime: Lifetime, solution: ISolution, cha
 
         psiModule
 
-    and createPsiModuleForPath (path: FileSystemPath) changeBuilder =
+    and createPsiModuleForPath (path: VirtualFileSystemPath) changeBuilder =
         let modulesForPath = getPsiModulesForPath path
         if modulesForPath.IsEmpty() then
             let fileDocument = documentManager.GetOrCreateDocument(path)
@@ -147,7 +147,7 @@ type FSharpScriptPsiModulesProvider(lifetime: Lifetime, solution: ISolution, cha
             scriptsFromPaths.[path] <- psiModule
             addPsiModule psiModule
 
-    let rec updateReferences (path: FileSystemPath) (document: IDocument) =
+    let rec updateReferences (path: VirtualFileSystemPath) (document: IDocument) =
         locks.QueueReadLock(lifetime, "Request new F# script references", fun _ ->
             let mutable oldReferences = Unchecked.defaultof<ScriptReferences>
             match scriptsReferences.TryGetValue(path, &oldReferences) with
@@ -238,7 +238,7 @@ type FSharpScriptPsiModulesProvider(lifetime: Lifetime, solution: ISolution, cha
         resultModule <- psiModule
         true
 
-    member x.CreatePsiModuleForPath(path: FileSystemPath, changeBuilder: PsiModuleChangeBuilder) =
+    member x.CreatePsiModuleForPath(path: VirtualFileSystemPath, changeBuilder: PsiModuleChangeBuilder) =
         locks.AssertWriteAccessAllowed()
         createPsiModuleForPath path changeBuilder
 
@@ -314,7 +314,7 @@ type FSharpScriptPsiModuleHandler(lifetime, solution, handler, modulesProvider,
     inherit DelegatingProjectPsiModuleHandler(handler)
 
     let locks = solution.Locks
-    let sourceFiles = Dictionary<FileSystemPath, IPsiSourceFile>()
+    let sourceFiles = Dictionary<VirtualFileSystemPath, IPsiSourceFile>()
 
     do
         lifetime.OnTermination(fun _ ->
@@ -378,7 +378,7 @@ type FSharpScriptPsiModule(lifetime, path, solution, sourceFileCtor, moduleId, a
     // We create at most one psi module for each project file and update list of handlers pointing to it.
     let projectHandlers = List<IProjectPsiModuleHandler>()
 
-    let assemblyCookies = DictionaryEvents<FileSystemPath, IAssemblyCookie>(lifetime, moduleId)
+    let assemblyCookies = DictionaryEvents<VirtualFileSystemPath, IAssemblyCookie>(lifetime, moduleId)
 
     do
         assemblyCookies.AddRemove.Advise_Remove(lifetime, fun (AddRemoveArgs (KeyValue (_, assemblyCookie))) ->
@@ -400,12 +400,12 @@ type FSharpScriptPsiModule(lifetime, path, solution, sourceFileCtor, moduleId, a
 
     member x.IsValid = psiServices.Modules.HasModule(this)
 
-    member x.AddReference(path: FileSystemPath) =
+    member x.AddReference(path: VirtualFileSystemPath) =
         solution.Locks.AssertWriteAccessAllowed()
         if not (assemblyCookies.ContainsKey(path)) then
             assemblyCookies.Add(path, assemblyFactory.AddRef(AssemblyLocation(path), moduleId, this.ResolveContext))
 
-    member x.RemoveReference(path: FileSystemPath) =
+    member x.RemoveReference(path: VirtualFileSystemPath) =
         solution.Locks.AssertWriteAccessAllowed()
         if assemblyCookies.ContainsKey(path) then
             assemblyCookies.Remove(path) |> ignore
@@ -459,11 +459,11 @@ type IFSharpFileService =
     abstract member IsScriptLike: IPsiSourceFile -> bool
 
     /// True when file is an IntelliJ scratch file.
-    abstract member IsScratchFile: FileSystemPath -> bool
+    abstract member IsScratchFile: VirtualFileSystemPath -> bool
 
 
 /// Holder for psi module resolve context.
-type FSharpScriptModule(path: FileSystemPath, solution: ISolution) =
+type FSharpScriptModule(path: VirtualFileSystemPath, solution: ISolution) =
     inherit UserDataHolder()
 
     static let scratchesPath = RelativePath.TryParse("Scratches")
@@ -507,8 +507,8 @@ type ScriptFileProperties() =
 
 
 type ScriptReferences =
-    { Assemblies: ISet<FileSystemPath>
-      Files: ISet<FileSystemPath> }
+    { Assemblies: ISet<VirtualFileSystemPath>
+      Files: ISet<VirtualFileSystemPath> }
 
 
 [<SolutionFeaturePart>]