add restart type providers action

Author: DedSec256

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

@@ -23,6 +23,7 @@ open JetBrains.ReSharper.Psi.CSharp
 open JetBrains.ReSharper.Psi.Modules
 open JetBrains.ReSharper.Psi.Tree
 open JetBrains.ReSharper.Psi.VB
+open JetBrains.ReSharper.Resources.Shell
 open JetBrains.Util
 
 module FcsCheckerService =
@@ -154,6 +155,7 @@ type FcsCheckerService(lifetime: Lifetime, logger: ILogger, onSolutionCloseNotif
             |> Seq.iter x.InvalidateFcsProject
 
     member x.InvalidateFcsProjects(solution: ISolution, isApplicable: IProject -> bool) =
+        use lock = ReadLockCookie.Create()
         if checker.IsValueCreated then
             solution.GetAllProjects()
             |> Seq.filter isApplicable

ReSharper.FSharp/src/FSharp.Common/src/Settings/FSharpOptions.fs

@@ -77,6 +77,7 @@ module FSharpExperimentalFeatures =
     let [<Literal>] formatter = "Enable F# code formatter"
     let [<Literal>] fsiInteractiveEditor = "Enable analysis of F# Interactive editor (experimental)"
     let [<Literal>] outOfProcessTypeProviders = "Host type providers out-of-process (solution reload required)"
+    let [<Literal>] hostTypeProvidersFromTempFolder = "Host type providers from Temp folder"
 
 
 [<SettingsKey(typeof<FSharpOptions>, "F# experimental features")>]
@@ -94,7 +95,10 @@ type FSharpExperimentalFeatures =
       mutable FsiInteractiveEditor: bool
 
       [<SettingsEntry(true, FSharpExperimentalFeatures.outOfProcessTypeProviders)>]
-      mutable OutOfProcessTypeProviders: bool }
+      mutable OutOfProcessTypeProviders: bool
+
+      [<SettingsEntry(false, FSharpExperimentalFeatures.hostTypeProvidersFromTempFolder)>]
+      mutable HostTypeProvidersFromTempFolder: bool }
 
 
 [<AllowNullLiteral>]
