add tests

Author: DedSec256

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

@@ -30,7 +30,6 @@ type IProxyExtensionTypingProvider =
 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

rider-fsharp/src/test/kotlin/Extensions.kt

@@ -15,21 +15,23 @@ fun com.intellij.openapi.editor.Editor.dumpTypeProviders(stream: PrintStream) {
     }
 }
 
-fun withSetting(project: Project, setting: String, function: () -> Unit) {
-    TestHost.getInstance(project.protocolHost).setSetting(setting, "true")
+fun withSettings(project: Project, settings: List<String>, function: () -> Unit) {
+    settings.forEach { TestHost.getInstance(project.protocolHost).setSetting(it, "true") }
     try {
         function()
     } finally {
-        TestHost.getInstance(project.protocolHost).setSetting(setting, "false")
+        settings.forEach { TestHost.getInstance(project.protocolHost).setSetting(it, "false") }
     }
 }
 
-fun BaseTestWithSolution.withTypeProviders(function: () -> Unit) {
-    withSetting(project, "FSharp/FSharpOptions/FSharpExperimentalFeatures/OutOfProcessTypeProviders/@EntryValue", function)
+fun BaseTestWithSolution.withTypeProviders(shadowCopyMode: Boolean = false, function: () -> Unit) {
+    val settings = mutableListOf("FSharp/FSharpOptions/FSharpExperimentalFeatures/OutOfProcessTypeProviders/@EntryValue")
+    if (shadowCopyMode) settings.add("FSharp/FSharpOptions/FSharpExperimentalFeatures/HostTypeProvidersFromTempFolder/@EntryValue")
+    withSettings(project, settings, function)
 }
 
 fun withEditorConfig(project: Project, function: () -> Unit) {
-    withSetting(project, "CodeStyle/EditorConfig/EnableEditorConfigSupport", function)
+    withSettings(project, listOf("CodeStyle/EditorConfig/EnableEditorConfigSupport"), function)
 }
 
 fun withCultureInfo(project: Project, culture: String, function: () -> Unit) {

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

@@ -1,22 +1,20 @@
 package typeProviders
 
+import com.intellij.execution.configurations.GeneralCommandLine
 import com.jetbrains.rd.platform.util.lifetime
-import com.jetbrains.rd.util.lifetime.Lifetime
 import com.jetbrains.rdclient.testFramework.waitForDaemon
 import com.jetbrains.rdclient.util.idea.waitAndPump
+import com.jetbrains.rider.NetCoreRuntime
 import com.jetbrains.rider.daemon.util.hasErrors
 import com.jetbrains.rider.plugins.fsharp.rdFSharpModel
 import com.jetbrains.rider.projectView.solution
+import com.jetbrains.rider.projectView.solutionDirectoryPath
 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.asserts.*
 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 com.jetbrains.rider.test.scriptingApi.*
 import org.testng.annotations.Test
 import withTypeProviders
 import java.time.Duration
@@ -28,6 +26,7 @@ class TypeProvidersActionsTest : BaseTestWithSolution() {
     override val restoreNuGetPackages = true
     private val sourceFile = "TypeProviderLibrary/Caches.fs"
     private val rdFcsHost get() = project.solution.rdFSharpModel.fsharpTestHost
+    private val restartTypeProvidersAction = "Rider.Plugins.FSharp.RestartTypeProviders"
 
     private fun waitForTypeProviders() {
         waitAndPump(project.lifetime, { rdFcsHost.typeProvidersRuntimeVersion.sync(Unit) != null }, Duration.ofSeconds(60000))
@@ -44,11 +43,56 @@ class TypeProvidersActionsTest : BaseTestWithSolution() {
                 rdFcsHost.killTypeProvidersProcess.sync(Unit)
                 rdFcsHost.typeProvidersRuntimeVersion.sync(Unit).shouldBeNull()
 
-                callAction("Rider.Plugins.FSharp.RestartTypeProviders")
+                callAction(restartTypeProvidersAction)
                 waitForTypeProviders()
                 waitForDaemon()
                 markupAdapter.hasErrors.shouldBeFalse()
             }
         }
     }
+
+    @Test
+    @TestEnvironment(solution = "LemonadeProvider")
+    fun rebuildTypeProvider() {
+        val lemonadeProviderProject = "${project.solutionDirectoryPath}/LemonadeProvider.DesignTime/LemonadeProvider.DesignTime.fsproj"
+        val sourceFileToCheck = "LemonadeProviderConsumer/Library.fs"
+
+        withTypeProviders(true) {
+
+            GeneralCommandLine()
+                .withWorkDirectory(project.solutionDirectoryPath.toString())
+                .withExePath(NetCoreRuntime.cliPath.value)
+                .withParameters("tool", "restore")
+                .createProcess()
+                .waitFor()
+                .shouldBe(0)
+
+            buildSelectedProjectsWithReSharperBuild(listOf(lemonadeProviderProject), ignoreReferencesResolve = true)
+
+            withOpenedEditor(project, sourceFileToCheck) {
+                waitForDaemon()
+                rdFcsHost.typeProvidersRuntimeVersion.sync(Unit).shouldNotBeNull()
+                markupAdapter.hasErrors.shouldBeFalse()
+            }
+
+            withOpenedEditor(project, "LemonadeProvider.DesignTime/LemonadeProvider.DesignTime.fs") {
+                //change "Drink" -> "Drink1"
+                typeFromOffset("1", 496)
+            }
+
+            buildSelectedProjectsWithReSharperBuild(project, listOf(lemonadeProviderProject))
+
+            withOpenedEditor(project, sourceFileToCheck) {
+                callAction(restartTypeProvidersAction)
+                waitForTypeProviders()
+                waitForDaemon()
+                markupAdapter.hasErrors.shouldBeTrue()
+
+                //change "Drink" -> "Drink1"
+                typeFromOffset("1", 86)
+                waitForDaemon()
+                markupAdapter.hasErrors.shouldBeFalse()
+            }
+        }
+    }
 }

rider-fsharp/testData/solutions/LemonadeProvider/.config/dotnet-tools.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "paket": {
+      "version": "5.241.5",
+      "commands": [
+        "paket"
+      ]
+    }
+  }
+}