add base test

Author: DedSec256

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

@@ -23,6 +23,7 @@ type IProxyExtensionTypingProvider =
 
     abstract RuntimeVersion: unit -> string
     abstract DumpTypeProvidersProcess: unit -> string
+    abstract TerminateConnection: unit -> unit
 
 [<SolutionComponent>]
 type ExtensionTypingProviderShim(solution: ISolution, toolset: ISolutionToolset,
@@ -131,5 +132,4 @@ type ExtensionTypingProviderShim(solution: ISolution, toolset: ISolutionToolset,
 
             $"{inProcessDump}\n\n{outOfProcessDump}"
 
-    interface IDisposable with
-        member this.Dispose() = terminateConnection ()
+        member this.TerminateConnection() = terminateConnection()

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

@@ -26,10 +26,7 @@ public class TypeProvidersLoader : ITypeProvidersLoader
     private readonly ILogger myLogger;
     private readonly Dictionary<string, string> myShadowCopyMapping = new Dictionary<string, string>();
 
-    public TypeProvidersLoader(ILogger logger)
-    {
-      myLogger = logger;
-    }
+    public TypeProvidersLoader(ILogger logger) => myLogger = logger;
 
     private readonly FSharpFunc<TypeProviderError, Unit> myLogError =
       FSharpFunc<TypeProviderError, Unit>.FromConverter(e =>
@@ -56,7 +53,8 @@ public IEnumerable<ITypeProvider> InstantiateTypeProvidersOfAssembly(
       var systemRuntimeAssemblyVersion = Version.Parse(parameters.SystemRuntimeAssemblyVersion);
       var compilerToolsPath = ListModule.OfSeq(parameters.CompilerToolsPath);
 
-      // todo: comment
+      // We assume that to check the type provider, its developer will reference the type provider design-time assembly in the project.
+      // In this case, RunTimeAssemblyFileName will be the same as DesignTimeAssemblyNameString.
       var designTimeAssembly = parameters.ShadowCopyDesignTimeAssembly
         ? GetAssemblyShadowCopy(parameters.RunTimeAssemblyFileName)
         : parameters.DesignTimeAssemblyNameString;

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

@@ -53,6 +53,10 @@ type FSharpTestHost(lifetime: Lifetime, solution: ISolution, checkerService: Fcs
     let dumpTypeProvidersProcess _ =
         solution.GetComponent<IProxyExtensionTypingProvider>().DumpTypeProvidersProcess()
 
+    let killTypeProvidersProcess _ =
+        solution.GetComponent<IProxyExtensionTypingProvider>().TerminateConnection()
+        JetBrains.Core.Unit.Instance
+
     do
         let fsTestHost = solution.RdFSharpModel().FsharpTestHost
 
@@ -69,3 +73,4 @@ type FSharpTestHost(lifetime: Lifetime, solution: ISolution, checkerService: Fcs
         fsTestHost.DumpSingleProjectLocalReferences.Set(dumpSingleProjectLocalReferences)
         fsTestHost.TypeProvidersRuntimeVersion.Set(typeProvidersRuntimeVersion)
         fsTestHost.DumpTypeProvidersProcess.Set(dumpTypeProvidersProcess)
+        fsTestHost.KillTypeProvidersProcess.Set(killTypeProvidersProcess)

rider-fsharp/protocol/src/kotlin/model/RdFSharpModel.kt

@@ -51,6 +51,7 @@ object RdFSharpModel : Ext(SolutionModel.Solution) {
         call("dumpSingleProjectLocalReferences", void, immutableList(string))
         call("typeProvidersRuntimeVersion", void, string.nullable)
         call("dumpTypeProvidersProcess", void, string)
+        call("killTypeProvidersProcess", void, void)
     }
 
     private val RdFSharpTypeProvidersHost = aggregatedef("RdFSharpTypeProvidersHost") {

rider-fsharp/src/test/kotlin/typeProviders/TypeProvidersActionsTest.kt

@@ -0,0 +1,53 @@
+package typeProviders
+
+import com.jetbrains.rd.util.lifetime.Lifetime
+import com.jetbrains.rdclient.testFramework.waitForDaemon
+import com.jetbrains.rdclient.util.idea.waitAndPump
+import com.jetbrains.rider.daemon.util.hasErrors
+import com.jetbrains.rider.plugins.fsharp.rdFSharpModel
+import com.jetbrains.rider.projectView.solution
+import com.jetbrains.rider.test.annotations.TestEnvironment
+import com.jetbrains.rider.test.asserts.shouldBeFalse
+import com.jetbrains.rider.test.asserts.shouldBeNull
+import com.jetbrains.rider.test.asserts.shouldNotBeNull
+import com.jetbrains.rider.test.base.BaseTestWithSolution
+import com.jetbrains.rider.test.enums.CoreVersion
+import com.jetbrains.rider.test.enums.ToolsetVersion
+import com.jetbrains.rider.test.scriptingApi.callAction
+import com.jetbrains.rider.test.scriptingApi.markupAdapter
+import com.jetbrains.rider.test.scriptingApi.withOpenedEditor
+import org.testng.annotations.Test
+import withTypeProviders
+import java.time.Duration
+
+@Test
+@TestEnvironment(toolset = ToolsetVersion.TOOLSET_16, coreVersion = CoreVersion.DOT_NET_CORE_3_1)
+class TypeProvidersActionsTest : BaseTestWithSolution() {
+    override fun getSolutionDirectoryName() = "TypeProviderLibrary"
+    override val restoreNuGetPackages = true
+    private val sourceFile = "TypeProviderLibrary/Caches.fs"
+    private val rdFcsHost get() = project.solution.rdFSharpModel.fsharpTestHost
+
+    private fun waitForTypeProviders() {
+        waitAndPump(Lifetime.Eternal, { rdFcsHost.typeProvidersRuntimeVersion.sync(Unit) != null }, Duration.ofSeconds(60000))
+    }
+
+    @Test
+    fun restartTypeProviders() {
+        withTypeProviders {
+            withOpenedEditor(project, sourceFile) {
+                waitForDaemon()
+                rdFcsHost.typeProvidersRuntimeVersion.sync(Unit).shouldNotBeNull()
+                markupAdapter.hasErrors.shouldBeFalse()
+
+                rdFcsHost.killTypeProvidersProcess.sync(Unit)
+                rdFcsHost.typeProvidersRuntimeVersion.sync(Unit).shouldBeNull()
+
+                callAction("Rider.Plugins.FSharp.RestartTypeProviders")
+                waitForTypeProviders()
+                waitForDaemon()
+                markupAdapter.hasErrors.shouldBeFalse()
+            }
+        }
+    }
+}