Add inferred type hint stage

ReSharper.FSharp/Directory.Build.props

@@ -9,7 +9,7 @@
 
   <PropertyGroup>
     <FantomasVersion>2020.1.4</FantomasVersion>
-    <FSharpCompilerServiceVersion>2020.1.12</FSharpCompilerServiceVersion>
+    <FSharpCompilerServiceVersion>2020.2.0</FSharpCompilerServiceVersion>
     <FSharpCoreVersion>4.7.0</FSharpCoreVersion>
     <ValueTupleVersion>4.5.0</ValueTupleVersion>
   </PropertyGroup>

ReSharper.FSharp/ReSharper.FSharp.sln.DotSettings

@@ -8,9 +8,18 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpUseContinuousIndentInsideBracesMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=deindenting/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=elif/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=exprs/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=failwith/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=failwithf/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=hotspots/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=noconditionalerasure/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Qualifiable/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Rarrow/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=RSRP/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=simpleresolution/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=targetprofile/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Tupled/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=warnon/@EntryIndexedValue">True</s:Boolean>
 </wpf:ResourceDictionary>

ReSharper.FSharp/src/Daemon.FSharp/src/FSharpSymbolHighlightingUtil.cs

@@ -13,65 +13,65 @@ public static class FSharpSymbolHighlightingUtil
     public static string GetEntityHighlightingAttributeId([NotNull] this FSharpEntity entity)
     {
       if (entity.IsNamespace)
-        return FSharpHighlightingAttributeIds.Namespace;
+        return FSharpHighlightingAttributeIdsModule.Namespace;
 
       if (entity.IsEnum)
-        return FSharpHighlightingAttributeIds.Enum;
+        return FSharpHighlightingAttributeIdsModule.Enum;
 
       if (entity.IsValueType)
-        return FSharpHighlightingAttributeIds.Struct;
+        return FSharpHighlightingAttributeIdsModule.Struct;
 
       if (entity.IsDelegate)
-        return FSharpHighlightingAttributeIds.Delegate;
+        return FSharpHighlightingAttributeIdsModule.Delegate;
 
       if (entity.IsFSharpModule)
-        return FSharpHighlightingAttributeIds.Module;
+        return FSharpHighlightingAttributeIdsModule.Module;
 
       if (entity.IsFSharpUnion)
-        return FSharpHighlightingAttributeIds.Union;
+        return FSharpHighlightingAttributeIdsModule.Union;
 
       if (entity.IsFSharpRecord)
-        return FSharpHighlightingAttributeIds.Record;
+        return FSharpHighlightingAttributeIdsModule.Record;
 
       return entity.IsInterface
-        ? FSharpHighlightingAttributeIds.Interface
-        : FSharpHighlightingAttributeIds.Class;
+        ? FSharpHighlightingAttributeIdsModule.Interface
+        : FSharpHighlightingAttributeIdsModule.Class;
     }
 
     [NotNull]
     public static string GetMfvHighlightingAttributeId([NotNull] this FSharpMemberOrFunctionOrValue mfv)
     {
       if (mfv.IsEvent || mfv.IsEventAddMethod || mfv.IsEventRemoveMethod || mfv.EventForFSharpProperty != null)
-        return FSharpHighlightingAttributeIds.Event;
+        return FSharpHighlightingAttributeIdsModule.Event;
 
       if (mfv.IsImplicitConstructor || mfv.IsConstructor)
         return mfv.DeclaringEntity?.Value is FSharpEntity declEntity && declEntity.IsValueType
-          ? FSharpHighlightingAttributeIds.Struct
-          : FSharpHighlightingAttributeIds.Class;
+          ? FSharpHighlightingAttributeIdsModule.Struct
+          : FSharpHighlightingAttributeIdsModule.Class;
 
       var entity = mfv.DeclaringEntity;
       if (mfv.IsModuleValueOrMember && (entity != null && !entity.Value.IsFSharpModule || mfv.IsExtensionMember))
         return mfv.IsProperty || mfv.IsPropertyGetterMethod || mfv.IsPropertySetterMethod
-          ? FSharpHighlightingAttributeIds.Property
-          : FSharpHighlightingAttributeIds.Method;
+          ? FSharpHighlightingAttributeIdsModule.Property
+          : FSharpHighlightingAttributeIdsModule.Method;
 
       if (mfv.LiteralValue != null)
-        return FSharpHighlightingAttributeIds.Literal;
+        return FSharpHighlightingAttributeIdsModule.Literal;
 
       if (mfv.IsActivePattern)
-        return FSharpHighlightingAttributeIds.ActivePatternCase;
+        return FSharpHighlightingAttributeIdsModule.ActivePatternCase;
 
       if (mfv.IsMutable || mfv.IsRefCell())
-        return FSharpHighlightingAttributeIds.MutableValue;
+        return FSharpHighlightingAttributeIdsModule.MutableValue;
 
       if (IsMangledOpName(mfv.LogicalName))
-        return FSharpHighlightingAttributeIds.Operator;
+        return FSharpHighlightingAttributeIdsModule.Operator;
 
       var fsType = mfv.FullType;
       if (fsType.HasTypeDefinition && fsType.TypeDefinition is var mfvTypeEntity && mfvTypeEntity.IsByRef)
-        return FSharpHighlightingAttributeIds.MutableValue;
+        return FSharpHighlightingAttributeIdsModule.MutableValue;
 
-      return FSharpHighlightingAttributeIds.Value;
+      return FSharpHighlightingAttributeIdsModule.Value;
     }
 
     [NotNull]
