WIN-24578 :: Add Rider plugin support for .net projects

.github/workflows/release.yml

@@ -98,3 +98,38 @@ jobs:
             --body "Current pull request contains patched \`CHANGELOG.md\` file for the \`$VERSION\` version." \
             --label "$LABEL" \
             --head $BRANCH
+
+  # Build the Windows installers from the exact plugin zip the job above just published, and attach
+  # them to the same release - so they're reproducible from CI rather than built locally and
+  # committed. Windows-only: the .exe needs csc.exe and 7-Zip, and the standalone script is run
+  # with Windows PowerShell, which is also what assembles it here (see installer/README.md).
+  installers:
+    name: Build Installers
+    needs: [ release ]
+    runs-on: windows-latest
+    permissions:
+      contents: write
+    steps:
+
+      # Check out the current repository
+      - name: Fetch Sources
+        uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event.release.tag_name }}
+
+      # The zip "Upload Release Asset" attached, not a fresh build
+      - name: Download Published Plugin
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: powershell
+        run: gh release download "${{ github.event.release.tag_name }}" --repo "${{ github.repository }}" --pattern intellij-ib-plugin.zip --dir build/published
+
+      - name: Build Installers
+        shell: powershell
+        run: .\installer\build-installer.ps1 -PluginZip build\published\intellij-ib-plugin.zip
+
+      - name: Upload Installers
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: powershell
+        run: gh release upload "${{ github.event.release.tag_name }}" --repo "${{ github.repository }}" --clobber build/distributions/install-intellij-ib-plugin.ps1 build/distributions/intellij-ib-plugin.exe

CHANGELOG.md

@@ -4,6 +4,44 @@
 
 ## [Unreleased]
 