@@ -129,6 +133,7 @@ type FSharpExperimentalFeaturesProvider(lifetime, solution, settings, settingsSc
     member val RedundantParensAnalysis = base.GetValueProperty<bool>("RedundantParensAnalysis")
     member val Formatter = base.GetValueProperty<bool>("Formatter")
     member val OutOfProcessTypeProviders = base.GetValueProperty<bool>("OutOfProcessTypeProviders")
+    member val HostTypeProvidersFromTempFolder = base.GetValueProperty<bool>("HostTypeProvidersFromTempFolder")
 
 
 module FSharpTypeHintOptions =
@@ -176,6 +181,11 @@ type FSharpOptionsPage(lifetime: Lifetime, optionsPageContext, settings,
         this.AddBoolOption((fun key -> key.EnableReactorMonitor), RichText(enableFcsReactorMonitor), null) |> ignore
         this.AddBoolOption((fun key -> key.BackgroundTypeCheck), RichText(backgroundTypeCheck), null) |> ignore
         this.AddBoolOption((fun key -> key.OutOfProcessTypeProviders), RichText(FSharpExperimentalFeatures.outOfProcessTypeProviders), null) |> ignore
+        do
+            use indent = this.Indent()
+            [ this.AddBoolOption((fun key -> key.HostTypeProvidersFromTempFolder), RichText(FSharpExperimentalFeatures.hostTypeProvidersFromTempFolder), null) ]
+            |> Seq.iter (fun checkbox ->
+                this.AddBinding(checkbox, BindingStyle.IsEnabledProperty, (fun key -> key.OutOfProcessTypeProviders), id))
 
         if configurations.IsInternalMode() then
             this.AddHeader("Experimental features options")

ReSharper.FSharp/src/FSharp.Common/src/Shim/TypeProviders/ExtensionTypingProviderShim.fs

@@ -8,10 +8,15 @@ open FSharp.Core.CompilerServices
 open JetBrains.Core
 open JetBrains.Lifetimes
 open JetBrains.ProjectModel
+open JetBrains.ProjectModel.Tasks
+open JetBrains.Rd.Tasks
+open JetBrains.ReSharper.Feature.Services.Daemon
+open JetBrains.ReSharper.Plugins.FSharp.Checker
 open JetBrains.ReSharper.Plugins.FSharp.Settings
 open JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Protocol
 open JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Protocol.Exceptions
 open JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Protocol.Models
+open JetBrains.ReSharper.Psi.Files
 
 type IProxyExtensionTypingProvider =
     inherit IExtensionTypingProvider
@@ -22,10 +27,13 @@ type IProxyExtensionTypingProvider =
 [<SolutionComponent>]
 type ExtensionTypingProviderShim(solution: ISolution, toolset: ISolutionToolset,
         experimentalFeatures: FSharpExperimentalFeaturesProvider,
+        checkerService: FcsCheckerService, daemon: IDaemon, psiFiles: IPsiFiles,
+        scheduler: ISolutionLoadTasksScheduler,
         typeProvidersLoadersFactory: TypeProvidersExternalProcessFactory) as this =
     let lifetime = solution.GetLifetime()
     let defaultShim = ExtensionTypingProvider
     let outOfProcess = experimentalFeatures.OutOfProcessTypeProviders
+    let hostFromTemp = experimentalFeatures.HostTypeProvidersFromTempFolder
 
     let mutable connection: TypeProvidersConnection = null
     let mutable typeProvidersHostLifetime: LifetimeDefinition = null
@@ -35,22 +43,37 @@ type ExtensionTypingProviderShim(solution: ISolution, toolset: ISolutionToolset,
         isNotNull connection && connection.IsActive
 
     let terminateConnection () =
-        if isConnectionAlive() then typeProvidersHostLifetime.Terminate()
+        if isConnectionAlive () then typeProvidersHostLifetime.Terminate()
 
     let connect () =
         if not (isConnectionAlive ()) then
             typeProvidersHostLifetime <- Lifetime.Define(lifetime)
             connection <- typeProvidersLoadersFactory.Create(typeProvidersHostLifetime.Lifetime).Run()
             typeProvidersManager <- TypeProvidersManager(connection) :?> _
 
+    let restart _ =
+        let paths = typeProvidersManager.GetAssemblies()
+        terminateConnection ()
+        checkerService.InvalidateFcsProjects(solution, fun x -> paths.Contains(x.Location))
+        psiFiles.IncrementModificationTimestamp(null)
+        daemon.Invalidate()
+        Unit.Instance
+
     do
-        lifetime.Bracket((fun () -> ExtensionTypingProvider <- this),
-            fun () -> ExtensionTypingProvider <- defaultShim)
+        lifetime.Bracket((fun () -> ExtensionTypingProvider <- this), fun () -> ExtensionTypingProvider <- defaultShim)
 
         toolset.Changed.Advise(lifetime, fun _ -> terminateConnection ())
         outOfProcess.Change.Advise(lifetime, fun enabled ->
             if enabled.HasNew && not enabled.New then terminateConnection ())
 
+        hostFromTemp.Change.Advise(lifetime, fun enabled ->
+            if enabled.HasNew && not enabled.New then terminateConnection ())
+
+        let rdTypeProvidersHost = solution.RdFSharpModel().FSharpTypeProvidersHost
+
+        rdTypeProvidersHost.RestartTypeProviders.Set(restart)
+        rdTypeProvidersHost.IsLaunched.Set(fun _ -> isNotNull connection)
+
     interface IProxyExtensionTypingProvider with
         member this.InstantiateTypeProvidersOfAssembly(runTimeAssemblyFileName: string,
                 designTimeAssemblyNameString: string, resolutionEnvironment: ResolutionEnvironment,
@@ -66,7 +89,7 @@ type ExtensionTypingProviderShim(solution: ISolution, toolset: ISolutionToolset,
                 try
                     typeProvidersManager.GetOrCreate(runTimeAssemblyFileName, designTimeAssemblyNameString,
                         resolutionEnvironment, isInvalidationSupported, isInteractive, systemRuntimeContainsType,
-                        systemRuntimeAssemblyVersion, compilerToolsPath)
+                        systemRuntimeAssemblyVersion, compilerToolsPath, hostFromTemp.Value)
                 with :? TypeProvidersInstantiationException as e  ->
                     logError (TypeProviderError(e.FcsNumber, "", m, [e.Message]))
                     []

ReSharper.FSharp/src/FSharp.Common/src/Shim/TypeProviders/TypeProvidersManager.fs

@@ -48,6 +48,13 @@ type internal TypeProvidersCache() =
     member x.Get(id) =
         proxyTypeProvidersPerId.[id]
 
+    member x.GetProvidersLocations() =
+        typeProvidersPerAssembly.Keys
+        |> Seq.map snd
+        |> Seq.distinct
+        |> Seq.map FileSystemPath.Parse
+        |> HashSet
+
     member x.Dump() =
         let typeProviders =
             proxyTypeProvidersPerId
@@ -68,8 +75,10 @@ type IProxyTypeProvidersManager =
         isInteractive: bool *
         systemRuntimeContainsType: (string -> bool) *
         systemRuntimeAssemblyVersion: Version *
-        compilerToolsPath: string list -> ITypeProvider list
+        compilerToolsPath: string list *
+        shadowCopyDesignTimeAssembly: bool -> ITypeProvider list
 
+    abstract member GetAssemblies: unit -> HashSet<FileSystemPath>
     abstract member Dump: unit -> string
 
 type TypeProvidersManager(connection: TypeProvidersConnection) =
@@ -85,8 +94,8 @@ type TypeProvidersManager(connection: TypeProvidersConnection) =
         member x.GetOrCreate(runTimeAssemblyFileName: string, designTimeAssemblyNameString: string,
                 resolutionEnvironment: ResolutionEnvironment, isInvalidationSupported: bool, isInteractive: bool,
                 systemRuntimeContainsType: string -> bool, systemRuntimeAssemblyVersion: Version,
-                compilerToolsPath: string list) =
-            let envKey = $"{designTimeAssemblyNameString}+{resolutionEnvironment.resolutionFolder}"
+                compilerToolsPath: string list, shadowCopyDesignTimeAssembly) =
+            let envKey = (designTimeAssemblyNameString, resolutionEnvironment.resolutionFolder)
 
             let result =
                 let fakeTcImports = getFakeTcImports systemRuntimeContainsType
@@ -96,7 +105,8 @@ type TypeProvidersManager(connection: TypeProvidersConnection) =
                         InstantiateTypeProvidersOfAssemblyParameters(runTimeAssemblyFileName,
                             designTimeAssemblyNameString, resolutionEnvironment.toRdResolutionEnvironment(),
                             isInvalidationSupported, isInteractive, systemRuntimeAssemblyVersion.ToString(),
-                            compilerToolsPath |> Array.ofList, fakeTcImports), RpcTimeouts.Maximal))
+                            compilerToolsPath |> Array.ofList, fakeTcImports, shadowCopyDesignTimeAssembly),
+                        RpcTimeouts.Maximal))
 
             let typeProviderProxies =
                 [ for tp in result.TypeProviders ->
@@ -113,3 +123,6 @@ type TypeProvidersManager(connection: TypeProvidersConnection) =
 
         member this.Dump() =
             $"{typeProviders.Dump()}\n\n{tpContext.Dump()}"
+
+        member this.GetAssemblies() =
+            typeProviders.GetProvidersLocations()

ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/Hosts/TypeProvidersHost.cs

@@ -111,8 +111,9 @@ private InstantiationResult InstantiateTypeProvidersOfAssembly(InstantiateTypePr
       return new InstantiationResult(rdTypeProviders.ToArray(), cachedIds.ToArray());
     }
 
-    private static Unit Die(Unit _)
+    private Unit Die(Unit _)
     {
+      myTypeProvidersContext.TypeProvidersLoader.Dispose();
       Environment.Exit(0);
       return Unit.Instance;
     }

ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/Program.cs

@@ -6,7 +6,7 @@ internal static class Program
   {
     public static void Main(string[] args)
     {
-      AppDomain.CurrentDomain.AssemblyResolve += RiderPluginAssemblyResolver.Resolve;
+      AppDomain.CurrentDomain.AssemblyResolve += TypeProvidersAssemblyResolver.Resolve;
       MainInternal(args);
     }
 

….Host/src/RiderPluginAssemblyResolver.cs …ost/src/TypeProvidersAssemblyResolver.csReSharper.FSharp/src/FSharp.TypeProviders.Host/src/RiderPluginAssemblyResolver.cs renamed to ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/TypeProvidersAssemblyResolver.cs ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/RiderPluginAssemblyResolver.cs renamed to ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/TypeProvidersAssemblyResolver.cs

@@ -5,12 +5,12 @@
 
 namespace JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Host
 {
-  public static class RiderPluginAssemblyResolver
+  public static class TypeProvidersAssemblyResolver
   {
     private const string AdditionalProbingPathsEnvVar = "RIDER_PLUGIN_ADDITIONAL_PROBING_PATHS";
     private static readonly List<string> OurAdditionalProbingPaths = new List<string>();
 
-    static RiderPluginAssemblyResolver()
+    static TypeProvidersAssemblyResolver()
     {
       var paths = Environment.GetEnvironmentVariable(AdditionalProbingPathsEnvVar);
       if (string.IsNullOrWhiteSpace(paths)) return;

ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/TypeProvidersContext.cs

@@ -55,7 +55,7 @@ public IProvidedRdModelsCreator<CustomAttributeData, RdCustomAttributeData>
     public TypeProvidersContext(ILogger logger)
     {
       Logger = logger;
-      TypeProvidersLoader = new TypeProvidersLoader();
+      TypeProvidersLoader = new TypeProvidersLoader(logger);
 
       TypeProvidersCache = new TypeProvidersCache();
       ProvidedTypesCache = new ProvidedTypesCache(ProvidedTypesComparer.Instance);

ReSharper.FSharp/src/FSharp.TypeProviders.Host/src/TypeProvidersLoader.cs

@@ -1,29 +1,53 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using FSharp.Compiler;
+using JetBrains.Diagnostics;
 using JetBrains.ReSharper.Plugins.FSharp.Shim.TypeProviders;
 using JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Protocol.Exceptions;
 using JetBrains.ReSharper.Plugins.FSharp.Util;
 using JetBrains.Rider.FSharp.TypeProviders.Protocol.Server;
+using JetBrains.Util;
 using Microsoft.FSharp.Collections;
 using Microsoft.FSharp.Core;
 using Microsoft.FSharp.Core.CompilerServices;
 using Range = FSharp.Compiler.Text.Range;
 
 namespace JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Host
 {
-  public interface ITypeProvidersLoader
+  public interface ITypeProvidersLoader : IDisposable
   {
     IEnumerable<ITypeProvider> InstantiateTypeProvidersOfAssembly(
       InstantiateTypeProvidersOfAssemblyParameters parameters);
   }
 
   public class TypeProvidersLoader : ITypeProvidersLoader
   {
+    private readonly ILogger myLogger;
+    private readonly Dictionary<string, string> myShadowCopyMapping = new Dictionary<string, string>();
+
+    public TypeProvidersLoader(ILogger logger)
+    {
+      myLogger = logger;
+    }
+
     private readonly FSharpFunc<TypeProviderError, Unit> myLogError =
       FSharpFunc<TypeProviderError, Unit>.FromConverter(e =>
         throw new TypeProvidersInstantiationException(e.ContextualErrorMessage, e.Number));
 
+    private string GetAssemblyShadowCopy(string designTimeAssembly)
+    {
+      if (!myShadowCopyMapping.TryGetValue(designTimeAssembly, out var shadowCopy))
+      {
+        shadowCopy = Path.ChangeExtension(Path.GetTempFileName(), "dll");
+        File.Copy(designTimeAssembly, shadowCopy);
+        myLogger.Log(LoggingLevel.INFO, $"Shadow copying assembly {designTimeAssembly} to {shadowCopy}");
+        myShadowCopyMapping.Add(designTimeAssembly, shadowCopy);
+      }
+
+      return shadowCopy;
+    }
+
     public IEnumerable<ITypeProvider> InstantiateTypeProvidersOfAssembly(
       InstantiateTypeProvidersOfAssemblyParameters parameters)
     {
@@ -32,11 +56,23 @@ public IEnumerable<ITypeProvider> InstantiateTypeProvidersOfAssembly(
       var systemRuntimeAssemblyVersion = Version.Parse(parameters.SystemRuntimeAssemblyVersion);
       var compilerToolsPath = ListModule.OfSeq(parameters.CompilerToolsPath);
 
+      // todo: comment
+      var designTimeAssembly = parameters.ShadowCopyDesignTimeAssembly
+        ? GetAssemblyShadowCopy(parameters.RunTimeAssemblyFileName)
+        : parameters.DesignTimeAssemblyNameString;
+
       var typeProviders = ExtensionTyping.Shim.ExtensionTypingProvider.InstantiateTypeProvidersOfAssembly(
-        parameters.RunTimeAssemblyFileName, parameters.DesignTimeAssemblyNameString,
+        parameters.RunTimeAssemblyFileName, designTimeAssembly,
         resolutionEnvironment, parameters.IsInvalidationSupported, parameters.IsInteractive, systemRuntimeContainsType,
         systemRuntimeAssemblyVersion, compilerToolsPath, myLogError, Range.Zero);
       return typeProviders;
     }
+
+    public void Dispose()
+    {
+      foreach (var shadowCopy in myShadowCopyMapping.Values)
+        if (File.Exists(shadowCopy))
+          File.Delete(shadowCopy);
+    }
   }
 }

ReSharper.FSharp/test/src/FSharp.Tests.Host/FSharpTestHost.fs

@@ -54,7 +54,7 @@ type FSharpTestHost(lifetime: Lifetime, solution: ISolution, checkerService: Fcs
         solution.GetComponent<IProxyExtensionTypingProvider>().DumpTypeProvidersProcess()
 
     do
-        let fsTestHost = solution.RdFSharpModel().FsharpTestHost
+        let fsTestHost = solution.RdFSharpModel().FSharpTestHost
 
         // We want to get events published by background checker.
         checkerService.Checker.ImplicitlyStartBackgroundWork <- true