@@ -87,21 +87,21 @@ public static string GetHighlightingAttributeId([NotNull] this FSharpSymbol symb
 
         case FSharpField field:
           return field.IsLiteral
-            ? FSharpHighlightingAttributeIds.Literal
-            : FSharpHighlightingAttributeIds.Field;
+            ? FSharpHighlightingAttributeIdsModule.Literal
+            : FSharpHighlightingAttributeIdsModule.Field;
 
         case FSharpUnionCase _:
-          return FSharpHighlightingAttributeIds.UnionCase;
+          return FSharpHighlightingAttributeIdsModule.UnionCase;
 
         case FSharpGenericParameter _:
-          return FSharpHighlightingAttributeIds.TypeParameter;
+          return FSharpHighlightingAttributeIdsModule.TypeParameter;
 
         case FSharpActivePatternCase _:
-          return FSharpHighlightingAttributeIds.ActivePatternCase;
+          return FSharpHighlightingAttributeIdsModule.ActivePatternCase;
       }
 
       // some highlighting is needed for tooltip provider
-      return FSharpHighlightingAttributeIds.Value;
+      return FSharpHighlightingAttributeIdsModule.Value;
     }
   }
 }

ReSharper.FSharp/src/Daemon.FSharp/src/Highlightings/IdentifierHighlighting.cs

@@ -9,7 +9,7 @@ public interface IFSharpIdentifierTooltipProvider
   }
 
   [DaemonTooltipProvider(typeof(IFSharpIdentifierTooltipProvider))]