+## [1.1.0]
+
+### Added
+
+- CLion support for CMake projects: **Build**, **Rebuild** and **Build All** in the **Incredibuild** menu run
+  `cmake --build` through Incredibuild, against the build directory, toolchain and generator the active CMake profile
+  is already configured with.
+- Rider support for .NET solutions: **Build Solution with Incredibuild**, **Rebuild Solution with Incredibuild** and
+  **Build Selected Projects with Incredibuild** in the **Build** menu, the Solution Explorer context menu and the
+  **Incredibuild** menu, bindable to shortcuts in **Settings/Preferences > Keymap**. They build the solution as it is
+  configured, in its active configuration and platform, through MSBuild accelerated by Incredibuild. While one runs,
+  the status bar shows the accelerated build in progress, and a notification reports the result.
+- **Settings/Preferences > Tools > Incredibuild** can set the MSBuild that Rider builds use, when the automatically
+  detected one isn't the right one.
+- The installers now also install the plugin into CLion and Rider.
+- **Use Incredibuild for the IDE's own Build and Rebuild actions** now works in CLion and Rider too, not only in
+  RustRover. In CLion it covers **Build**, **Rebuild**, **Build Project** and the build that runs before a CMake run
+  configuration starts. In Rider it covers **Build Solution**, **Rebuild Solution**, **Build Selection** and the
+  **Build Project**/**Build Solution** before-run steps. In both IDEs that includes the toolbar build button and
+  keyboard shortcuts. Off by default, and the **Incredibuild** menu actions are available either way.
+- **Settings/Preferences > Tools > Incredibuild** shows the Incredibuild installation the plugin uses (folder, version
+  and, on Windows, whether this machine is licensed), with a **Re-check** button.
+
+### Changed
+
+- When IDE build acceleration is on but Incredibuild is not installed, not licensed or too old, the build now runs
+  with the IDE's own builder and a notification explains why, with links to the settings and the download page.
+  Previously RustRover fell back silently. The notification is shown once per project session for each problem.
+- Only one Incredibuild build runs at a time, in every IDE. Starting a build - from the **Incredibuild** menu or,
+  with IDE build acceleration on, from the IDE's own build actions - while another is still running offers to stop
+  the running one, then starts the new build as soon as it has stopped. Previously a second build started alongside
+  the first, replacing its output in the **Incredibuild** tool window.
+- Renamed the setting **Accelerate the IDE's own build actions** to **Use Incredibuild for the IDE's own Build and
+  Rebuild actions**. The saved value is kept.
+- The Windows installers (`install-intellij-ib-plugin.ps1` and `intellij-ib-plugin.exe`) are now attached to each
+  GitHub release, built by the release workflow from the published plugin, instead of the script being committed to
+  the repository.
+
 ## [1.0.3]
 
 ### Added

README.md

@@ -24,19 +24,54 @@ configuration, build profile and target selection are all respected.
 
 ### Accelerating the IDE's own build actions
 
-The IDE's build actions can be accelerated too. Turn on **Accelerate the IDE's own build actions**
-under **Settings/Preferences > Tools > Incredibuild**, and **Build Project** - along with the build
-that runs before **Run** and **Test** - goes through Incredibuild, reporting into the IDE's own
-**Build** tool window. The commands and keyboard shortcuts stay exactly where they are.
-
-The setting is off by default. While it is off - or if Incredibuild isn't installed on the machine -
-those actions behave exactly as they do without this plugin. The actions in the **Incredibuild** menu
-always use Incredibuild, whichever way the setting is set.
+The IDE's build actions can be accelerated too, in RustRover, CLion and Rider. Turn on **Use Incredibuild
+for the IDE's own Build and Rebuild actions** under **Settings/Preferences > Tools > Incredibuild**, and the
+standard Build and Rebuild go through Incredibuild - from the Build menu, the toolbar, keyboard shortcuts,
+and the build that runs before a run configuration starts:
+
+- **RustRover** - **Build Project**, **Rebuild Project**, and the build before **Run** and **Test**,
+  reporting into the IDE's own **Build** tool window
+- **CLion** - **Build**, **Rebuild**, **Build Project**, and the build before a CMake run configuration
+  starts, reporting into the **Incredibuild** tool window
+- **Rider** - **Build Solution**, **Rebuild Solution**, **Build Selection**, and the **Build Project** /
+  **Build Solution** before-run steps, reporting into the **Incredibuild** tool window
+
+The commands and keyboard shortcuts stay exactly where they are. The setting is off by default, and while
+it is off those actions behave exactly as they do without this plugin. If Incredibuild is not installed,
+not licensed or too old, the build runs with the IDE's own builder instead and a notification explains why
+(once per project session for each problem). The same settings page shows the Incredibuild installation the
+plugin uses - its folder, version and, on Windows, whether this machine is licensed. The actions in the
+**Incredibuild** menu always use Incredibuild, whichever way the setting is set.
+
+### Rider (.NET)
+
+In Rider, the **Build** menu gets dedicated Incredibuild actions right after the standard ones (they are
+also in the **Incredibuild** menu):
+
+- **Build Solution with Incredibuild** - builds the solution in its active configuration and platform
+- **Rebuild Solution with Incredibuild** - cleans and rebuilds it
+- **Build Selected Projects with Incredibuild** - builds the projects selected in the Solution Explorer,
+  along with the projects they reference
+
+The same actions are in the Solution Explorer's context menu on the solution, solution folders and
+projects, and each can be bound to a shortcut under **Settings/Preferences > Keymap** (search for
+"Incredibuild"). They have no default shortcuts, so none of Rider's own are taken over.
+
+They run MSBuild on the solution exactly as it is configured: the active configuration and platform
+are respected (for selected projects, through the solution's own project configuration mapping), and
+an open solution filter (`.slnf`) limits the build the same way it limits Rider's own. Nothing about the
+solution or its projects is changed. While an accelerated build runs, the status bar shows
+*Building <solution> with Incredibuild*, the **Incredibuild** tool window shows its output under a banner
+naming the configuration and MSBuild used, and a notification reports the result.
+
+MSBuild is detected automatically: the newest Visual Studio / Build Tools `MSBuild.exe` with the .NET SDK component on Windows,
+otherwise the .NET SDK's `dotnet msbuild`. Rider's own MSBuild selection lives in its backend settings,
+which plugins can't read, so a different one can be set under **Settings/Preferences > Tools > Incredibuild**.
 
 ### Settings
 
 **Settings/Preferences > Tools > Incredibuild** configures the number of parallel jobs (`-j`)
-accelerated builds request, and the opt-in above.
+accelerated Cargo/CMake builds request, the opt-in above, and (in Rider) the MSBuild to use.
 
 If Incredibuild isn't installed on the machine, the menu commands offer to open
 [incredibuild.com](https://www.incredibuild.com/) to download it.
@@ -46,6 +81,7 @@ If Incredibuild isn't installed on the machine, the menu commands offer to open
 - RustRover, or IntelliJ IDEA Ultimate with the Rust plugin - 2026.1 or 2026.2 (builds 261-262).
   The Rust plugin is released for one IDE line at a time, and this plugin depends on it, so support
   for a newer line follows a Rust plugin release for it.
+- Or Rider 2026.2, with MSBuild (Visual Studio / Build Tools) or the .NET SDK installed.
 - [Incredibuild](https://www.incredibuild.com/) installed, on Windows or Linux:
   - Windows: 10.37.1 or later
   - Linux: 4.29.3 or later, installed under `/opt/incredibuild`

build.gradle.kts

@@ -2,6 +2,7 @@ import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.gradle.api.tasks.bundling.Zip
 import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
 import org.jetbrains.intellij.platform.gradle.TestFrameworkType
+import org.jetbrains.intellij.platform.gradle.tasks.VerifyPluginTask
 
 plugins {
     id("org.jetbrains.kotlin.jvm")
@@ -52,6 +53,9 @@ dependencies {
         // Verifier against a plain 2026.2 target (only 262.8665+ builds have it).
         plugin("com.intellij.nativeDebug", "262.8665.176")
         bundledPlugin("intellij.testRunner.plugin")
+        // The Rider-only .NET adapter (see rider/build.gradle.kts), merged into this plugin's
+        // own jar rather than shipped as a separate one - still a single plugin to install.
+        pluginComposedModule(implementation(project(":rider")))
         testFramework(TestFrameworkType.Platform)
     }
 }
@@ -107,21 +111,86 @@ intellijPlatform {
         // resolve CMake-only classes - not a bug. Rather than dropping COMPATIBILITY_PROBLEMS
         // from failureLevel entirely (which would also hide a real, future compatibility
         // break, e.g. a 2026.x IDE removing an API this plugin uses), those 4 specific,
-        // already-reviewed problems are listed in ignoredProblemsFile instead - everything
+        // already-reviewed problems are listed in an ignored-problems file instead - everything
         // else in that category still fails the task. failureLevel is left at its default
         // (COMPATIBILITY_PROBLEMS + INTERNAL_API_USAGES; confirmed by observing which
         // categories actually failed the task even though deprecated/experimental/missing-
         // optional-dependency problems were also present and reported) - it already caught a
         // real, fixable internal-API usage (PluginManagerCore.getPlugin(), replaced with the
         // public isLoaded() instead) and should keep gating future ones the same way.
-        ignoredProblemsFile.set(rootProject.layout.projectDirectory.file("gradle/pluginVerifier-ignoredProblems.txt"))
+        //
+        // The ignored-problems file is set per IDE, not here - see the per-IDE verification
+        // tasks below.
         ides {
             create(IntelliJPlatformType.CLion, "2026.2")
             create(IntelliJPlatformType.RustRover, "2026.2")
+            // The only IDE that ever loads the .NET half (rider-support.xml).
+            // Rider is only published as a Maven artifact, not a regular installer - see
+            // https://github.com/JetBrains/intellij-platform-gradle-plugin/issues/1852.
+            create(IntelliJPlatformType.Rider, "2026.2") {
+                useInstaller = false
+            }
         }
     }
 }
 
+// One verification run per IDE, each with only the ignored problems that IDE is expected to
+// report. A Plugin Verifier ignored-problems file applies to every IDE in a run - its conditions
+// can name a plugin but not an IDE - so a single shared file would also hide those same messages
+// where they *would* be real problems: "Package 'org.rust' is not found" is expected against
+// Rider (no Rust plugin) but would mean a broken build against RustRover, and the CMake-only
+// symbols are expected against RustRover but never against CLion. Splitting the runs keeps that
+// coverage.
+//
+// All three take the IDEs pluginVerification.ides resolves above and keep only their own, by the
+// productCode in each IDE's product-info.json. `verifyPlugin` itself verifies CLion and runs the
+// other two, so CI's `./gradlew verifyPlugin` still covers all three. Reports go to one
+// subdirectory each of build/reports/pluginVerifier, which CI uploads as a whole.
+data class PerIdeVerification(val productCode: String, val reportsSubdirectory: String, val ignoredProblems: String?)
+
+val perIdeVerifications = mapOf(
+    "verifyPlugin" to PerIdeVerification("CL", "clion", null),
+    "verifyPluginRustRover" to PerIdeVerification("RR", "rustrover", "gradle/pluginVerifier-ignoredProblems-rustrover.txt"),
+    "verifyPluginRider" to PerIdeVerification("RD", "rider", "gradle/pluginVerifier-ignoredProblems-rider.txt"),
+)
+
+for ((taskName, verification) in perIdeVerifications) {
+    val configure: VerifyPluginTask.() -> Unit = {
+        // A snapshot of the sources the plugin wired in, not `ides` itself - filtering a
+        // collection into its own sources would make it depend on itself.
+        val allIdes = files(ides.from.toList())
+        val productCode = verification.productCode
+        ides.setFrom(allIdes.filter { ide ->
+            val productInfo = ide.resolve("product-info.json")
+            productInfo.isFile &&
+                Regex(""""productCode"\s*:\s*"([A-Z]+)"""").find(productInfo.readText())?.groupValues?.get(1) == productCode
+        })
+        verification.ignoredProblems?.let { ignoredProblemsFile.set(layout.projectDirectory.file(it)) }
+        verificationReportsDirectory.set(layout.buildDirectory.dir("reports/pluginVerifier/${verification.reportsSubdirectory}"))
+        // A home directory of its own for each run. These tasks can run in parallel (the
+        // configuration cache allows it), and every Plugin Verifier run starts by deleting and
+        // recreating <home>/extracted-plugins - with the shared default home (~/.pluginVerifier),
+        // one run deleting it while another walks it fails that run with NoSuchFileException.
+        systemProperty(
+            "plugin.verifier.home.dir",
+            layout.buildDirectory.dir("pluginVerifier/${verification.reportsSubdirectory}").get().asFile.absolutePath
+        )
+    }
+    if (taskName == "verifyPlugin") {
+        tasks.named<VerifyPluginTask>(taskName, configure)
+    } else {
+        tasks.register<VerifyPluginTask>(taskName) {
+            group = "intellij platform"
+            description = "Verifies the plugin against ${verification.reportsSubdirectory} only - see build.gradle.kts."
+            configure()
+        }
+    }
+}
+
+tasks.named("verifyPlugin") {
+    dependsOn("verifyPluginRustRover", "verifyPluginRider")
+}
+
 // Plain `runIde` launches intellijIdeaUltimate (the platform this plugin's dependencies block
 // above declares), which never loads the CMake half at all (see plugin.xml's optional
 // <depends config-file="cmake-support.xml">) - there's nothing to manually exercise there. Add a
@@ -132,12 +201,21 @@ intellijPlatformTesting {
             type = IntelliJPlatformType.CLion
             version = "2026.2"
         }
+        // Likewise for the .NET/Rider actions (rider-support.xml).
+        register("runIdeForRider") {
+            type = IntelliJPlatformType.Rider
+            version = "2026.2"
+            useInstaller = false
+        }
     }
 }
 
 // buildSearchableOptions launches a sandboxed IDE to index Settings UI labels for search.
 // That launcher doesn't support ARM64 hosts ("Unsupported JVM architecture: aarch64") - it's a
 // build-time search-indexing convenience only, not required for the plugin to function.
-tasks.named("buildSearchableOptions") {
-    enabled = false
+// Switched off through the plugin's own flag rather than by disabling just that one task: the
+// follow-up prepareJarSearchableOptions task still expects the output folder buildSearchableOptions
+// would have created, so after a `clean` the task-only approach fails the build.
+intellijPlatform {
+    buildSearchableOptions = false
 }

gradle.properties

@@ -1,5 +1,5 @@
 group = com.incredibuild.ibplugin
-version = 1.0.3
+version = 1.1.0
 
 pluginRepositoryUrl = https://github.com/Incredibuild-RND/intellij-ib-plugin
 

gradle/pluginVerifier-ignoredProblems-rider.txt

@@ -0,0 +1,12 @@
+// Plugin Verifier "ignored problems" file for the Rider run only (verifyPluginRider) - see the
+// per-IDE verification tasks in build.gradle.kts. Each IDE gets its own file because a file's
+// conditions apply to every IDE in a run: this line must not hide a real org.rust problem when
+// verifying against RustRover. Format: see pluginVerifier-ignoredProblems-rustrover.txt.
+//
+// The optional-dependency split seen from Rider, which has no Rust plugin:
+// RunWithIncredibuildAction is kept in the source tree but not registered anywhere (see the
+// commented-out registration in rust-support.xml), and everything that IS registered against
+// org.rust only loads through rust-support.xml. Confirmed by the Verifier's own "Missing
+// dependencies: com.jetbrains.rust (optional): Unavailable" against Rider. (The CMake problems
+// ignored for RustRover don't occur here: Rider bundles com.intellij.cmake itself.)
+com.incredibuild.ibplugin:Package 'org\.rust' is not found

gradle/pluginVerifier-ignoredProblems.txt → gradle/pluginVerifier-ignoredProblems-rustrover.txt

@@ -1,6 +1,7 @@
-// Plugin Verifier "ignored problems" file - see pluginVerification.ignoredProblemsFile in
-// build.gradle.kts for how this is wired in, and its comment for why these specific problems
-// are expected rather than bugs.
+// Plugin Verifier "ignored problems" file for the RustRover run only (verifyPluginRustRover) - see
+// the per-IDE verification tasks in build.gradle.kts for how it's wired in, and the
+// pluginVerification comment there for why these specific problems are expected rather than bugs.
+// Each IDE gets its own file because a file's conditions apply to every IDE in a run.
 //
 // Format (one condition per line, blank lines and "//" comments skipped): either
 // "<plugin id>:<pattern>" or just "<pattern>". No version field, so these keep applying across
@@ -11,8 +12,7 @@
 // (com.jetbrains.cidr.cpp.toolchains.*, com.jetbrains.cidr.cpp.cmake.*) showing up as
 // unresolved when verified against RustRover, which has no CMake plugin - the optional-
 // dependency split (plugin.xml's cmake-support.xml) working as intended, confirmed by the
-// Verifier's own "Missing dependencies: com.intellij.cmake (optional): Unavailable". They can
-// never match when verifying against CLion, which does have com.intellij.cmake.
+// Verifier's own "Missing dependencies: com.intellij.cmake (optional): Unavailable".
 com.incredibuild.ibplugin:Package 'com\.jetbrains\.cidr\.cpp\.toolchains' is not found
 com.incredibuild.ibplugin:Package 'com\.jetbrains\.cidr\.cpp\.cmake' is not found
 com.incredibuild.ibplugin:Access to unresolved class com\.jetbrains\.cidr\.cpp\.execution\.CMakeAppRunConfiguration\.BuildAndRunConfigurations