Psi: rename FSharpResolvedSymbolsCache -> FcsResolvedSymbolsCache

auduchinok · auduchinok · commit b0e3a5fe42d0 · 2021-06-04T15:23:05.000+03:00
diff --git a/ReSharper.FSharp/src/FSharp.Psi.Features/src/LanguageService/FSharpLanguageService.fs b/ReSharper.FSharp/src/FSharp.Psi.Features/src/LanguageService/FSharpLanguageService.fs
@@ -31,7 +31,7 @@ type FSharpLanguageService(languageType, constantValueService, cacheProvider: FS
 
     let getSymbolsCache (psiModule: IPsiModule) =
         if isNull psiModule then null else
-        psiModule.GetSolution().GetComponent<IFSharpResolvedSymbolsCache>()
+        psiModule.GetSolution().GetComponent<IFcsResolvedSymbolsCache>()
 
     override x.IsCaseSensitive = true
     override x.SupportTypeMemberCache = true
diff --git a/ReSharper.FSharp/src/FSharp.Psi.Features/src/Parsing/FSharpParser.fs b/ReSharper.FSharp/src/FSharp.Psi.Features/src/Parsing/FSharpParser.fs
@@ -15,7 +15,7 @@ open JetBrains.ReSharper.Psi
 open JetBrains.ReSharper.Psi.Parsing
 
 type FSharpParser(lexer: ILexer, document: IDocument, path: FileSystemPath, sourceFile: IPsiSourceFile,
-        checkerService: FcsCheckerService, symbolsCache: IFSharpResolvedSymbolsCache) =
+        checkerService: FcsCheckerService, symbolsCache: IFcsResolvedSymbolsCache) =
 
     let tryCreateTreeBuilder lexer lifetime =
         Option.map (fun (parseResults: FSharpParseFileResults) ->
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Features/Daemon/Stages/HighlightIdentifiersStage.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Features/Daemon/Stages/HighlightIdentifiersStage.cs
@@ -34,7 +34,7 @@ public class HighlightIdentifiersStageProcess : FSharpDaemonStageProcessBase
     public HighlightIdentifiersStageProcess([NotNull] IFSharpFile fsFile, [NotNull] IDaemonProcess process)
       : base(fsFile, process) => myDocument = process.Document;
 
-    private void AddHighlightings(IEnumerable<FSharpResolvedSymbolUse> symbolsUses,
+    private void AddHighlightings(IEnumerable<FcsResolvedSymbolUse> symbolsUses,
       ICollection<HighlightingInfo> highlightings)
     {
       foreach (var resolvedSymbolUse in symbolsUses)
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Impl/Tree/FSharpFileBase.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Impl/Tree/FSharpFileBase.cs
@@ -21,7 +21,7 @@ internal abstract class FSharpFileBase : FileElementBase, IFSharpFileCheckInfoOw
     public FcsCheckerService CheckerService => FcsCheckerService;
 
     // ReSharper disable once NotNullMemberIsNotInitialized
-    public IFSharpResolvedSymbolsCache ResolvedSymbolsCache { get; set; }
+    public IFcsResolvedSymbolsCache ResolvedSymbolsCache { get; set; }
 
     private readonly CachedPsiValue<FSharpOption<FSharpParseFileResults>> myParseResults =
       new FileCachedPsiValue<FSharpOption<FSharpParseFileResults>>();
@@ -47,10 +47,10 @@ public FSharpOption<FSharpParseAndCheckResults> GetParseAndCheckResults(bool all
     public FSharpSymbol GetSymbol(int offset) =>
       ResolvedSymbolsCache.GetSymbol(SourceFile, offset);
 
-    public IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols(FSharpCheckFileResults checkResults = null) =>
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols(FSharpCheckFileResults checkResults = null) =>
       ResolvedSymbolsCache.GetAllResolvedSymbols(SourceFile);
 
-    public IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols(FSharpCheckFileResults checkResults = null) =>
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols(FSharpCheckFileResults checkResults = null) =>
       ResolvedSymbolsCache.GetAllDeclaredSymbols(SourceFile);
 
     public FSharpSymbolUse GetSymbolUse(int offset) =>
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/EmptyFcsFileResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/EmptyFcsFileResolvedSymbols.cs
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using FSharp.Compiler.CodeAnalysis;
+using FSharp.Compiler.Symbols;
+using JetBrains.Util;
+
+namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
+{
+  public class EmptyFcsFileResolvedSymbols : IFcsFileResolvedSymbols
+  {
+    public static IFcsFileResolvedSymbols Instance = new EmptyFcsFileResolvedSymbols();
+
+    public FSharpSymbolUse GetSymbolUse(int offset) => null;
+    public FSharpSymbolUse GetSymbolDeclaration(int offset) => null;
+
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols() =>
+      EmptyList<FcsResolvedSymbolUse>.Instance;
+
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols() =>
+      EmptyList<FcsResolvedSymbolUse>.Instance;
+
+    public FSharpSymbol GetSymbol(int offset) => null;
+  }
+}
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/EmptyFileResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/EmptyFileResolvedSymbols.cs
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FSharpMiscModuleResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FSharpMiscModuleResolvedSymbols.cs
@@ -14,7 +14,7 @@ public void Invalidate(IPsiSourceFile sourceFile)
     {
     }
 
-    public IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile) =>
-      EmptyFileResolvedSymbols.Instance;
+    public IFcsFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile) =>
+      EmptyFcsFileResolvedSymbols.Instance;
   }
 }
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FSharpModuleResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FSharpModuleResolvedSymbols.cs
@@ -7,7 +7,7 @@ namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
 {
   public class FSharpModuleResolvedSymbols : IFSharpModuleResolvedSymbols
   {
-    private readonly FSharpFileResolvedSymbols[] myFileResolvedSymbols;
+    private readonly FcsFileResolvedSymbols[] myFileResolvedSymbols;
 
     public IPsiModule PsiModule { get; }
     public FcsCheckerService CheckerService { get; }
@@ -18,7 +18,7 @@ public class FSharpModuleResolvedSymbols : IFSharpModuleResolvedSymbols
     public FSharpModuleResolvedSymbols(IPsiModule psiModule, int filesCount, FcsCheckerService checkerService,
       IFcsProjectProvider fcsProjectProvider)
     {
-      myFileResolvedSymbols = new FSharpFileResolvedSymbols[filesCount];
+      myFileResolvedSymbols = new FcsFileResolvedSymbols[filesCount];
 
       PsiModule = psiModule;
       CheckerService = checkerService;
@@ -39,13 +39,13 @@ public void Invalidate(IPsiSourceFile sourceFile)
       }
     }
 
-    private FSharpFileResolvedSymbols TryGetResolvedSymbols(int fileIndex)
+    private FcsFileResolvedSymbols TryGetResolvedSymbols(int fileIndex)
     {
       using (myLock.UsingReadLock())
         return myFileResolvedSymbols[fileIndex];
     }
 
-    public IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile)
+    public IFcsFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile)
     {
       var fileIndex = FcsProjectProvider.GetFileIndex(sourceFile);
       var fileResolvedSymbols = TryGetResolvedSymbols(fileIndex);
@@ -58,7 +58,7 @@ public IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile)
         if (fileResolvedSymbols != null)
           return fileResolvedSymbols;
 