-  [StaticSeverityHighlighting(Severity.INFO, HighlightingGroupIds.IdentifierHighlightingsGroup,
+  [StaticSeverityHighlighting(Severity.INFO, typeof(HighlightingGroupIds.IdentifierHighlightings),
     OverlapResolve = OverlapResolveKind.NONE, ShowToolTipInStatusBar = false)]
   public class FSharpIdentifierHighlighting : ICustomAttributeIdHighlighting
   {

ReSharper.FSharp/src/Daemon.FSharp/src/Stages/HighlightIdentifiersStage.cs

@@ -45,7 +45,7 @@ private void AddHighlightings(IEnumerable<FSharpResolvedSymbolUse> symbolsUses,
 
         var highlightingId =
           symbolUse.IsFromComputationExpression
-            ? FSharpHighlightingAttributeIds.Keyword
+            ? FSharpHighlightingAttributeIdsModule.Keyword
             : symbol.GetHighlightingAttributeId();
 
         if (symbolUse.IsFromDefinition && symbol is FSharpMemberOrFunctionOrValue mfv)

ReSharper.FSharp/src/FSharp.Common/FSharp.Common.fsproj

@@ -39,8 +39,10 @@
     <Compile Include="src\ProjectModel\FSharpFileService.fs" />
     <Compile Include="src\ProjectModel\FSharpProjectPresenter.fs" />
     <Compile Include="src\ProjectModel\ProjectLoadDiagnostics.fs" />
-    <Compile Include="src\Checker\FSharpProjectOptionsBuilder.fs" />
-    <Compile Include="src\Checker\FSharpProjectOptionsProvider.fs" />
+    <Compile Include="src\Checker\ScriptFcsProjectProvider.fs" />
+    <Compile Include="src\Checker\FcsProjectBuilder.fs" />
+    <Compile Include="src\Checker\FcsProjectProvider.fs" />
+    <Compile Include="src\FcsReactorMonitor.fs" />
     <Compile Include="src\PaketRestoreTargetsAnalyzer.fs" />
   </ItemGroup>
 

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

@@ -1,7 +1,6 @@
 namespace rec JetBrains.ReSharper.Plugins.FSharp.Checker
 
 open System
-open System.Collections.Generic
 open System.Runtime.InteropServices
 open FSharp.Compiler.SourceCodeServices
 open FSharp.Compiler.Text
@@ -11,6 +10,7 @@ open JetBrains.Application
 open JetBrains.Application.Settings
 open JetBrains.DataFlow
 open JetBrains.DocumentModel
+open JetBrains.Lifetimes
 open JetBrains.ProjectModel
 open JetBrains.ReSharper.Feature.Services
 open JetBrains.ReSharper.Plugins.FSharp
@@ -21,10 +21,15 @@ open JetBrains.ReSharper.Psi.Modules
 open JetBrains.ReSharper.Psi.Tree
 open JetBrains.Util
 
+module FSharpCheckerService =
+    let getSourceText (document: IDocument) =
+        SourceText.ofString(document.GetText())
+
+
 [<ShellComponent; AllowNullLiteral>]
 type FSharpCheckerService
-        (lifetime, logger: ILogger, onSolutionCloseNotifier: OnSolutionCloseNotifier, settingsStore: ISettingsStore,
-         settingsSchema: SettingsSchema) =
+        (lifetime: Lifetime, logger: ILogger, onSolutionCloseNotifier: OnSolutionCloseNotifier,
+         settingsStore: ISettingsStore, settingsSchema: SettingsSchema) =
 
     let checker =
         Environment.SetEnvironmentVariable("FCS_CheckFileInProjectCacheSize", "20")
@@ -55,13 +60,23 @@ type FSharpCheckerService
             if checker.IsValueCreated then
                 checker.Value.InvalidateAll())
 
-    member val OptionsProvider = Unchecked.defaultof<IFSharpProjectOptionsProvider> with get, set
+    member val FcsReactorMonitor = Unchecked.defaultof<IFcsReactorMonitor> with get, set
+    member val FcsProjectProvider = Unchecked.defaultof<IFcsProjectProvider> with get, set
+
     member x.Checker = checker.Value
 
-    member x.ParseFile(path: FileSystemPath, document: IDocument, parsingOptions: FSharpParsingOptions) =
-        let source = SourceText.ofString (document.GetText())
+    member x.ParseFile(path, document, parsingOptions, [<Optional; DefaultParameterValue(false)>] noCache: bool) =
         try
-            let parseResults = x.Checker.ParseFile(path.FullPath, source, parsingOptions).RunAsTask() 
+            let source = FSharpCheckerService.getSourceText document
+            let fullPath = getFullPath path
+
+            let parseAsync =
+                if noCache then
+                    x.Checker.ParseFileNoCache(fullPath, source, parsingOptions)
+                else
+                    x.Checker.ParseFile(fullPath, source, parsingOptions)
+
+            let parseResults = parseAsync.RunAsTask()
             Some parseResults
         with
         | OperationCanceled -> reraise()
@@ -71,21 +86,23 @@ type FSharpCheckerService
             None
 
     member x.ParseFile([<NotNull>] sourceFile: IPsiSourceFile) =
-        let parsingOptions = x.OptionsProvider.GetParsingOptions(sourceFile)
+        let parsingOptions = x.FcsProjectProvider.GetParsingOptions(sourceFile)
         x.ParseFile(sourceFile.GetLocation(), sourceFile.Document, parsingOptions)
 
     member x.ParseAndCheckFile([<NotNull>] file: IPsiSourceFile, opName,
                                [<Optional; DefaultParameterValue(false)>] allowStaleResults) =
-        match x.OptionsProvider.GetProjectOptions(file) with
+        match x.FcsProjectProvider.GetProjectOptions(file) with
         | None -> None
         | Some options ->
 
         let path = file.GetLocation().FullPath
-        let source = SourceText.ofString (file.Document.GetText())
+        let source = FSharpCheckerService.getSourceText file.Document
         logger.Trace("ParseAndCheckFile: start {0}, {1}", path, opName)
 
+        use op = x.FcsReactorMonitor.MonitorOperation opName
+
         // todo: don't cancel the computation when file didn't change
-        match x.Checker.ParseAndCheckDocument(path, source, options, allowStaleResults, opName).RunAsTask() with
+        match x.Checker.ParseAndCheckDocument(path, source, options, allowStaleResults, op.OperationName).RunAsTask() with
         | Some (parseResults, checkResults) when parseResults.ParseTree.IsSome ->
             logger.Trace("ParseAndCheckFile: finish {0}, {1}", path, opName)
             Some { ParseResults = parseResults; CheckResults = checkResults }
@@ -95,7 +112,7 @@ type FSharpCheckerService
             None
 
     member x.TryGetStaleCheckResults([<NotNull>] file: IPsiSourceFile, opName) =
-        match x.OptionsProvider.GetProjectOptions(file) with
+        match x.FcsProjectProvider.GetProjectOptions(file) with
         | None -> None
         | Some options ->
 
@@ -111,9 +128,9 @@ type FSharpCheckerService
             logger.Trace("TryGetStaleCheckResults: fail {0}, {1}", path, opName)
             None
 
-    member x.InvalidateFSharpProject(fsProject: FSharpProject) =
+    member x.InvalidateFcsProject(fcsProjectOptions: FSharpProjectOptions) =
         if checker.IsValueCreated then
-            checker.Value.InvalidateConfiguration(fsProject.ProjectOptions, false)
+            checker.Value.InvalidateConfiguration(fcsProjectOptions, false)
 
     /// Use with care: returns wrong symbol inside its non-recursive declaration, see dotnet/fsharp#7694.
     member x.ResolveNameAtLocation(sourceFile: IPsiSourceFile, names, coords, opName) =
@@ -123,7 +140,9 @@ type FSharpCheckerService
             let checkResults = results.CheckResults
             let fcsPos = getPosFromCoords coords
             let lineText = sourceFile.Document.GetLineText(coords.Line)
-            checkResults.GetSymbolUseAtLocation(fcsPos.Line, fcsPos.Column, lineText, names, opName).RunAsTask())
+
+            use op = x.FcsReactorMonitor.MonitorOperation opName
+            checkResults.GetSymbolUseAtLocation(fcsPos.Line, fcsPos.Column, lineText, names, op.OperationName).RunAsTask())
 
     /// Use with care: returns wrong symbol inside its non-recursive declaration, see dotnet/fsharp#7694.
     member x.ResolveNameAtLocation(sourceFile: IPsiSourceFile, name, coords, opName) =
@@ -137,31 +156,37 @@ type FSharpCheckerService
         x.ResolveNameAtLocation(sourceFile, names, coords, opName)
 
 
-type FSharpProject =
-    { ProjectOptions: FSharpProjectOptions
-      ParsingOptions: FSharpParsingOptions
-      FileIndices: IDictionary<FileSystemPath, int>
-      ImplFilesWithSigs: ISet<FileSystemPath> }
-
-    member x.ContainsFile(file: IPsiSourceFile) =
-        x.FileIndices.ContainsKey(file.GetLocation())
-
-
 type FSharpParseAndCheckResults = 
     { ParseResults: FSharpParseFileResults
       CheckResults: FSharpCheckFileResults }
 
 
-type IFSharpProjectOptionsProvider =
+type IFcsProjectProvider =
     abstract GetProjectOptions: IPsiSourceFile -> FSharpProjectOptions option
     abstract GetParsingOptions: IPsiSourceFile -> FSharpParsingOptions
     abstract GetFileIndex: IPsiSourceFile -> int
+
+    // Indicates if implementation file has an associated signature file.
     abstract HasPairFile: IPsiSourceFile -> bool
-    abstract Invalidate: IProject -> bool
+
+    /// Returns True when the project has been invalidated.
+    abstract InvalidateReferencesToProject: IProject -> bool
+
     abstract ModuleInvalidated: ISignal<IPsiModule>
-    abstract HasFSharpProjects: bool
+
+    /// True when any F# projects are currently known to project options provider after requesting info from FCS.
+    abstract HasFcsProjects: bool
 
 
-type IFSharpScriptProjectOptionsProvider =
+type IScriptFcsProjectProvider =
     abstract GetScriptOptions: IPsiSourceFile -> FSharpProjectOptions option
     abstract GetScriptOptions: FileSystemPath * string -> FSharpProjectOptions option
+
+
+type IMonitoredReactorOperation =
+    inherit IDisposable
+    abstract OperationName : string
+
+
+type IFcsReactorMonitor =
+    abstract MonitorOperation : opName: string -> IMonitoredReactorOperation