-        fileResolvedSymbols = new FSharpFileResolvedSymbols(sourceFile, CheckerService);
+        fileResolvedSymbols = new FcsFileResolvedSymbols(sourceFile, CheckerService);
         myFileResolvedSymbols[fileIndex] = fileResolvedSymbols;
       }
 
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FcsFileResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FcsFileResolvedSymbols.cs
@@ -23,7 +23,7 @@
 
 namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
 {
-  public class FSharpFileResolvedSymbols : IFSharpFileResolvedSymbols
+  public class FcsFileResolvedSymbols : IFcsFileResolvedSymbols
   {
     private const string OpName = "FSharpFileResolvedSymbols";
 
@@ -33,7 +33,7 @@ public class FSharpFileResolvedSymbols : IFSharpFileResolvedSymbols
     [NotNull] public IPsiSourceFile SourceFile { get; }
     [NotNull] public FcsCheckerService CheckerService { get; }
 
-    public FSharpFileResolvedSymbols([NotNull] IPsiSourceFile sourceFile, [NotNull] FcsCheckerService checkerService)
+    public FcsFileResolvedSymbols([NotNull] IPsiSourceFile sourceFile, [NotNull] FcsCheckerService checkerService)
     {
       SourceFile = sourceFile;
       CheckerService = checkerService;
@@ -70,13 +70,13 @@ public FSharpSymbolUse GetSymbolDeclaration(int offset)
       return resolvedSymbols.Declarations.TryGetValue(offset)?.SymbolUse;
     }
 
-    public IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols()
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols()
     {
       var resolvedSymbols = GetResolvedSymbols();
       return resolvedSymbols.Declarations.Values.AsChunkIReadOnlyList();
     }
 
-    public IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols()
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols()
     {
       var resolvedSymbols = GetResolvedSymbols();
       return resolvedSymbols.Uses.Values.AsChunkIReadOnlyList();
@@ -168,12 +168,12 @@ private ResolvedSymbols CreateFileResolvedSymbols()
               var (caseStart, caseEnd) = caseDeclaration.GetTreeTextRange();
               var caseStartOffset = caseStart.Offset;
               var caseTextRange = new TextRange(caseStartOffset, caseEnd.Offset);
-              resolvedSymbols.Declarations[caseStartOffset] = new FSharpResolvedSymbolUse(symbolUse, caseTextRange);
+              resolvedSymbols.Declarations[caseStartOffset] = new FcsResolvedSymbolUse(symbolUse, caseTextRange);
               continue;
             }
 
             var caseUseInBindingRange = new TextRange(startOffset, endOffset);
-            resolvedSymbols.Uses[startOffset] = new FSharpResolvedSymbolUse(symbolUse, caseUseInBindingRange);
+            resolvedSymbols.Uses[startOffset] = new FcsResolvedSymbolUse(symbolUse, caseUseInBindingRange);
             continue;
           }
           else
@@ -188,7 +188,7 @@ private ResolvedSymbols CreateFileResolvedSymbols()
             : FixRange(startOffset, endOffset, null, buffer, lexer);
           startOffset = textRange.StartOffset;
 
-          resolvedSymbols.Declarations[startOffset] = new FSharpResolvedSymbolUse(symbolUse, textRange);
+          resolvedSymbols.Declarations[startOffset] = new FcsResolvedSymbolUse(symbolUse, textRange);
           resolvedSymbols.Uses.Remove(startOffset);
         }
         else
@@ -243,7 +243,7 @@ private ResolvedSymbols CreateFileResolvedSymbols()
                 existingSymbol.SymbolUse.Symbol is FSharpEntity && !isCtor)
               continue;
 
-            resolvedSymbols.Uses[startOffset] = new FSharpResolvedSymbolUse(symbolUse, nameRange);
+            resolvedSymbols.Uses[startOffset] = new FcsResolvedSymbolUse(symbolUse, nameRange);
           }
 
           if (symbolUse.IsFromPattern)
@@ -302,13 +302,13 @@ private class ResolvedSymbols
     {
       public static readonly ResolvedSymbols Empty = new ResolvedSymbols();
 
-      [NotNull] internal readonly CompactMap<int, FSharpResolvedSymbolUse> Declarations;
-      [NotNull] internal readonly CompactMap<int, FSharpResolvedSymbolUse> Uses;
+      [NotNull] internal readonly CompactMap<int, FcsResolvedSymbolUse> Declarations;
+      [NotNull] internal readonly CompactMap<int, FcsResolvedSymbolUse> Uses;
 
       public ResolvedSymbols(int symbolUsesCount = 0)
       {
-        Declarations = new CompactMap<int, FSharpResolvedSymbolUse>(symbolUsesCount / 4);
-        Uses = new CompactMap<int, FSharpResolvedSymbolUse>(symbolUsesCount);
+        Declarations = new CompactMap<int, FcsResolvedSymbolUse>(symbolUsesCount / 4);
+        Uses = new CompactMap<int, FcsResolvedSymbolUse>(symbolUsesCount);
       }
     }
 
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FcsResolvedSymbolUse.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FcsResolvedSymbolUse.cs
@@ -4,14 +4,14 @@
 
 namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
 {
-  public class FSharpResolvedSymbolUse
+  public class FcsResolvedSymbolUse
   {
     [NotNull]
     public FSharpSymbolUse SymbolUse { get; }
 
     public TextRange Range { get; }
 
-    public FSharpResolvedSymbolUse([NotNull] FSharpSymbolUse symbolUse, TextRange range)
+    public FcsResolvedSymbolUse([NotNull] FSharpSymbolUse symbolUse, TextRange range)
     {
       SymbolUse = symbolUse;
       Range = range;
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FcsResolvedSymbolsCache.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/FcsResolvedSymbolsCache.cs
@@ -20,7 +20,7 @@
 namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
 {
   [SolutionComponent]
-  public class FSharpResolvedSymbolsCache : IPsiSourceFileCache, IFSharpResolvedSymbolsCache
+  public class FcsResolvedSymbolsCache : IPsiSourceFileCache, IFcsResolvedSymbolsCache
   {
     public IPsiModules PsiModules { get; }
     public FcsCheckerService CheckerService { get; }
@@ -29,7 +29,7 @@ public class FSharpResolvedSymbolsCache : IPsiSourceFileCache, IFSharpResolvedSy
     private readonly object myLock = new object();
     private readonly ISet<IPsiSourceFile> myDirtyFiles = new HashSet<IPsiSourceFile>();
 
-    public FSharpResolvedSymbolsCache(Lifetime lifetime, FcsCheckerService checkerService, IPsiModules psiModules,
+    public FcsResolvedSymbolsCache(Lifetime lifetime, FcsCheckerService checkerService, IPsiModules psiModules,
       IFcsProjectProvider fcsProjectProvider, AssemblyReaderShim assemblyReaderShim)
     {
       PsiModules = psiModules;
@@ -170,7 +170,7 @@ public bool HasDirtyFiles
     protected readonly IDictionary<IPsiModule, FSharpModuleResolvedSymbols> PsiModulesCaches =
       new Dictionary<IPsiModule, FSharpModuleResolvedSymbols>();
 
-    private IFSharpFileResolvedSymbols GetOrCreateResolvedSymbols(IPsiSourceFile sourceFile) =>
+    private IFcsFileResolvedSymbols GetOrCreateResolvedSymbols(IPsiSourceFile sourceFile) =>
       GetModuleResolvedSymbols(sourceFile).GetResolvedSymbols(sourceFile);
 
     [NotNull]
@@ -206,10 +206,10 @@ public FSharpSymbolUse GetSymbolUse(IPsiSourceFile sourceFile, int offset) =>
     public FSharpSymbolUse GetSymbolDeclaration(IPsiSourceFile sourceFile, int offset) =>
       GetOrCreateResolvedSymbols(sourceFile).GetSymbolDeclaration(offset);
 
-    public IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols(IPsiSourceFile sourceFile) =>
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols(IPsiSourceFile sourceFile) =>
       GetOrCreateResolvedSymbols(sourceFile).GetAllDeclaredSymbols();
 
-    public IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols(IPsiSourceFile sourceFile) =>
+    public IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols(IPsiSourceFile sourceFile) =>
       GetOrCreateResolvedSymbols(sourceFile).GetAllResolvedSymbols();
 
     public FSharpSymbol GetSymbol(IPsiSourceFile sourceFile, int offset) =>
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/IFSharpModuleResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/IFSharpModuleResolvedSymbols.cs
@@ -10,6 +10,6 @@ public interface IFSharpModuleResolvedSymbols
     void Invalidate(IPsiSourceFile sourceFile);
 
     [NotNull]
-    IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile);
+    IFcsFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile);
   }
 }
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/IFcsFileResolvedSymbols.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/IFcsFileResolvedSymbols.cs
@@ -5,7 +5,7 @@
 
 namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
 {
-  public interface IFSharpFileResolvedSymbols
+  public interface IFcsFileResolvedSymbols
   {
     [CanBeNull]
     FSharpSymbolUse GetSymbolUse(int offset);
@@ -14,10 +14,10 @@ public interface IFSharpFileResolvedSymbols
     FSharpSymbolUse GetSymbolDeclaration(int offset);
 
     [NotNull]
-    IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols();
+    IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols();
 
     [NotNull]
-    IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols();
+    IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols();
 
     [CanBeNull] FSharpSymbol GetSymbol(int offset);
   }
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/IFcsResolvedSymbolsCache.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Resolve/IFcsResolvedSymbolsCache.cs
@@ -6,7 +6,7 @@
 
 namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
 {
-  public interface IFSharpResolvedSymbolsCache
+  public interface IFcsResolvedSymbolsCache
   {
     [CanBeNull]
     FSharpSymbolUse GetSymbolUse(IPsiSourceFile sourceFile, int offset);
@@ -15,10 +15,10 @@ public interface IFSharpResolvedSymbolsCache
     FSharpSymbolUse GetSymbolDeclaration(IPsiSourceFile sourceFile, int offset);
 
     [NotNull]
-    IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols(IPsiSourceFile sourceFile);
+    IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols(IPsiSourceFile sourceFile);
 
     [NotNull]
-    IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols(IPsiSourceFile sourceFile);
+    IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols(IPsiSourceFile sourceFile);
 
     [CanBeNull]
     FSharpSymbol GetSymbol(IPsiSourceFile sourceFile, int offset);
diff --git a/ReSharper.FSharp/src/FSharp.Psi/src/Tree/IFSharpFileCheckInfoOwner.cs b/ReSharper.FSharp/src/FSharp.Psi/src/Tree/IFSharpFileCheckInfoOwner.cs
@@ -19,7 +19,7 @@ public interface IFSharpFileCheckInfoOwner : ICompositeElement
 
     [NotNull] FcsCheckerService FcsCheckerService { get; set; }
 
-    [NotNull] IFSharpResolvedSymbolsCache ResolvedSymbolsCache { get; set; }
+    [NotNull] IFcsResolvedSymbolsCache ResolvedSymbolsCache { get; set; }
 
     [CanBeNull] FSharpOption<FSharpParseFileResults> ParseResults { get; set; }
 
@@ -35,10 +35,10 @@ public interface IFSharpFileCheckInfoOwner : ICompositeElement
     FSharpSymbol GetSymbol(int offset);
 
     [NotNull]
-    IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols(FSharpCheckFileResults checkResults = null);
+    IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols(FSharpCheckFileResults checkResults = null);
 
     [NotNull]
-    IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols(FSharpCheckFileResults checkResults = null);
+    IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols(FSharpCheckFileResults checkResults = null);
 
     /// Documents are currently used in F# files parsing for getting line index info.
     /// This property is only set in FSharpElementFactory to make the document accessible without having source file
diff --git a/ReSharper.FSharp/test/src/FSharp.Tests/Common.fs b/ReSharper.FSharp/test/src/FSharp.Tests/Common.fs
@@ -104,12 +104,12 @@ type FSharpLanguageLevelAttribute(languageLevel: FSharpLanguageLevel) =
 
 [<SolutionComponent>]
 type TestFSharpResolvedSymbolsCache(lifetime, checkerService, psiModules, fcsProjectProvider, assemblyReaderShim) =
-    inherit FSharpResolvedSymbolsCache(lifetime, checkerService, psiModules, fcsProjectProvider, assemblyReaderShim)
+    inherit FcsResolvedSymbolsCache(lifetime, checkerService, psiModules, fcsProjectProvider, assemblyReaderShim)
 
     override x.Invalidate _ =
         x.PsiModulesCaches.Clear()
 
-    interface IHideImplementation<FSharpResolvedSymbolsCache>
+    interface IHideImplementation<FcsResolvedSymbolsCache>
 
 
 [<SolutionComponent>]

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public class HighlightIdentifiersStageProcess : FSharpDaemonStageProcessBase`
`34`	`34`	`public HighlightIdentifiersStageProcess([NotNull] IFSharpFile fsFile, [NotNull] IDaemonProcess process)`
`35`	`35`	`: base(fsFile, process) => myDocument = process.Document;`
`36`	`36`
`37`		`- private void AddHighlightings(IEnumerable<FSharpResolvedSymbolUse> symbolsUses,`
	`37`	`+ private void AddHighlightings(IEnumerable<FcsResolvedSymbolUse> symbolsUses,`
`38`	`38`	`ICollection<HighlightingInfo> highlightings)`
`39`	`39`	`{`
`40`	`40`	`foreach (var resolvedSymbolUse in symbolsUses)`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public void Invalidate(IPsiSourceFile sourceFile)`
`14`	`14`	`{`
`15`	`15`	`}`
`16`	`16`
`17`		`- public IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile) =>`
`18`		`- EmptyFileResolvedSymbols.Instance;`
	`17`	`+ public IFcsFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile) =>`
	`18`	`+ EmptyFcsFileResolvedSymbols.Instance;`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve`
`7`	`7`	`{`
`8`	`8`	`public class FSharpModuleResolvedSymbols : IFSharpModuleResolvedSymbols`
`9`	`9`	`{`
`10`		`- private readonly FSharpFileResolvedSymbols[] myFileResolvedSymbols;`
	`10`	`+ private readonly FcsFileResolvedSymbols[] myFileResolvedSymbols;`
`11`	`11`
`12`	`12`	`public IPsiModule PsiModule { get; }`
`13`	`13`	`public FcsCheckerService CheckerService { get; }`
`@@ -18,7 +18,7 @@ public class FSharpModuleResolvedSymbols : IFSharpModuleResolvedSymbols`
`18`	`18`	`public FSharpModuleResolvedSymbols(IPsiModule psiModule, int filesCount, FcsCheckerService checkerService,`
`19`	`19`	`IFcsProjectProvider fcsProjectProvider)`
`20`	`20`	`{`
`21`		`- myFileResolvedSymbols = new FSharpFileResolvedSymbols[filesCount];`
	`21`	`+ myFileResolvedSymbols = new FcsFileResolvedSymbols[filesCount];`
`22`	`22`
`23`	`23`	`PsiModule = psiModule;`
`24`	`24`	`CheckerService = checkerService;`
`@@ -39,13 +39,13 @@ public void Invalidate(IPsiSourceFile sourceFile)`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`- private FSharpFileResolvedSymbols TryGetResolvedSymbols(int fileIndex)`
	`42`	`+ private FcsFileResolvedSymbols TryGetResolvedSymbols(int fileIndex)`
`43`	`43`	`{`
`44`	`44`	`using (myLock.UsingReadLock())`
`45`	`45`	`return myFileResolvedSymbols[fileIndex];`
`46`	`46`	`}`
`47`	`47`
`48`		`- public IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile)`
	`48`	`+ public IFcsFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile)`
`49`	`49`	`{`
`50`	`50`	`var fileIndex = FcsProjectProvider.GetFileIndex(sourceFile);`
`51`	`51`	`var fileResolvedSymbols = TryGetResolvedSymbols(fileIndex);`
`@@ -58,7 +58,7 @@ public IFSharpFileResolvedSymbols GetResolvedSymbols(IPsiSourceFile sourceFile)`
`58`	`58`	`if (fileResolvedSymbols != null)`
`59`	`59`	`return fileResolvedSymbols;`
`60`	`60`
`61`		`- fileResolvedSymbols = new FSharpFileResolvedSymbols(sourceFile, CheckerService);`
	`61`	`+ fileResolvedSymbols = new FcsFileResolvedSymbols(sourceFile, CheckerService);`
`62`	`62`	`myFileResolvedSymbols[fileIndex] = fileResolvedSymbols;`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`
`24`	`24`	`namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve`
`25`	`25`	`{`
`26`		`- public class FSharpFileResolvedSymbols : IFSharpFileResolvedSymbols`
	`26`	`+ public class FcsFileResolvedSymbols : IFcsFileResolvedSymbols`
`27`	`27`	`{`
`28`	`28`	`private const string OpName = "FSharpFileResolvedSymbols";`
`29`	`29`
`@@ -33,7 +33,7 @@ public class FSharpFileResolvedSymbols : IFSharpFileResolvedSymbols`
`33`	`33`	`[NotNull] public IPsiSourceFile SourceFile { get; }`
`34`	`34`	`[NotNull] public FcsCheckerService CheckerService { get; }`
`35`	`35`
`36`		`- public FSharpFileResolvedSymbols([NotNull] IPsiSourceFile sourceFile, [NotNull] FcsCheckerService checkerService)`
	`36`	`+ public FcsFileResolvedSymbols([NotNull] IPsiSourceFile sourceFile, [NotNull] FcsCheckerService checkerService)`
`37`	`37`	`{`
`38`	`38`	`SourceFile = sourceFile;`
`39`	`39`	`CheckerService = checkerService;`
`@@ -70,13 +70,13 @@ public FSharpSymbolUse GetSymbolDeclaration(int offset)`
`70`	`70`	`return resolvedSymbols.Declarations.TryGetValue(offset)?.SymbolUse;`
`71`	`71`	`}`
`72`	`72`
`73`		`- public IReadOnlyList<FSharpResolvedSymbolUse> GetAllDeclaredSymbols()`
	`73`	`+ public IReadOnlyList<FcsResolvedSymbolUse> GetAllDeclaredSymbols()`
`74`	`74`	`{`
`75`	`75`	`var resolvedSymbols = GetResolvedSymbols();`
`76`	`76`	`return resolvedSymbols.Declarations.Values.AsChunkIReadOnlyList();`
`77`	`77`	`}`
`78`	`78`
`79`		`- public IReadOnlyList<FSharpResolvedSymbolUse> GetAllResolvedSymbols()`
	`79`	`+ public IReadOnlyList<FcsResolvedSymbolUse> GetAllResolvedSymbols()`
`80`	`80`	`{`
`81`	`81`	`var resolvedSymbols = GetResolvedSymbols();`
`82`	`82`	`return resolvedSymbols.Uses.Values.AsChunkIReadOnlyList();`
`@@ -168,12 +168,12 @@ private ResolvedSymbols CreateFileResolvedSymbols()`
`168`	`168`	`var (caseStart, caseEnd) = caseDeclaration.GetTreeTextRange();`
`169`	`169`	`var caseStartOffset = caseStart.Offset;`
`170`	`170`	`var caseTextRange = new TextRange(caseStartOffset, caseEnd.Offset);`
`171`		`- resolvedSymbols.Declarations[caseStartOffset] = new FSharpResolvedSymbolUse(symbolUse, caseTextRange);`
	`171`	`+ resolvedSymbols.Declarations[caseStartOffset] = new FcsResolvedSymbolUse(symbolUse, caseTextRange);`
`172`	`172`	`continue;`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`var caseUseInBindingRange = new TextRange(startOffset, endOffset);`
`176`		`- resolvedSymbols.Uses[startOffset] = new FSharpResolvedSymbolUse(symbolUse, caseUseInBindingRange);`
	`176`	`+ resolvedSymbols.Uses[startOffset] = new FcsResolvedSymbolUse(symbolUse, caseUseInBindingRange);`
`177`	`177`	`continue;`
`178`	`178`	`}`
`179`	`179`	`else`
`@@ -188,7 +188,7 @@ private ResolvedSymbols CreateFileResolvedSymbols()`
`188`	`188`	`: FixRange(startOffset, endOffset, null, buffer, lexer);`
`189`	`189`	`startOffset = textRange.StartOffset;`
`190`	`190`
`191`		`- resolvedSymbols.Declarations[startOffset] = new FSharpResolvedSymbolUse(symbolUse, textRange);`
	`191`	`+ resolvedSymbols.Declarations[startOffset] = new FcsResolvedSymbolUse(symbolUse, textRange);`
`192`	`192`	`resolvedSymbols.Uses.Remove(startOffset);`
`193`	`193`	`}`
`194`	`194`	`else`
`@@ -243,7 +243,7 @@ private ResolvedSymbols CreateFileResolvedSymbols()`
`243`	`243`	`existingSymbol.SymbolUse.Symbol is FSharpEntity && !isCtor)`
`244`	`244`	`continue;`
`245`	`245`
`246`		`- resolvedSymbols.Uses[startOffset] = new FSharpResolvedSymbolUse(symbolUse, nameRange);`
	`246`	`+ resolvedSymbols.Uses[startOffset] = new FcsResolvedSymbolUse(symbolUse, nameRange);`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`if (symbolUse.IsFromPattern)`
`@@ -302,13 +302,13 @@ private class ResolvedSymbols`
`302`	`302`	`{`
`303`	`303`	`public static readonly ResolvedSymbols Empty = new ResolvedSymbols();`
`304`	`304`
`305`		`- [NotNull] internal readonly CompactMap<int, FSharpResolvedSymbolUse> Declarations;`
`306`		`- [NotNull] internal readonly CompactMap<int, FSharpResolvedSymbolUse> Uses;`
	`305`	`+ [NotNull] internal readonly CompactMap<int, FcsResolvedSymbolUse> Declarations;`
	`306`	`+ [NotNull] internal readonly CompactMap<int, FcsResolvedSymbolUse> Uses;`
`307`	`307`
`308`	`308`	`public ResolvedSymbols(int symbolUsesCount = 0)`
`309`	`309`	`{`
`310`		`- Declarations = new CompactMap<int, FSharpResolvedSymbolUse>(symbolUsesCount / 4);`
`311`		`- Uses = new CompactMap<int, FSharpResolvedSymbolUse>(symbolUsesCount);`
	`310`	`+ Declarations = new CompactMap<int, FcsResolvedSymbolUse>(symbolUsesCount / 4);`
	`311`	`+ Uses = new CompactMap<int, FcsResolvedSymbolUse>(symbolUsesCount);`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,14 @@`
`4`	`4`
`5`	`5`	`namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve`
`6`	`6`	`{`
`7`		`- public class FSharpResolvedSymbolUse`
	`7`	`+ public class FcsResolvedSymbolUse`
`8`	`8`	`{`
`9`	`9`	`[NotNull]`
`10`	`10`	`public FSharpSymbolUse SymbolUse { get; }`
`11`	`11`
`12`	`12`	`public TextRange Range { get; }`
`13`	`13`
`14`		`- public FSharpResolvedSymbolUse([NotNull] FSharpSymbolUse symbolUse, TextRange range)`
	`14`	`+ public FcsResolvedSymbolUse([NotNull] FSharpSymbolUse symbolUse, TextRange range)`
`15`	`15`	`{`
`16`	`16`	`SymbolUse = symbolUse;`
`17`	`17`	`Range = range;`