From bbabb8a96a194f402a3497a3b2bbb09a7ee83099 Mon Sep 17 00:00:00 2001 From: Anton Gorielikov Date: Fri, 9 Oct 2026 17:01:19 +0300 Subject: [PATCH 1/8] WIN-24578 :: Add Rider plugin support for .net projects --- CHANGELOG.md | 11 + README.md | 28 +- build.gradle.kts | 22 +- gradle/pluginVerifier-ignoredProblems.txt | 8 + installer/install-common.ps1 | 11 +- rider/build.gradle.kts | 47 +++ .../ibplugin/rider/RiderSolutionModel.kt | 122 ++++++++ settings.gradle.kts | 6 + .../ibplugin/actions/IncredibuildRunner.kt | 269 +++++++++++++----- .../actions/dotnet/DotNetBuildActions.kt | 118 ++++++++ .../actions/dotnet/DotNetBuildRunner.kt | 128 +++++++++ .../ibplugin/actions/dotnet/MsBuildCommand.kt | 209 ++++++++++++++ .../ibplugin/actions/dotnet/MsBuildLocator.kt | 136 +++++++++ .../settings/IncredibuildConfigurable.kt | 26 +- .../ibplugin/settings/IncredibuildSettings.kt | 12 + src/main/resources/META-INF/plugin.xml | 25 +- src/main/resources/META-INF/rider-support.xml | 50 ++++ .../actions/dotnet/MsBuildCommandTest.kt | 168 +++++++++++ 18 files changed, 1314 insertions(+), 82 deletions(-) create mode 100644 rider/build.gradle.kts create mode 100644 rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderSolutionModel.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt create mode 100644 src/main/resources/META-INF/rider-support.xml create mode 100644 src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index 13d3b50..176cda3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,17 @@ ## [Unreleased] +### Added + +- 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 Rider. + ## [1.0.3] ### Added diff --git a/README.md b/README.md index 4c339c5..89c56da 100644 --- a/README.md +++ b/README.md @@ -33,10 +33,35 @@ The setting is off by default. While it is off - or if Incredibuild isn't instal 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. +### 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 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 +71,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` diff --git a/build.gradle.kts b/build.gradle.kts index 334b430..f91bcf4 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -52,6 +52,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) } } @@ -118,6 +121,12 @@ intellijPlatform { 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 + } } } } @@ -132,12 +141,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 } diff --git a/gradle/pluginVerifier-ignoredProblems.txt b/gradle/pluginVerifier-ignoredProblems.txt index 3920afc..229d987 100644 --- a/gradle/pluginVerifier-ignoredProblems.txt +++ b/gradle/pluginVerifier-ignoredProblems.txt @@ -17,3 +17,11 @@ com.incredibuild.ibplugin:Package 'com\.jetbrains\.cidr\.cpp\.toolchains' is not 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 com.incredibuild.ibplugin:Access to unresolved class com\.jetbrains\.cidr\.cpp\.execution\.CMakeAppRunConfiguration +// +// The line below is the same 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 lines above +// don't apply to Rider: it bundles com.intellij.cmake itself.) +com.incredibuild.ibplugin:Package 'org\.rust' is not found diff --git a/installer/install-common.ps1 b/installer/install-common.ps1 index b923260..26a3f1a 100644 --- a/installer/install-common.ps1 +++ b/installer/install-common.ps1 @@ -4,9 +4,10 @@ # install.ps1) via installer/build-installer.ps1 - edit this ONE file rather # than both generated scripts. -# RR = RustRover, IU = IntelliJ IDEA Ultimate. Community editions (IC) don't -# carry com.intellij.modules.ultimate, which the Rust plugin requires there. -$targetProductCodes = @("RR", "IU") +# RR = RustRover, IU = IntelliJ IDEA Ultimate, RD = Rider (the .NET actions - +# see rider-support.xml). Community editions (IC) don't carry +# com.intellij.modules.ultimate, which the Rust plugin requires there. +$targetProductCodes = @("RR", "IU", "RD") # Installs can land in quite a few places, so several roots are searched # recursively rather than assuming one fixed layout: @@ -30,7 +31,7 @@ $registryInstallLocations = @( } | ForEach-Object { Get-ItemProperty -Path $_.PSPath -ErrorAction SilentlyContinue } | Where-Object { - $_.DisplayName -match "RustRover|IntelliJ IDEA" -and $_.InstallLocation + $_.DisplayName -match "RustRover|IntelliJ IDEA|Rider" -and $_.InstallLocation } | ForEach-Object { $_.InstallLocation } | Select-Object -Unique $searchRoots = @( @@ -80,7 +81,7 @@ function Stop-InstallerTranscriptIfRunning { if (-not $installs) { $searched = ($searchRoots | Select-Object -Unique) -join "; " - $message = "No supported JetBrains IDE (RustRover or IntelliJ IDEA Ultimate) found. Searched: $searched." + $message = "No supported JetBrains IDE (RustRover, IntelliJ IDEA Ultimate or Rider) found. Searched: $searched." if ($allProducts) { $found = ($allProducts | ForEach-Object { "$($_.ProductName) [$($_.ProductCode)] at $($_.InfoPath)" }) -join "; " $message += " Found (but not supported by this plugin): $found." diff --git a/rider/build.gradle.kts b/rider/build.gradle.kts new file mode 100644 index 0000000..ee2252d --- /dev/null +++ b/rider/build.gradle.kts @@ -0,0 +1,47 @@ +// The Rider-only adapter for this plugin's .NET support: a thin layer over Rider's frontend +// solution model (which solution is open, its active configuration|platform, what's selected in +// the Solution Explorer), compiled against Rider itself because those classes only exist in the +// Rider product, never as a Marketplace plugin the root module could compile against alongside +// the Rust/CMake ones. It is merged into the root plugin's jar (see pluginComposedModule in the +// root build.gradle.kts), so this is still one plugin and one install - and only ever called +// from code that rider-support.xml registers, i.e. only when running inside Rider. +// +// Deliberately depends on nothing in the root module (that would be a dependency cycle - the +// root module depends on this one), and exposes only platform types in its API so the root +// module never needs Rider classes on its own compile classpath. + +import org.gradle.api.tasks.bundling.AbstractArchiveTask + +plugins { + id("org.jetbrains.kotlin.jvm") + id("org.jetbrains.intellij.platform.module") +} + +kotlin { + jvmToolchain(25) + // Same reason as the root module's identical setting. + compilerOptions { + freeCompilerArgs.add("-Xjvm-default=all") + } +} + +dependencies { + intellijPlatform { + // Same 2026.2 (262) line as the root module's other compile targets. + rider("2026.2") { + useInstaller = false + } + // Rider's solution-host extensions (project.solutionFile, isExistingSolution, ...) and its + // Solution Explorer workspace model (ProjectModelEntity) live in this core content module, + // which isn't on the default compile classpath. It's a "required" module of Rider's core + // plugin, so it's always loaded at runtime in Rider. + bundledModule("intellij.rider.rdclient.dotnet") + bundledModule("intellij.rd.ide.model.generated") + } +} + +// Same as the root build.gradle.kts: keep real timestamps on this module's classes, which end up +// merged into the plugin's own jar, instead of Gradle's fixed 1980-02-01 placeholder. +tasks.withType().configureEach { + isPreserveFileTimestamps = true +} diff --git a/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderSolutionModel.kt b/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderSolutionModel.kt new file mode 100644 index 0000000..46c97e5 --- /dev/null +++ b/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderSolutionModel.kt @@ -0,0 +1,122 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.rider + +import com.intellij.openapi.actionSystem.DataContext +import com.intellij.openapi.project.Project +import com.jetbrains.rider.projectView.SolutionConfigurationManager +import com.jetbrains.rider.projectView.isExistingSolution +import com.jetbrains.rider.projectView.solutionFile +import com.jetbrains.rider.projectView.solutionFilterPath +import com.jetbrains.rider.projectView.workspace.ProjectModelEntity +import com.jetbrains.rider.projectView.workspace.getProjectModelEntities +import com.jetbrains.rider.projectView.workspace.isProject +import com.jetbrains.rider.projectView.workspace.isSolution +import com.jetbrains.rider.projectView.workspace.isSolutionFolder +import com.jetbrains.rider.projectView.workspace.isUnloadedProject + +/** The solution configuration Rider's own build would use, e.g. "Debug" / "Any CPU". */ +class SolutionConfiguration(val configuration: String, val platform: String) + +/** What the Solution Explorer selection asks to be built - see [RiderSolutionModel.selection]. */ +sealed interface SolutionSelection { + /** The solution node itself is selected: build everything. */ + data object WholeSolution : SolutionSelection + + /** [projectFiles] are absolute paths of project files (.csproj, .vbproj, .fsproj, ...). */ + class Projects(val projectFiles: List) : SolutionSelection + + /** Nothing buildable is selected (e.g. a plain file or folder, or no Solution Explorer focus). */ + data object Nothing : SolutionSelection +} + +/** + * Read-only access to the parts of Rider's frontend solution model the Incredibuild .NET actions + * need. Everything here mirrors what Rider's own build actions consult + * ([com.jetbrains.rider.build.actions.BuildSolutionActionBase], + * [com.jetbrains.rider.build.actions.BuildSelectionActionBase]), so the accelerated build targets + * exactly what Rider's own one would - but deliberately stops short of Rider's + * [com.jetbrains.rider.build.BuildHost]: that hands the build to the ReSharper backend, which runs + * MSBuild in its own process tree, where Incredibuild can't wrap it. + * + * Only platform types cross this API, so the root module (compiled against IntelliJ IDEA, not + * Rider) can call it without Rider classes on its own classpath. + */ +object RiderSolutionModel { + + /** + * Whether [project] is a real .sln/.slnx solution - not a folder opened as a "directory + * solution", a CMake project opened in Rider, or the temporary placeholder solution Rider + * opens with no solution at all, none of which have a solution file MSBuild could build. + */ + fun hasSolution(project: Project): Boolean = project.isExistingSolution + + /** + * The file to hand MSBuild for a whole-solution build. A solution filter (.slnf) wins when one + * is open, because that's what Rider's own build is scoped to then - and MSBuild accepts a + * .slnf directly, building only the projects it includes. + */ + fun buildEntryPoint(project: Project): String? { + if (!hasSolution(project)) return null + project.solutionFilterPath?.let { return it.toString() } + return project.solutionFile.absolutePath + } + + /** The actual .sln/.slnx file, even when a filter is open - see [buildEntryPoint]. */ + fun solutionFile(project: Project): String? = + if (hasSolution(project)) project.solutionFile.absolutePath else null + + /** The configuration|platform selected in Rider's toolbar, the one its own Build uses. */ + fun activeConfiguration(project: Project): SolutionConfiguration? { + val active = SolutionConfigurationManager.tryGetInstance(project)?.activeConfigurationAndPlatform ?: return null + return SolutionConfiguration(active.configuration, active.platform) + } + + /** + * What the selection in [dataContext] asks to build, the same way Rider's own "Build Selection" + * reads it: the solution node means the whole solution, project nodes mean those projects, + * and a solution folder means every project nested in it. Anything else (files, folders, + * references) isn't buildable by itself, matching Rider - which also only offers its own + * build-selection action on those three kinds of node. + */ + fun selection(dataContext: DataContext): SolutionSelection { + val entities = dataContext.getProjectModelEntities() + if (entities.isEmpty()) return SolutionSelection.Nothing + if (entities.any { it.isSolution() }) return SolutionSelection.WholeSolution + + val projectFiles = LinkedHashSet() + for (entity in entities) { + when { + entity.isProject() -> entity.projectFilePath()?.let(projectFiles::add) + entity.isSolutionFolder() -> collectProjects(entity, projectFiles) + } + } + return if (projectFiles.isEmpty()) SolutionSelection.Nothing else SolutionSelection.Projects(projectFiles.toList()) + } + + private fun collectProjects(folder: ProjectModelEntity, into: MutableSet) { + for (child in folder.childrenEntities) { + when { + child.isProject() -> child.projectFilePath()?.let(into::add) + child.isSolutionFolder() -> collectProjects(child, into) + } + } + } + + /** An unloaded project can't be built by Rider either - skipped rather than handed to MSBuild. */ + private fun ProjectModelEntity.projectFilePath(): String? = + if (isUnloadedProject()) null else url?.presentableUrl +} diff --git a/settings.gradle.kts b/settings.gradle.kts index 9841bdf..da28989 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -2,6 +2,12 @@ import org.jetbrains.intellij.platform.gradle.extensions.intellijPlatform rootProject.name = "intellij-ib-plugin" +// Rider's frontend API (solution model, active solution configuration) ships inside the Rider +// product itself rather than as a separately published plugin, so unlike the Rust/CMake halves +// it can't be added to the root module's IntelliJ IDEA Ultimate compile target - see +// rider/build.gradle.kts. +include(":rider") + pluginManagement { plugins { id("org.jetbrains.kotlin.jvm") version "2.4.10" diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt index f2f9285..bdc1938 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt @@ -17,10 +17,12 @@ package com.incredibuild.ibplugin.actions import com.incredibuild.ibplugin.actions.cmake.CMakeBuildKind import com.incredibuild.ibplugin.actions.cmake.CMakeBuildResolution -import com.incredibuild.ibplugin.actions.cmake.ResolvedCMakeBuild import com.incredibuild.ibplugin.actions.cmake.deriveCMakeBuild import com.intellij.execution.configurations.GeneralCommandLine import com.intellij.execution.impl.ConsoleViewImpl +import com.intellij.execution.ui.ConsoleViewContentType +import com.intellij.notification.NotificationGroupManager +import com.intellij.notification.NotificationType import com.intellij.execution.process.ColoredProcessHandler import com.intellij.execution.process.KillableProcessHandler import com.intellij.execution.process.OSProcessHandler @@ -60,6 +62,11 @@ private const val MINIMUM_RUST_BUILD_VERSION = "10.37.1" // "10.37.0.12597" vs "3.18.0"). private const val MINIMUM_RUST_BUILD_VERSION_LINUX = "4.29.3" +/** Declared in plugin.xml. */ +private const val NOTIFICATION_GROUP_ID = "Incredibuild" + +private const val STATUS_POLL_INTERVAL_MS = 250L + /** A POSIX shell variable name - see [IncredibuildRunner]'s CMake Linux environment export. */ internal val VALID_SHELL_IDENTIFIER = Regex("[A-Za-z_][A-Za-z0-9_]*") @@ -125,7 +132,7 @@ object IncredibuildRunner { } /** The "Incredibuild wasn't found" dialog, shared by [ensureIncredibuildReady] (Rust) and - * [ensureIncredibuildInstalledForCMake] - identical either way, since it's the same + * [ensureIncredibuildInstalled] (CMake, MSBuild) - identical either way, since it's the same * Incredibuild install being looked for regardless of which language triggered the build. */ private fun showNotFoundDialog(project: Project, actionType: String) { PostHogClient.capture("incredibuild_not_found", mapOf("action" to actionType)) @@ -372,6 +379,7 @@ object IncredibuildRunner { project: Project, commandLine: GeneralCommandLine, actionType: String, + presentation: AcceleratedBuildPresentation? = null, onFinished: (exitCode: Int) -> Unit ) { PostHogClient.capture("build_started", mapOf("action" to actionType)) @@ -382,10 +390,58 @@ object IncredibuildRunner { ) ApplicationManager.getApplication().invokeLater { - run(project, commandLine, "Build", onFinished) + val processHandler = run( + project, + commandLine, + presentation?.contentName ?: "Build", + presentation?.banner, + onFinished + ) + if (presentation != null) { + trackInStatusBar(project, processHandler, presentation) + } } } + /** + * Keeps a "[AcceleratedBuildPresentation.progressTitle]" progress in the status bar for as + * long as [processHandler] runs - the IDE's usual "something is building" signal, so an + * accelerated build is visible even with the Incredibuild tool window hidden - and reports + * the outcome as a notification once it ends. Cancelling the progress stops the build the + * same graceful way Stop Build does ([OSProcessHandler.destroyProcess] on our handler). + */ + private fun trackInStatusBar( + project: Project, + processHandler: OSProcessHandler, + presentation: AcceleratedBuildPresentation + ) { + ProgressManager.getInstance().run(object : Task.Backgroundable(project, presentation.progressTitle, true) { + override fun run(indicator: ProgressIndicator) { + indicator.isIndeterminate = true + indicator.text = presentation.progressTitle + var stopRequested = false + while (!processHandler.waitFor(STATUS_POLL_INTERVAL_MS)) { + if (indicator.isCanceled && !stopRequested) { + stopRequested = true + indicator.text = "Stopping Incredibuild build..." + processHandler.destroyProcess() + } + } + val exitCode = processHandler.exitCode + val (content, type) = when { + stopRequested -> "${presentation.contentName} was stopped." to NotificationType.INFORMATION + exitCode == 0 -> "${presentation.contentName} succeeded." to NotificationType.INFORMATION + else -> "${presentation.contentName} failed (exit code $exitCode). See the Incredibuild tool window for details." to + NotificationType.ERROR + } + NotificationGroupManager.getInstance() + .getNotificationGroup(NOTIFICATION_GROUP_ID) + .createNotification("Incredibuild", content, type) + .notify(project) + } + }) + } + private fun showErrorOnEdt(project: Project, message: String) { ApplicationManager.getApplication().invokeLater { Messages.showErrorDialog(project, message, "Incredibuild") @@ -407,17 +463,23 @@ object IncredibuildRunner { * exit code - used both to chain a plain "cargo clean" into an Incredibuild-accelerated * build for Rebuild, and to report build success back to the IDE's build pipeline when * the build was started from there (see [IncredibuildProjectTaskRunner]). + * + * [banner], if given, is printed at the top of the console before any build output. */ fun run( project: Project, commandLine: GeneralCommandLine, contentName: String, + banner: String? = null, onFinished: ((exitCode: Int) -> Unit)? = null - ) { + ): OSProcessHandler { val processHandler = createProcessHandler(commandLine) val console = ConsoleViewImpl(project, true) console.attachToProcess(processHandler) + if (banner != null) { + console.print(banner + "\n\n", ConsoleViewContentType.SYSTEM_OUTPUT) + } val toolWindow = requireNotNull(ToolWindowManager.getInstance(project).getToolWindow("Incredibuild")) { "The Incredibuild tool window is declared in plugin.xml and should always be registered." @@ -436,6 +498,7 @@ object IncredibuildRunner { }) } processHandler.startNotify() + return processHandler } /** @@ -599,28 +662,75 @@ object IncredibuildRunner { } // ----------------------------------------------------------------------------------- - // CMake (CLion) support - mirrors the Cargo/Rust flow above, but a cmake invocation is - // built from a resolved executable + argument list + environment (see - // com.incredibuild.ibplugin.actions.cmake.CMakeBuildCommand) rather than a single - // command string, and needs no custom Incredibuild profile: unlike Rust/cargo, - // Incredibuild's own default profile already covers C/C++ builds. + // Native builds - CMake (CLion) and MSBuild (Rider). Mirrors the Cargo/Rust flow above, + // but each invocation is built from resolved executables + argument lists + environment + // (see [NativeBuild]) rather than a single command string, and needs no custom + // Incredibuild profile: unlike Rust/cargo, Incredibuild's own default profile already + // covers the tools these builds launch. // ----------------------------------------------------------------------------------- /** * Checks that Incredibuild is installed, showing the "not found" dialog and returning * null if the caller should not proceed. Unlike [ensureIncredibuildReady], this has no * minimum-version gate: there is no known minimum Incredibuild version required for its - * native CMake/C++ build support, unlike the specific version bump Rust build support - * needed. + * native CMake/C++ or MSBuild build support, unlike the specific version bump Rust build + * support needed. */ - internal fun ensureIncredibuildInstalledForCMake(project: Project): File? { + internal fun ensureIncredibuildInstalled(project: Project, actionType: String): File? { val installFolder = IncredibuildLocator.findInstallFolder() if (installFolder == null) { - showNotFoundDialog(project, "cmake") + showNotFoundDialog(project, actionType) } return installFolder } + /** One process to run inside an accelerated [NativeBuild]. */ + internal class NativeCommand(val executable: String, val arguments: List) + + /** + * Everything an accelerated native build runs: [commands] in order (stopping at the first + * that fails), from [workingDirectory], with [environment] set on top of the inherited one. + * Kept as executable + argument lists rather than pre-joined strings so quoting is only ever + * done once, by whichever wrapper script actually launches them. + */ + internal class NativeBuild( + val commands: List, + val workingDirectory: String, + val environment: Map = emptyMap() + ) + + /** + * How an accelerated build announces itself in the IDE - so it's unmistakable that this + * build is going through Incredibuild rather than the IDE's own builder: [contentName] names + * the Incredibuild tool window tab, [banner] is printed at the top of its console, and + * [progressTitle] is shown in the status bar (with a cancel button that stops the build + * gracefully) for as long as the build runs, followed by a success/failure notification. + */ + internal class AcceleratedBuildPresentation( + val contentName: String, + val banner: String, + val progressTitle: String + ) + + /** + * Runs an already-resolved [build] through Incredibuild. Must be called from a background + * thread with an already-verified [installFolder] (see [ensureIncredibuildInstalled]). + */ + internal fun launchNativeBuild( + project: Project, + installFolder: File, + build: NativeBuild, + actionType: String, + presentation: AcceleratedBuildPresentation? = null + ) { + when (val prepared = prepareNativeBuild(project, installFolder, build)) { + is PreparedBuild.Failed -> showErrorOnEdt(project, prepared.message) + is PreparedBuild.Ready -> launchBuild(project, prepared.commandLine, actionType, presentation) { _ -> + prepared.cleanUp() + } + } + } + /** * Resolves [kind]'s cmake invocation and, if Incredibuild is installed, runs it through * Incredibuild. Everything here - locating Incredibuild, reading the CMake project model - @@ -630,7 +740,7 @@ object IncredibuildRunner { internal fun buildCMakeViaIncredibuild(project: Project, actionType: String, kind: CMakeBuildKind) { ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Locating Incredibuild") { override fun run(indicator: ProgressIndicator) { - val installFolder = ensureIncredibuildInstalledForCMake(project) ?: return + val installFolder = ensureIncredibuildInstalled(project, "cmake") ?: return val resolution = deriveCMakeBuild(project, kind) val resolved = when (resolution) { null -> { @@ -647,48 +757,49 @@ object IncredibuildRunner { } is CMakeBuildResolution.Ready -> resolution.build } - when (val prepared = prepareCMakeBuild(project, installFolder, resolved)) { - is PreparedBuild.Failed -> showErrorOnEdt(project, prepared.message) - is PreparedBuild.Ready -> launchBuild(project, prepared.commandLine, actionType) { _ -> - prepared.cleanUp() - } - } + val build = NativeBuild( + listOf(NativeCommand(resolved.executable, resolved.arguments)), + resolved.workingDirectory, + resolved.environment + ) + launchNativeBuild(project, installFolder, build, actionType) } }) } - private fun prepareCMakeBuild( + private fun prepareNativeBuild( project: Project, installFolder: File, - resolved: ResolvedCMakeBuild + build: NativeBuild ): PreparedBuild = if (SystemInfo.isLinux) { - prepareCMakeBuildLinux(project, installFolder, resolved) + prepareNativeBuildLinux(project, installFolder, build) } else { - prepareCMakeBuildWindows(project, installFolder, resolved) + prepareNativeBuildWindows(project, installFolder, build) } /** * BuildConsole needs "/command=" with a single quoted value. Rather than hand it the whole - * `cmake --build ... --target ...` invocation as one string - which would need its own - * space-containing arguments (the build directory, a target name) individually quoted - * *inside* that already-quoted value, an ambiguous nested-quoting shape BuildConsole's own - * parsing for /command= is not documented to support - this writes a tiny wrapper .cmd that - * runs the real invocation with ordinary single-level quoting, and points /command= at just - * that script's path (one simple quoted path, the same shape /profile= above already uses - * uncontroversially). The toolchain environment (PATH/INCLUDE/LIB for an MSVC profile, ...) - * is set inside the same script via `set`, so it doesn't depend on whether BuildConsole - * passes its own parent environment through to what it launches. + * `cmake --build ... --target ...` (or `MSBuild.exe ...`) invocation as one + * string - which would need its own space-containing arguments (the build directory, a + * target name, a solution path) individually quoted *inside* that already-quoted value, an + * ambiguous nested-quoting shape BuildConsole's own parsing for /command= is not documented + * to support - this writes a tiny wrapper .cmd that runs the real invocation with ordinary + * single-level quoting, and points /command= at just that script's path (one simple quoted + * path, the same shape /profile= above already uses uncontroversially). The toolchain + * environment (PATH/INCLUDE/LIB for an MSVC profile, ...) is set inside the same script via + * `set`, so it doesn't depend on whether BuildConsole passes its own parent environment + * through to what it launches. * * No `/profile=`/`/BuildCacheProfile=` here, unlike [prepareBuildWindows]: those point at a - * bespoke Incredibuild profile built specifically for Cargo/rustc, which C/C++ needs no - * equivalent of - Incredibuild's own default profile already covers cmake/ninja/make/nmake - * and the compilers they invoke. + * bespoke Incredibuild profile built specifically for Cargo/rustc, which C/C++ and MSBuild + * need no equivalent of - Incredibuild's own default profile already covers + * cmake/ninja/make/nmake/MSBuild and the compilers they invoke. */ - private fun prepareCMakeBuildWindows( + private fun prepareNativeBuildWindows( project: Project, installFolder: File, - resolved: ResolvedCMakeBuild + build: NativeBuild ): PreparedBuild { val buildConsolePath = File(installFolder, "BuildConsole.exe") if (!buildConsolePath.exists()) { @@ -697,18 +808,9 @@ object IncredibuildRunner { ) } - val wrapperCmd = File.createTempFile("incredibuild-cmake-", ".cmd") + val wrapperCmd = File.createTempFile("incredibuild-native-", ".cmd") wrapperCmd.deleteOnExit() - val cmdLines = StringBuilder("@echo off\r\n") - for ((key, value) in resolved.environment) { - cmdLines.append("set \"").append(batchEscaped(key)).append('=').append(batchEscaped(value)).append("\"\r\n") - } - cmdLines.append(cmdQuoted(resolved.executable)) - for (arg in resolved.arguments) { - cmdLines.append(' ').append(cmdQuoted(arg)) - } - cmdLines.append("\r\nexit /b %ERRORLEVEL%\r\n") - wrapperCmd.writeText(cmdLines.toString()) + wrapperCmd.writeText(windowsWrapperScript(build)) val scriptFile = File.createTempFile("incredibuild-build-", ".ps1") scriptFile.deleteOnExit() @@ -729,7 +831,7 @@ object IncredibuildRunner { val commandLine = GeneralCommandLine("powershell") .withParameters("-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptFile.absolutePath) - .withWorkDirectory(resolved.workingDirectory) + .withWorkDirectory(build.workingDirectory) return PreparedBuild.Ready(commandLine) { scriptFile.delete() @@ -737,17 +839,45 @@ object IncredibuildRunner { } } + /** + * The .cmd [prepareNativeBuildWindows] points BuildConsole's /command= at: [NativeBuild.environment] + * via `set`, then each command in turn, stopping at (and exiting with) the first non-zero + * exit code - so a multi-project build reports failure the same way a single command does. + */ + internal fun windowsWrapperScript(build: NativeBuild): String { + val cmdLines = StringBuilder("@echo off\r\n") + for ((key, value) in build.environment) { + cmdLines.append("set \"").append(batchEscaped(key)).append('=').append(batchEscaped(value)).append("\"\r\n") + } + for ((index, command) in build.commands.withIndex()) { + cmdLines.append(cmdQuoted(command.executable)) + for (arg in command.arguments) { + cmdLines.append(' ').append(cmdQuoted(arg)) + } + cmdLines.append("\r\n") + if (index < build.commands.lastIndex) { + cmdLines.append("if errorlevel 1 exit /b %ERRORLEVEL%\r\n") + } + } + cmdLines.append("exit /b %ERRORLEVEL%\r\n") + return cmdLines.toString() + } + /** * ib_console has no `/command=`-style text field - the build command is trailing argv * after its own recognized options - so, unlike Windows, there's no nested-quoting - * concern to work around here: the whole invocation (environment exports, then the cmake + * concern to work around here: the whole invocation (environment exports, then the build * command) is written into one script, each token quoted individually and safely via * [shellSingleQuoted]. * + * ib_console runs exactly one command, so a [NativeBuild] with more than one (a multi-project + * MSBuild selection) has them chained inside a `/bin/sh -c` that ib_console runs instead - + * every process they start is still a descendant of ib_console, so all of it is accelerated. + * * No custom `--profile` here, unlike [prepareBuildLinux]'s RustRover-specific one: C/C++ - * needs no equivalent, ib_console's own shipped default profile already covers it. + * and MSBuild need no equivalent, ib_console's own shipped default profile already covers them. */ - private fun prepareCMakeBuildLinux(project: Project, installFolder: File, resolved: ResolvedCMakeBuild): PreparedBuild { + private fun prepareNativeBuildLinux(project: Project, installFolder: File, build: NativeBuild): PreparedBuild { val consolePath = File(installFolder, "bin/ib_console") if (!consolePath.exists()) { return PreparedBuild.Failed( @@ -757,8 +887,18 @@ object IncredibuildRunner { val scriptFile = File.createTempFile("incredibuild-build-", ".sh") scriptFile.deleteOnExit() + scriptFile.writeText(linuxWrapperScript(project.name, consolePath.absolutePath, build)) + + val commandLine = GeneralCommandLine("/bin/sh", scriptFile.absolutePath) + .withWorkDirectory(build.workingDirectory) + + return PreparedBuild.Ready(commandLine) { scriptFile.delete() } + } + + /** The script [prepareNativeBuildLinux] runs - see there. */ + internal fun linuxWrapperScript(caption: String, consolePath: String, build: NativeBuild): String { val script = StringBuilder("#!/bin/sh\n") - for ((key, value) in resolved.environment) { + for ((key, value) in build.environment) { // Not every entry CPPBuildUtil.buildCommandLine hands back is necessarily a valid // shell identifier (e.g. an inherited "BASH_FUNC_foo%%" from an exported bash // function) - "export" on such a name fails and takes the whole script down with @@ -767,21 +907,20 @@ object IncredibuildRunner { if (!VALID_SHELL_IDENTIFIER.matches(key)) continue script.append("export ").append(key).append('=').append(shellSingleQuoted(value)).append('\n') } - script.append("exec ").append(shellSingleQuoted(consolePath.absolutePath)) - .append(" --caption ").append(shellSingleQuoted(project.name)) + script.append("exec ").append(shellSingleQuoted(consolePath)) + .append(" --caption ").append(shellSingleQuoted(caption)) .append(" --ib-quiet --build-cache-local-shared --build-cache-basedir=\"\$PWD\" -- ") - .append(shellSingleQuoted(resolved.executable)) - for (arg in resolved.arguments) { - script.append(' ').append(shellSingleQuoted(arg)) + val commandTexts = build.commands.map { command -> + (listOf(command.executable) + command.arguments).joinToString(" ") { shellSingleQuoted(it) } + } + if (commandTexts.size == 1) { + script.append(commandTexts.single()) + } else { + script.append("/bin/sh -c ").append(shellSingleQuoted(commandTexts.joinToString(" && "))) } // Merges stderr into stdout, for the same reason prepareBuildLinux's Cargo build does. script.append(" 2>&1\n") - scriptFile.writeText(script.toString()) - - val commandLine = GeneralCommandLine("/bin/sh", scriptFile.absolutePath) - .withWorkDirectory(resolved.workingDirectory) - - return PreparedBuild.Ready(commandLine) { scriptFile.delete() } + return script.toString() } /** Wraps [value] as a cmd.exe double-quoted token (after [batchEscaped]), needed only when diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt new file mode 100644 index 0000000..b4ad8e3 --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt @@ -0,0 +1,118 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.dotnet + +import com.incredibuild.ibplugin.rider.RiderSolutionModel +import com.incredibuild.ibplugin.rider.SolutionSelection +import com.intellij.openapi.actionSystem.ActionUpdateThread +import com.intellij.openapi.actionSystem.AnAction +import com.intellij.openapi.actionSystem.AnActionEvent +import com.intellij.openapi.project.DumbAware +import com.intellij.openapi.ui.Messages + +/** + * The shared shape of the three Rider .NET "... with Incredibuild" actions: each captures what + * Rider's own equivalent would build (solution, active configuration|platform, selection) and + * hands it to [DotNetBuildRunner], which runs it through Incredibuild instead of Rider's builder. + * + * Registered only in Rider (rider-support.xml), so [RiderSolutionModel] - which needs Rider's + * own classes - is only ever reached there. + */ +abstract class DotNetBuildWithIncredibuildActionBase internal constructor( + private val kind: DotNetBuildKind, + private val actionType: String +) : AnAction(), DumbAware { + + override fun getActionUpdateThread() = ActionUpdateThread.BGT + + override fun update(e: AnActionEvent) { + val project = e.project + if (project == null || !RiderSolutionModel.hasSolution(project)) { + e.presentation.isEnabledAndVisible = false + return + } + + val selection = RiderSolutionModel.selection(e.dataContext) + if (e.isFromContextMenu) { + // Same rule as Rider's own Build Selection: offered on the solution, solution + // folders and projects in the Solution Explorer, not on files/references inside them. + e.presentation.isEnabledAndVisible = selection != SolutionSelection.Nothing + return + } + + e.presentation.isVisible = true + e.presentation.isEnabled = kind != DotNetBuildKind.BUILD_PROJECTS || selection != SolutionSelection.Nothing + } + + override fun actionPerformed(e: AnActionEvent) { + val project = e.project ?: return + val entryPoint = RiderSolutionModel.buildEntryPoint(project) + val solutionFile = RiderSolutionModel.solutionFile(project) + val configuration = RiderSolutionModel.activeConfiguration(project) + if (entryPoint == null || solutionFile == null || configuration == null) { + Messages.showErrorDialog( + project, + "Could not determine what to build. Is a solution loaded, with an active configuration selected?", + "Incredibuild" + ) + return + } + + var effectiveKind = kind + var projectFiles = emptyList() + if (kind == DotNetBuildKind.BUILD_PROJECTS) { + when (val selection = RiderSolutionModel.selection(e.dataContext)) { + // The solution node itself selected: like Rider's own Build Selection, that's + // just a solution build. + SolutionSelection.WholeSolution -> effectiveKind = DotNetBuildKind.BUILD_SOLUTION + is SolutionSelection.Projects -> projectFiles = selection.projectFiles + SolutionSelection.Nothing -> { + Messages.showInfoMessage( + project, + "Select one or more projects in the Solution Explorer to build them with Incredibuild.", + "Incredibuild" + ) + return + } + } + } + + DotNetBuildRunner.build( + project, + DotNetBuildRequest( + effectiveKind, + entryPoint, + solutionFile, + configuration.configuration, + configuration.platform, + projectFiles + ), + actionType + ) + } +} + +/** The accelerated equivalent of Rider's own Build Solution. */ +class BuildSolutionWithIncredibuildAction : + DotNetBuildWithIncredibuildActionBase(DotNetBuildKind.BUILD_SOLUTION, "dotnet_build_solution") + +/** The accelerated equivalent of Rider's own Rebuild Solution. */ +class RebuildSolutionWithIncredibuildAction : + DotNetBuildWithIncredibuildActionBase(DotNetBuildKind.REBUILD_SOLUTION, "dotnet_rebuild_solution") + +/** The accelerated equivalent of Rider's own Build Selection. */ +class BuildSelectedProjectsWithIncredibuildAction : + DotNetBuildWithIncredibuildActionBase(DotNetBuildKind.BUILD_PROJECTS, "dotnet_build_projects") diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt new file mode 100644 index 0000000..80ef5de --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt @@ -0,0 +1,128 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.dotnet + +import com.incredibuild.ibplugin.actions.IncredibuildRunner +import com.incredibuild.ibplugin.actions.IncredibuildRunner.AcceleratedBuildPresentation +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.diagnostic.Logger +import com.intellij.openapi.fileEditor.FileDocumentManager +import com.intellij.openapi.progress.ProgressIndicator +import com.intellij.openapi.progress.ProgressManager +import com.intellij.openapi.progress.Task +import com.intellij.openapi.project.Project +import com.intellij.openapi.ui.Messages +import java.io.File + +private val LOG = Logger.getInstance("com.incredibuild.ibplugin.actions.dotnet.DotNetBuildRunner") + +/** + * Everything about Rider's own state an accelerated .NET build needs, captured up front by the + * action (on the thread it runs on) so the background part never touches Rider's models. + */ +internal class DotNetBuildRequest( + val kind: DotNetBuildKind, + /** The .sln/.slnx, or open .slnf - see [solutionBuild]. */ + val entryPoint: String, + /** The actual .sln/.slnx even when a filter is open - see [projectsBuild]. */ + val solutionFile: String, + val configuration: String, + val platform: String, + /** Only for [DotNetBuildKind.BUILD_PROJECTS]. */ + val projectFiles: List = emptyList(), +) + +internal object DotNetBuildRunner { + + fun build(project: Project, request: DotNetBuildRequest, actionType: String) { + // Rider's own build saves unsaved editors first, so the build sees what's on screen; + // MSBuild reads from disk, so this has to as well. + FileDocumentManager.getInstance().saveAllDocuments() + + ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Locating Incredibuild") { + override fun run(indicator: ProgressIndicator) { + val installFolder = IncredibuildRunner.ensureIncredibuildInstalled(project, actionType) ?: return + + val tool = when (val location = MsBuildLocator.locate()) { + is MsBuildLocation.NotFound -> return showError(project, location.reason) + is MsBuildLocation.Found -> location.tool + } + + val build = when (request.kind) { + DotNetBuildKind.BUILD_SOLUTION, DotNetBuildKind.REBUILD_SOLUTION -> + solutionBuild(tool, request.entryPoint, request.kind, request.configuration, request.platform) + + DotNetBuildKind.BUILD_PROJECTS -> projectsBuild( + tool, + request.solutionFile, + request.projectFiles, + request.configuration, + request.platform, + readProjectConfigurations(request.solutionFile) + ) + } + + IncredibuildRunner.launchNativeBuild( + project, + installFolder, + build, + actionType, + presentation(request, tool) + ) + } + }) + } + + private fun readProjectConfigurations(solutionFile: String): Map> { + val file = File(solutionFile) + if (!file.extension.equals("sln", ignoreCase = true)) return emptyMap() + return try { + parseSolutionProjectConfigurations(file.readText(), file.absoluteFile.parentFile) + } catch (e: Exception) { + LOG.warn("Could not read project configuration mappings from $solutionFile", e) + emptyMap() + } + } + + private fun presentation(request: DotNetBuildRequest, tool: MsBuildTool): AcceleratedBuildPresentation { + val solutionName = File(request.solutionFile).nameWithoutExtension + val actionName = when (request.kind) { + DotNetBuildKind.BUILD_SOLUTION -> "Build Solution" + DotNetBuildKind.REBUILD_SOLUTION -> "Rebuild Solution" + DotNetBuildKind.BUILD_PROJECTS -> "Build Selected Projects" + } + val target = when (request.kind) { + DotNetBuildKind.BUILD_PROJECTS -> + request.projectFiles.joinToString(", ") { File(it).nameWithoutExtension } + else -> File(request.entryPoint).name + } + val progressVerb = if (request.kind == DotNetBuildKind.REBUILD_SOLUTION) "Rebuilding" else "Building" + return AcceleratedBuildPresentation( + contentName = actionName, + banner = "Incredibuild: $actionName (accelerated)\n" + + " Building: $target\n" + + " Configuration: ${request.configuration} | ${request.platform}\n" + + " MSBuild: ${tool.description}", + progressTitle = "$progressVerb $solutionName with Incredibuild (${request.configuration} | ${request.platform})" + ) + } + + private fun showError(project: Project, message: String) { + ApplicationManager.getApplication().invokeLater { + Messages.showErrorDialog(project, message, "Incredibuild") + } + } +} diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt new file mode 100644 index 0000000..5d89381 --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt @@ -0,0 +1,209 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.dotnet + +import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeBuild +import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeCommand +import java.io.File + +/** Which of the three .NET "... with Incredibuild" actions is asking for a command. */ +internal enum class DotNetBuildKind(val msBuildTarget: String) { + /** "Build Solution with Incredibuild". */ + BUILD_SOLUTION("Build"), + + /** "Rebuild Solution with Incredibuild". */ + REBUILD_SOLUTION("Rebuild"), + + /** "Build Selected Projects with Incredibuild". */ + BUILD_PROJECTS("Build"), +} + +/** + * The MSBuild to run: [executable] plus any [leadingArguments] that must come before the + * project/solution (`msbuild` for `dotnet msbuild`), and a [description] for the console banner. + */ +internal class MsBuildTool(val executable: String, val leadingArguments: List, val description: String) { + companion object { + /** MSBuild.exe itself, or the dotnet host - which needs its `msbuild` verb first. */ + fun fromPath(path: String): MsBuildTool { + val name = File(path).nameWithoutExtension + return if (name.equals("dotnet", ignoreCase = true)) { + MsBuildTool(path, listOf("msbuild"), "dotnet msbuild ($path)") + } else { + MsBuildTool(path, emptyList(), path) + } + } + } +} + +/** + * Arguments shared by every accelerated MSBuild invocation, on top of the target and the active + * configuration: + * - `-restore`: Rider's own build restores NuGet packages first too. + * - `-graph`: MSBuild's static graph mode - evaluate the whole project graph up front, then + * build it bottom-up, every project only once its references are done. Without it, a project + * that references many others (an app referencing all of a solution's libraries) builds those + * references itself, from whichever MSBuild node it happens to run on - and MSBuild pins each + * project to the first node that touches it, so every library that project reached first then + * builds on that one node, one after another. Observed on a 100-library solution: 16 libraries + * in parallel, then the remaining 84 strictly one at a time (4 min vs 1:48 with `-graph`) - + * leaving Incredibuild one compiler process at a time to distribute. + * - `-m`: lets MSBuild build independent projects concurrently, which is what gives Incredibuild + * more than one compiler process at a time to distribute. Deliberately unbounded (one node per + * local core) rather than the "Parallel jobs" setting: every MSBuild node is a full, + * long-lived process, and the hundreds of jobs that setting defaults to for Cargo/CMake would + * mean hundreds of them. + * - `-nodeReuse:false`: otherwise MSBuild leaves its worker nodes running after the build for the + * next one to reuse - processes that outlive the build they were started from, which + * Incredibuild would then keep waiting on before it considers the build finished. + * - `-p:UseSharedCompilation=false`: otherwise the C#/VB compilers don't run as their own + * processes at all, but as requests to one shared, long-lived VBCSCompiler server - which + * Incredibuild can't see, let alone distribute. Only changes how the compiler is launched, not + * what it compiles. + * - `-nologo`/`-v:minimal`: the same console verbosity Rider's own build output defaults to. + * + * None of these change anything about how the solution or its projects are configured - they + * only affect this one command-line invocation. + */ +internal val COMMON_MSBUILD_ARGUMENTS = listOf( + "-restore", + "-graph", + "-m", + "-nodeReuse:false", + "-p:UseSharedCompilation=false", + "-nologo", + "-v:minimal", +) + +/** + * The accelerated build for a whole solution - the equivalent of Rider's own Build/Rebuild + * Solution. [entryPoint] is the .sln/.slnx, or the .slnf when a solution filter is open (MSBuild + * builds a filter directly, honoring which projects it includes). + */ +internal fun solutionBuild( + tool: MsBuildTool, + entryPoint: String, + kind: DotNetBuildKind, + configuration: String, + platform: String +): NativeBuild { + val arguments = tool.leadingArguments + listOf( + entryPoint, + "-t:${kind.msBuildTarget}", + "-p:Configuration=$configuration", + "-p:Platform=$platform", + ) + COMMON_MSBUILD_ARGUMENTS + return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(entryPoint).absoluteFile.parent) +} + +/** + * The accelerated build for individually selected projects - the equivalent of Rider's own + * Build Selection, which also builds each selected project together with the projects it + * references (MSBuild follows ProjectReferences by itself). + * + * Each project is built directly rather than through the solution, since a solution can only be + * asked to build a specific project by a target name derived from its solution-folder path - so + * the context the solution would otherwise have provided is passed explicitly instead: + * - the project's own configuration|platform that the solution's active configuration maps it + * to ([mappings], from [parseSolutionProjectConfigurations]) - falling back to the solution + * configuration's own names, as Visual Studio does for a project with no mapping of its own; + * - the `SolutionDir`/`SolutionPath`/... properties MSBuild would have set had it come in + * through the solution, which build logic commonly relies on (e.g. a shared output folder). + * + * One MSBuild invocation per project, run one after the other: MSBuild only accepts a single + * project per invocation. Each one is still parallel within itself (see [COMMON_MSBUILD_ARGUMENTS]). + */ +internal fun projectsBuild( + tool: MsBuildTool, + solutionFile: String, + projectFiles: List, + configuration: String, + platform: String, + mappings: Map> +): NativeBuild { + val solution = File(solutionFile).absoluteFile + val solutionDir = solution.parent.trimEnd(File.separatorChar) + File.separator + val solutionProperties = listOf( + "-p:SolutionDir=$solutionDir", + "-p:SolutionPath=${solution.path}", + "-p:SolutionName=${solution.nameWithoutExtension}", + "-p:SolutionFileName=${solution.name}", + "-p:SolutionExt=.${solution.extension}", + ) + + val commands = projectFiles.map { projectFile -> + val mapped = mappings[normalizedPath(projectFile)]?.get("$configuration|$platform") + val (projectConfiguration, projectPlatform) = mapped?.split('|', limit = 2)?.takeIf { it.size == 2 } + ?: listOf(configuration, platform) + val arguments = tool.leadingArguments + listOf( + projectFile, + "-t:${DotNetBuildKind.BUILD_PROJECTS.msBuildTarget}", + "-p:Configuration=$projectConfiguration", + "-p:Platform=${projectPlatformName(projectPlatform)}", + ) + solutionProperties + COMMON_MSBUILD_ARGUMENTS + NativeCommand(tool.executable, arguments) + } + return NativeBuild(commands, solution.parent) +} + +/** + * Solutions spell the .NET "any CPU" platform with a space ("Any CPU"), project files without + * one ("AnyCPU") - MSBuild's own solution-to-project translation does the same rewrite when it + * builds a project through a solution, so it has to be done here when building one directly. + */ +internal fun projectPlatformName(platform: String): String = + if (platform.equals("Any CPU", ignoreCase = true)) "AnyCPU" else platform + +private val SLN_PROJECT_LINE = Regex( + """^Project\("\{[^}]*}"\)\s*=\s*"[^"]*"\s*,\s*"([^"]*)"\s*,\s*"\{([^}]*)}"""", + RegexOption.MULTILINE +) + +/** e.g. `{GUID}.Debug|Any CPU.ActiveCfg = Debug|x64` */ +private val SLN_ACTIVE_CFG_LINE = Regex( + """^\s*\{([^}]*)}\.([^.=]+\|[^=]+?)\.ActiveCfg\s*=\s*(.+?)\s*$""", + RegexOption.MULTILINE +) + +/** + * Reads a classic (.sln) solution's own record of which project configuration|platform each + * solution configuration|platform builds (its `ProjectConfigurationPlatforms` section), keyed by + * [normalizedPath] of each project file and then by solution "Configuration|Platform". + * + * Returns an empty map for anything else (e.g. an XML .slnx, which only lists the exceptions to + * the same-names default, or a .sln this can't parse) - [projectsBuild] then falls back to the + * solution configuration's own names, which is what such solutions mean by default anyway. + */ +internal fun parseSolutionProjectConfigurations(solutionText: String, solutionDir: File): Map> { + val projectPathByGuid = HashMap() + for (match in SLN_PROJECT_LINE.findAll(solutionText)) { + val relativePath = match.groupValues[1].replace('\\', File.separatorChar).replace('/', File.separatorChar) + val guid = match.groupValues[2].uppercase() + projectPathByGuid[guid] = normalizedPath(File(solutionDir, relativePath).path) + } + + val result = HashMap>() + for (match in SLN_ACTIVE_CFG_LINE.findAll(solutionText)) { + val projectPath = projectPathByGuid[match.groupValues[1].uppercase()] ?: continue + result.getOrPut(projectPath) { HashMap() }[match.groupValues[2].trim()] = match.groupValues[3] + } + return result +} + +/** Canonical, case-insensitive form of a path, so a project path from Rider's model matches the + * one resolved from the .sln regardless of `..`/separator/casing differences. */ +internal fun normalizedPath(path: String): String = + File(path).absoluteFile.normalize().path.replace('\\', '/').lowercase() diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt new file mode 100644 index 0000000..f06954a --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt @@ -0,0 +1,136 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.dotnet + +import com.incredibuild.ibplugin.settings.IncredibuildSettings +import com.intellij.execution.configurations.GeneralCommandLine +import com.intellij.execution.configurations.PathEnvironmentVariableUtil +import com.intellij.execution.util.ExecUtil +import com.intellij.openapi.diagnostic.Logger +import com.intellij.openapi.util.SystemInfo +import java.io.File + +private val LOG = Logger.getInstance("com.incredibuild.ibplugin.actions.dotnet.MsBuildLocator") + +private const val VSWHERE_TIMEOUT_MS = 15_000 + +private const val MSBUILD_COMPONENT = "Microsoft.Component.MSBuild" + +/** + * The ".NET SDK" Visual Studio component. Without it, a Visual Studio install's MSBuild has no + * .NET SDK resolver (Microsoft.DotNet.MSBuildSdkResolver), so it can't build any SDK-style + * project: every `` fails with MSB4236 "The SDK + * 'Microsoft.NET.Sdk' specified could not be found". A C++-only Visual Studio install still has + * Microsoft.Component.MSBuild, though, so requiring MSBuild alone isn't enough to tell them apart. + */ +private const val DOTNET_SDK_COMPONENT = "Microsoft.NetCore.Component.SDK" + +/** What [MsBuildLocator.locate] came back with. */ +internal sealed interface MsBuildLocation { + class Found(val tool: MsBuildTool) : MsBuildLocation + + /** [reason] is shown to the user as-is. */ + class NotFound(val reason: String) : MsBuildLocation +} + +/** + * Finds the MSBuild to run accelerated .NET builds with. + * + * Rider picks its own MSBuild in its backend settings (Build, Execution, Deployment | Toolset and + * Build), which the frontend this plugin runs in has no API to read - so this follows the same + * preference Rider's own automatic choice does instead, and lets the user override it in + * Settings | Tools | Incredibuild when that isn't the one they use: + * 1. The MSBuild configured in Settings | Tools | Incredibuild, if any. + * 2. Windows: the newest Visual Studio / Build Tools MSBuild.exe that has the .NET SDK component, + * found the way Microsoft documents for it (vswhere). It builds both SDK-style and classic + * .NET Framework projects - and mixed solutions containing C++ ones - which `dotnet msbuild` + * can't. Just "the newest Visual Studio" isn't enough: a C++-only install can be newer than + * the one with .NET in it - see [DOTNET_SDK_COMPONENT]. + * 3. The .NET SDK's `dotnet msbuild`, from PATH or a standard install location. + * 4. Windows: any Visual Studio MSBuild.exe, for classic .NET Framework-only solutions. + */ +internal object MsBuildLocator { + + fun locate(): MsBuildLocation { + val configured = IncredibuildSettings.getInstance().msBuildPath + if (configured.isNotBlank()) { + return if (File(configured).isFile) { + MsBuildLocation.Found(MsBuildTool.fromPath(configured)) + } else { + MsBuildLocation.NotFound( + "The MSBuild executable configured in Settings | Tools | Incredibuild doesn't exist:\n$configured" + ) + } + } + + if (SystemInfo.isWindows) { + findVisualStudioMsBuild(MSBUILD_COMPONENT, DOTNET_SDK_COMPONENT) + ?.let { return MsBuildLocation.Found(MsBuildTool(it, emptyList(), it)) } + } + findDotNet()?.let { return MsBuildLocation.Found(MsBuildTool.fromPath(it)) } + // Last resort: a Visual Studio without the .NET SDK component still builds classic + // (non-SDK-style) .NET Framework projects, which is better than finding nothing at all. + if (SystemInfo.isWindows) { + findVisualStudioMsBuild(MSBUILD_COMPONENT) + ?.let { return MsBuildLocation.Found(MsBuildTool(it, emptyList(), it)) } + } + + return MsBuildLocation.NotFound( + "No MSBuild was found on this machine: neither Visual Studio / Build Tools MSBuild nor the .NET SDK's " + + "dotnet command. Install one, or point Settings | Tools | Incredibuild at the MSBuild to use." + ) + } + + /** The newest Visual Studio / Build Tools MSBuild.exe whose install has all [requiredComponents]. */ + private fun findVisualStudioMsBuild(vararg requiredComponents: String): String? { + val programFilesX86 = System.getenv("ProgramFiles(x86)") ?: return null + val vswhere = File(programFilesX86, "Microsoft Visual Studio\\Installer\\vswhere.exe") + if (!vswhere.isFile) return null + return try { + val output = ExecUtil.execAndGetOutput( + GeneralCommandLine(vswhere.absolutePath, "-latest", "-prerelease", "-products", "*", "-requires") + // vswhere's -requires takes several ids and, without -requiresAny, matches only + // installs that have every one of them. + .withParameters(*requiredComponents) + .withParameters("-find", "MSBuild\\**\\Bin\\MSBuild.exe"), + VSWHERE_TIMEOUT_MS + ) + if (output.exitCode != 0) return null + output.stdoutLines.map { it.trim() }.firstOrNull { it.isNotEmpty() && File(it).isFile } + } catch (e: Exception) { + LOG.warn("Could not query vswhere for MSBuild", e) + null + } + } + + private fun findDotNet(): String? { + val executableName = if (SystemInfo.isWindows) "dotnet.exe" else "dotnet" + PathEnvironmentVariableUtil.findInPath(executableName)?.let { return it.absolutePath } + + val candidates = buildList { + System.getenv("DOTNET_ROOT")?.let { add(File(it, executableName)) } + if (SystemInfo.isWindows) { + System.getenv("ProgramFiles")?.let { add(File(it, "dotnet\\$executableName")) } + } else { + add(File("/usr/share/dotnet/dotnet")) + add(File("/usr/lib/dotnet/dotnet")) + add(File("/usr/local/share/dotnet/dotnet")) + } + add(File(System.getProperty("user.home"), ".dotnet${File.separator}$executableName")) + } + return candidates.firstOrNull { it.isFile }?.absolutePath + } +} diff --git a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt index 117af75..13d12c6 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt @@ -16,16 +16,25 @@ package com.incredibuild.ibplugin.settings import com.intellij.ide.plugins.PluginManagerCore +import com.intellij.openapi.actionSystem.ActionManager import com.intellij.openapi.extensions.PluginId +import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory import com.intellij.openapi.options.BoundConfigurable +import com.intellij.ui.dsl.builder.AlignX import com.intellij.ui.dsl.builder.bindIntText import com.intellij.ui.dsl.builder.bindSelected +import com.intellij.ui.dsl.builder.bindText import com.intellij.ui.dsl.builder.panel private val RUST_PLUGIN_ID = PluginId.getId("com.jetbrains.rust") -/** Settings > Tools > Incredibuild - the "-j"/"--parallel" job count and (RustRover only) - * IDE build acceleration. */ +// Registered by rider-support.xml, so present exactly when the .NET half is loaded. Checked instead +// of the com.intellij.modules.rider alias it's gated on: PluginManagerCore.isLoaded() only matches +// real plugin ids, not module aliases, and PlatformUtils.isRider() is internal API. +private const val RIDER_ACTION_ID = "Incredibuild.DotNet.BuildSolution" + +/** Settings > Tools > Incredibuild - the "-j"/"--parallel" job count, (RustRover only) IDE build + * acceleration, and (Rider only) the MSBuild to use. */ class IncredibuildConfigurable : BoundConfigurable("Incredibuild") { override fun createPanel() = panel { @@ -46,5 +55,18 @@ class IncredibuildConfigurable : BoundConfigurable("Incredibuild") { "The actions in the Incredibuild menu always use Incredibuild, either way." ) }.visible(PluginManagerCore.isLoaded(RUST_PLUGIN_ID)) + // Only meaningful for the .NET actions (see rider-support.xml), so only shown in Rider. + row("MSBuild executable:") { + textFieldWithBrowseButton( + FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor().withTitle("Select MSBuild or dotnet") + ) + .align(AlignX.FILL) + .bindText(IncredibuildSettings.getInstance()::msBuildPath) + .comment( + "Used by the ... with Incredibuild .NET build actions. Leave empty to detect it " + + "automatically: Visual Studio's MSBuild.exe on Windows if it has the .NET SDK component, otherwise " + + "dotnet msbuild. Either MSBuild.exe or the dotnet executable can be given." + ) + }.visible(ActionManager.getInstance().getAction(RIDER_ACTION_ID) != null) } } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt index ba1c9e1..addefe5 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt @@ -35,6 +35,12 @@ class IncredibuildSettings : PersistentStateComponentIncredibuild Incredibuild Build Acceleration builds your project through Incredibuild directly from the IDE - — a Rust/Cargo project from RustRover (or IntelliJ IDEA with the Rust plugin), or a CMake project from - CLion.

+ — a Rust/Cargo project from RustRover (or IntelliJ IDEA with the Rust plugin), a CMake project from + CLion, or a .NET solution from Rider.

Incredibuild is a build acceleration tool that distributes compilation work across the free cores of multiple machines on your network (or in the cloud), cutting build times without requiring any changes to your code or project structure.

A dedicated Incredibuild menu accelerates a build on demand. In RustRover:

    @@ -19,7 +19,14 @@
  • Rebuild — cleans and builds that same target in one accelerated step.
  • Build All — builds every target in the active CMake profile.
-

Stop Build — cancels the build in progress — is available either way.

+

In Rider, alongside the standard actions in the Build menu and the Solution Explorer's context 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.
    • +
+

These run MSBuild on the solution exactly as it is configured — nothing about the solution or its projects changes. Each can be bound to a keyboard shortcut in Settings | Keymap. While an accelerated build runs, the status bar shows it is building with Incredibuild, and a notification reports the result.

+

Stop Build — cancels the build in progress — is available in every IDE.

In RustRover, the IDE's own build actions can be accelerated as well. Turn on Accelerate the IDE's own build actions in Settings | Tools | Incredibuild, and two things change: Build Project goes through Incredibuild, and so does the build that runs before Run and Test. The commands and keyboard shortcuts stay exactly where they are — only what happens underneath changes. The setting is off by default. While it is off — or if Incredibuild is not 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.

Either way the accelerated build runs the same command the IDE itself would have run: the selected run configuration, build profile and target selection are respected for Cargo, and in CLion the accelerated build runs cmake's own generator-agnostic cmake --build against whichever build directory, toolchain and compiler the active CMake profile is already configured with, so it works the same way whether that profile uses Ninja, Unix Makefiles or NMake Makefiles. The same settings page configures how many parallel jobs accelerated builds request.

Works with Incredibuild on both Windows and Linux.

@@ -38,6 +45,9 @@ instance="com.incredibuild.ibplugin.settings.IncredibuildConfigurable" id="com.incredibuild.ibplugin.settings.IncredibuildConfigurable" displayName="Incredibuild"/> + + @@ -59,10 +69,11 @@ - + com.jetbrains.rust com.intellij.cmake + com.intellij.modules.rider diff --git a/src/main/resources/META-INF/rider-support.xml b/src/main/resources/META-INF/rider-support.xml new file mode 100644 index 0000000..85ed321 --- /dev/null +++ b/src/main/resources/META-INF/rider-support.xml @@ -0,0 +1,50 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt new file mode 100644 index 0000000..0a3f781 --- /dev/null +++ b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt @@ -0,0 +1,168 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.dotnet + +import com.incredibuild.ibplugin.actions.IncredibuildRunner +import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeBuild +import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeCommand +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import java.io.File + +/** Covers how the .NET actions turn Rider's state into MSBuild invocations, and the wrapper + * scripts those invocations are run through. */ +class MsBuildCommandTest { + + private val solutionDir = File("work", "Sln").absoluteFile + private val solutionFile = File(solutionDir, "App.sln").path + private val appProject = File(solutionDir, "src${File.separator}App${File.separator}App.csproj").path + private val libProject = File(solutionDir, "Lib${File.separator}Lib.csproj").path + + private val msBuild = MsBuildTool("C:\\VS\\MSBuild.exe", emptyList(), "MSBuild") + + private val sln = """ + Microsoft Visual Studio Solution File, Format Version 12.00 + Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "App", "src\App\App.csproj", "{11111111-1111-1111-1111-111111111111}" + EndProject + Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lib", "Lib\Lib.csproj", "{22222222-2222-2222-2222-222222222222}" + EndProject + Global + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {11111111-1111-1111-1111-111111111111}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {11111111-1111-1111-1111-111111111111}.Debug|Any CPU.Build.0 = Debug|Any CPU + {22222222-2222-2222-2222-222222222222}.Debug|Any CPU.ActiveCfg = Release|x64 + {22222222-2222-2222-2222-222222222222}.Debug|Any CPU.Build.0 = Release|x64 + EndGlobalSection + EndGlobal + """.trimIndent() + + @Test + fun `MsBuildTool fromPath runs dotnet through its msbuild verb`() { + val tool = MsBuildTool.fromPath("C:\\Program Files\\dotnet\\dotnet.exe") + assertEquals(listOf("msbuild"), tool.leadingArguments) + } + + @Test + fun `MsBuildTool fromPath runs MSBuild exe directly`() { + assertEquals(emptyList(), MsBuildTool.fromPath("C:\\VS\\MSBuild.exe").leadingArguments) + } + + @Test + fun `solution build passes the target and active configuration unchanged`() { + val build = solutionBuild(msBuild, solutionFile, DotNetBuildKind.REBUILD_SOLUTION, "Debug", "Any CPU") + val command = build.commands.single() + assertEquals(msBuild.executable, command.executable) + assertEquals( + listOf(solutionFile, "-t:Rebuild", "-p:Configuration=Debug", "-p:Platform=Any CPU"), + command.arguments.take(4) + ) + assertTrue(command.arguments.containsAll(COMMON_MSBUILD_ARGUMENTS)) + assertEquals(solutionDir.path, build.workingDirectory) + } + + @Test + fun `solution build through dotnet puts msbuild first`() { + val dotnet = MsBuildTool.fromPath("/usr/bin/dotnet") + val command = solutionBuild(dotnet, solutionFile, DotNetBuildKind.BUILD_SOLUTION, "Debug", "Any CPU").commands.single() + assertEquals(listOf("msbuild", solutionFile, "-t:Build"), command.arguments.take(3)) + } + + @Test + fun `sln parsing maps each project to its own configuration`() { + val mappings = parseSolutionProjectConfigurations(sln, solutionDir) + assertEquals("Debug|Any CPU", mappings[normalizedPath(appProject)]?.get("Debug|Any CPU")) + assertEquals("Release|x64", mappings[normalizedPath(libProject)]?.get("Debug|Any CPU")) + } + + @Test + fun `projects build uses each project's mapped configuration and solution context`() { + val mappings = parseSolutionProjectConfigurations(sln, solutionDir) + val build = projectsBuild(msBuild, solutionFile, listOf(appProject, libProject), "Debug", "Any CPU", mappings) + + val (app, lib) = build.commands + assertEquals(listOf(appProject, "-t:Build", "-p:Configuration=Debug", "-p:Platform=AnyCPU"), app.arguments.take(4)) + assertEquals(listOf(libProject, "-t:Build", "-p:Configuration=Release", "-p:Platform=x64"), lib.arguments.take(4)) + assertTrue(app.arguments.contains("-p:SolutionDir=${solutionDir.path}${File.separator}")) + assertTrue(app.arguments.contains("-p:SolutionPath=$solutionFile")) + assertTrue(app.arguments.contains("-p:SolutionName=App")) + assertTrue(app.arguments.contains("-p:SolutionExt=.sln")) + } + + @Test + fun `projects build falls back to the solution configuration without a mapping`() { + val build = projectsBuild(msBuild, solutionFile, listOf(appProject), "Release", "Any CPU", emptyMap()) + assertEquals( + listOf(appProject, "-t:Build", "-p:Configuration=Release", "-p:Platform=AnyCPU"), + build.commands.single().arguments.take(4) + ) + } + + @Test + fun `projectPlatformName only rewrites Any CPU`() { + assertEquals("AnyCPU", projectPlatformName("Any CPU")) + assertEquals("x64", projectPlatformName("x64")) + assertEquals("Mixed Platforms", projectPlatformName("Mixed Platforms")) + } + + @Test + fun `windows wrapper stops at the first failing command`() { + val build = NativeBuild( + listOf(NativeCommand("msbuild", listOf("a b.csproj")), NativeCommand("msbuild", listOf("c.csproj"))), + "." + ) + assertEquals( + "@echo off\r\n" + + "msbuild \"a b.csproj\"\r\n" + + "if errorlevel 1 exit /b %ERRORLEVEL%\r\n" + + "msbuild c.csproj\r\n" + + "exit /b %ERRORLEVEL%\r\n", + IncredibuildRunner.windowsWrapperScript(build) + ) + } + + @Test + fun `windows wrapper for a single command is unchanged from the CMake one`() { + val build = NativeBuild(listOf(NativeCommand("cmake", listOf("--build", "out"))), ".", mapOf("A" to "1")) + assertEquals( + "@echo off\r\nset \"A=1\"\r\ncmake --build out\r\nexit /b %ERRORLEVEL%\r\n", + IncredibuildRunner.windowsWrapperScript(build) + ) + } + + @Test + fun `linux wrapper chains several commands inside one ib_console`() { + val build = NativeBuild( + listOf(NativeCommand("dotnet", listOf("msbuild", "a.csproj")), NativeCommand("dotnet", listOf("msbuild", "b.csproj"))), + "." + ) + val script = IncredibuildRunner.linuxWrapperScript("Sln", "/opt/incredibuild/bin/ib_console", build) + assertTrue( + script, + script.endsWith( + "-- /bin/sh -c ''\\''dotnet'\\'' '\\''msbuild'\\'' '\\''a.csproj'\\'' && " + + "'\\''dotnet'\\'' '\\''msbuild'\\'' '\\''b.csproj'\\''' 2>&1\n" + ) + ) + } + + @Test + fun `linux wrapper runs a single command directly`() { + val build = NativeBuild(listOf(NativeCommand("cmake", listOf("--build", "out"))), ".") + val script = IncredibuildRunner.linuxWrapperScript("P", "/ib", build) + assertTrue(script, script.endsWith("-- 'cmake' '--build' 'out' 2>&1\n")) + } +} From e02c494b5243cf2bb9bdf041168500b647d2682b Mon Sep 17 00:00:00 2001 From: Anton Gorielikov Date: Fri, 9 Oct 2026 17:36:38 +0300 Subject: [PATCH 2/8] WIN-24578 :: Fix rebuilds between plugin and native --- .../actions/dotnet/DotNetBuildRunner.kt | 25 +++++++- .../ibplugin/actions/dotnet/MsBuildCommand.kt | 53 +++++++++++++++-- .../actions/dotnet/MsBuildCommandTest.kt | 57 +++++++++++++++++++ 3 files changed, 126 insertions(+), 9 deletions(-) diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt index 80ef5de..e388827 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt @@ -62,8 +62,14 @@ internal object DotNetBuildRunner { } val build = when (request.kind) { - DotNetBuildKind.BUILD_SOLUTION, DotNetBuildKind.REBUILD_SOLUTION -> - solutionBuild(tool, request.entryPoint, request.kind, request.configuration, request.platform) + DotNetBuildKind.BUILD_SOLUTION, DotNetBuildKind.REBUILD_SOLUTION -> solutionBuild( + tool, + request.entryPoint, + request.kind, + request.configuration, + request.platform, + restore = needsRestore(readSolutionProjectFiles(request.solutionFile)) + ) DotNetBuildKind.BUILD_PROJECTS -> projectsBuild( tool, @@ -71,7 +77,8 @@ internal object DotNetBuildRunner { request.projectFiles, request.configuration, request.platform, - readProjectConfigurations(request.solutionFile) + readProjectConfigurations(request.solutionFile), + restore = needsRestore(request.projectFiles) ) } @@ -97,6 +104,18 @@ internal object DotNetBuildRunner { } } + /** The solution's project files, for [needsRestore] - empty if they can't be read, which then + * leaves restore to Rider, as it is for every already-restored solution. */ + private fun readSolutionProjectFiles(solutionFile: String): List { + val file = File(solutionFile) + return try { + solutionProjectFiles(file.readText(), file.absoluteFile.parentFile) + } catch (e: Exception) { + LOG.warn("Could not read the project list from $solutionFile", e) + emptyList() + } + } + private fun presentation(request: DotNetBuildRequest, tool: MsBuildTool): AcceleratedBuildPresentation { val solutionName = File(request.solutionFile).nameWithoutExtension val actionName = when (request.kind) { diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt index 5d89381..6830bf4 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt @@ -52,7 +52,14 @@ internal class MsBuildTool(val executable: String, val leadingArguments: List): Boolean = + projectFiles.any { !File(File(it).absoluteFile.parentFile, "obj${File.separator}project.assets.json").isFile } + +private val SLNX_PROJECT_PATH = Regex("""]*Path="([^"]+)"""") + +/** + * The project files a .sln or .slnx lists, resolved against its directory - for [needsRestore]. + * Solution folders and non-project entries (anything not ending in "proj") are skipped. + */ +internal fun solutionProjectFiles(solutionText: String, solutionDir: File): List { + val relativePaths = SLN_PROJECT_LINE.findAll(solutionText).map { it.groupValues[1] } + + SLNX_PROJECT_PATH.findAll(solutionText).map { it.groupValues[1] } + return relativePaths + .filter { it.endsWith("proj", ignoreCase = true) } + .map { File(solutionDir, it.replace('\\', File.separatorChar).replace('/', File.separatorChar)).path } + .distinct() + .toList() +} + /** * The accelerated build for a whole solution - the equivalent of Rider's own Build/Rebuild * Solution. [entryPoint] is the .sln/.slnx, or the .slnf when a solution filter is open (MSBuild @@ -98,14 +135,15 @@ internal fun solutionBuild( entryPoint: String, kind: DotNetBuildKind, configuration: String, - platform: String + platform: String, + restore: Boolean = false ): NativeBuild { val arguments = tool.leadingArguments + listOf( entryPoint, "-t:${kind.msBuildTarget}", "-p:Configuration=$configuration", "-p:Platform=$platform", - ) + COMMON_MSBUILD_ARGUMENTS + ) + restoreArguments(restore) + COMMON_MSBUILD_ARGUMENTS return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(entryPoint).absoluteFile.parent) } @@ -132,7 +170,8 @@ internal fun projectsBuild( projectFiles: List, configuration: String, platform: String, - mappings: Map> + mappings: Map>, + restore: Boolean = false ): NativeBuild { val solution = File(solutionFile).absoluteFile val solutionDir = solution.parent.trimEnd(File.separatorChar) + File.separator @@ -153,12 +192,14 @@ internal fun projectsBuild( "-t:${DotNetBuildKind.BUILD_PROJECTS.msBuildTarget}", "-p:Configuration=$projectConfiguration", "-p:Platform=${projectPlatformName(projectPlatform)}", - ) + solutionProperties + COMMON_MSBUILD_ARGUMENTS + ) + solutionProperties + restoreArguments(restore) + COMMON_MSBUILD_ARGUMENTS NativeCommand(tool.executable, arguments) } return NativeBuild(commands, solution.parent) } +private fun restoreArguments(restore: Boolean): List = if (restore) listOf(RESTORE_ARGUMENT) else emptyList() + /** * Solutions spell the .NET "any CPU" platform with a space ("Any CPU"), project files without * one ("AnyCPU") - MSBuild's own solution-to-project translation does the same rewrite when it diff --git a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt index 0a3f781..87a83f9 100644 --- a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt +++ b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt @@ -19,9 +19,11 @@ import com.incredibuild.ibplugin.actions.IncredibuildRunner import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeBuild import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeCommand import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Test import java.io.File +import java.nio.file.Files /** Covers how the .NET actions turn Rider's state into MSBuild invocations, and the wrapper * scripts those invocations are run through. */ @@ -111,6 +113,61 @@ class MsBuildCommandTest { ) } + @Test + fun `builds leave restore to Rider by default`() { + val solution = solutionBuild(msBuild, solutionFile, DotNetBuildKind.BUILD_SOLUTION, "Debug", "Any CPU") + val projects = projectsBuild(msBuild, solutionFile, listOf(appProject), "Debug", "Any CPU", emptyMap()) + assertFalse(solution.commands.single().arguments.contains(RESTORE_ARGUMENT)) + assertFalse(projects.commands.single().arguments.contains(RESTORE_ARGUMENT)) + } + + @Test + fun `builds restore when asked to`() { + val solution = solutionBuild(msBuild, solutionFile, DotNetBuildKind.BUILD_SOLUTION, "Debug", "Any CPU", restore = true) + val projects = + projectsBuild(msBuild, solutionFile, listOf(appProject), "Debug", "Any CPU", emptyMap(), restore = true) + assertTrue(solution.commands.single().arguments.contains(RESTORE_ARGUMENT)) + assertTrue(projects.commands.single().arguments.contains(RESTORE_ARGUMENT)) + } + + @Test + fun `needsRestore is true only when a project has no assets file`() { + val root = Files.createTempDirectory("msbuild-restore-test").toFile() + try { + val restored = File(root, "Restored/Restored.csproj").apply { parentFile.mkdirs(); writeText("") } + File(restored.parentFile, "obj/project.assets.json").apply { parentFile.mkdirs(); writeText("{}") } + val fresh = File(root, "Fresh/Fresh.csproj").apply { parentFile.mkdirs(); writeText("") } + + assertFalse(needsRestore(listOf(restored.path))) + assertTrue(needsRestore(listOf(restored.path, fresh.path))) + assertFalse(needsRestore(emptyList())) + } finally { + root.deleteRecursively() + } + } + + @Test + fun `solutionProjectFiles lists the projects of an sln`() { + assertEquals( + listOf(appProject, libProject), + solutionProjectFiles(sln, solutionDir) + ) + } + + @Test + fun `solutionProjectFiles lists the projects of an slnx and skips non-project entries`() { + val slnx = """ + + + + + + + + """.trimIndent() + assertEquals(listOf(appProject, libProject), solutionProjectFiles(slnx, solutionDir)) + } + @Test fun `projectPlatformName only rewrites Any CPU`() { assertEquals("AnyCPU", projectPlatformName("Any CPU")) From 54acb39ed084dad35f7dfe40253bc54e74822ea8 Mon Sep 17 00:00:00 2001 From: Anton Gorielikov Date: Tue, 13 Oct 2026 10:43:08 +0300 Subject: [PATCH 3/8] WIN-24578 :: Bugfixes --- .../ibplugin/actions/IncredibuildRunner.kt | 21 ++- .../actions/dotnet/DotNetBuildRunner.kt | 7 +- .../ibplugin/actions/dotnet/MsBuildCommand.kt | 147 ++++++++++++++++-- .../actions/IncredibuildRunnerTest.kt | 18 +++ .../actions/dotnet/MsBuildCommandTest.kt | 118 ++++++++++++-- 5 files changed, 288 insertions(+), 23 deletions(-) diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt index bdc1938..270e82b 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt @@ -923,13 +923,28 @@ object IncredibuildRunner { return script.toString() } - /** Wraps [value] as a cmd.exe double-quoted token (after [batchEscaped]), needed only when - * it contains whitespace. */ + /** + * Wraps [value] as a cmd.exe double-quoted token (after [batchEscaped]), needed only when it + * is empty, contains whitespace, or contains a character cmd.exe would otherwise treat as an + * operator (`&`, `|`, `<`, `>`, `^`, `(`, `)` - e.g. a solution under `C:\R&D\`). + * + * Inside the quotes, the receiving program (MSBuild, cmake, ... - anything parsing its + * command line the MSVC runtime / CommandLineToArgvW way) treats backslashes right before a + * `"` as escapes, so a value ending in backslashes - `-p:SolutionDir=C:\My Projects\App\` - + * would otherwise turn the closing quote into a literal one and swallow every argument after + * it. Doubling those trailing backslashes is that same parser's escape for them. + */ internal fun cmdQuoted(value: String): String { val escaped = batchEscaped(value) - return if (escaped.any { it.isWhitespace() }) "\"$escaped\"" else escaped + if (escaped.isNotEmpty() && escaped.none { it.isWhitespace() || it in CMD_SPECIAL_CHARACTERS }) { + return escaped + } + val trailingBackslashes = escaped.length - escaped.trimEnd('\\').length + return "\"" + escaped + "\\".repeat(trailingBackslashes) + "\"" } + private const val CMD_SPECIAL_CHARACTERS = "&|<>^()" + /** Escapes [value] for literal use in a .cmd file: cmd.exe expands `%...%` variable * references anywhere on a line it parses - including inside a `set "KEY=VALUE"` value and * inside an already-quoted argument - so a stray `%` in a path or environment value (e.g. diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt index e388827..e790051 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt @@ -95,9 +95,12 @@ internal object DotNetBuildRunner { private fun readProjectConfigurations(solutionFile: String): Map> { val file = File(solutionFile) - if (!file.extension.equals("sln", ignoreCase = true)) return emptyMap() return try { - parseSolutionProjectConfigurations(file.readText(), file.absoluteFile.parentFile) + when (file.extension.lowercase()) { + "sln" -> parseSolutionProjectConfigurations(file.readText(), file.absoluteFile.parentFile) + "slnx" -> parseSlnxProjectConfigurations(file.readText(), file.absoluteFile.parentFile) + else -> emptyMap() + } } catch (e: Exception) { LOG.warn("Could not read project configuration mappings from $solutionFile", e) emptyMap() diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt index 6830bf4..c621e6e 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt @@ -17,7 +17,13 @@ package com.incredibuild.ibplugin.actions.dotnet import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeBuild import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeCommand +import org.w3c.dom.Document +import org.w3c.dom.Element +import org.xml.sax.InputSource import java.io.File +import java.io.IOException +import java.io.StringReader +import javax.xml.parsers.DocumentBuilderFactory /** Which of the three .NET "... with Incredibuild" actions is asking for a command. */ internal enum class DotNetBuildKind(val msBuildTarget: String) { @@ -101,13 +107,52 @@ internal val COMMON_MSBUILD_ARGUMENTS = listOf( internal const val RESTORE_ARGUMENT = "-restore" /** - * Whether any of [projectFiles] has no NuGet assets file yet (obj\project.assets.json, where the - * .NET SDK puts it by default) - i.e. was never restored, so building it would fail with NETSDK1004. - * A project that moves its intermediate folder elsewhere shows up here as unrestored, which only - * costs it the restore it would have had anyway before this check existed. + * Whether any of [projectFiles] is a PackageReference-restored project with no NuGet assets file + * yet - i.e. was never restored, so building it would fail with NETSDK1004. + * + * Only such projects ever get a project.assets.json, so everything else is skipped rather than + * counted as unrestored: shared projects (.shproj), C++ projects (.vcxproj), classic projects + * using packages.config, ... Counting those would add `-restore` to every build of a solution + * that contains one - exactly the restore-state churn [COMMON_MSBUILD_ARGUMENTS] explains this + * is meant to avoid. A project file that can't be read is skipped too, leaving restore to Rider. */ internal fun needsRestore(projectFiles: List): Boolean = - projectFiles.any { !File(File(it).absoluteFile.parentFile, "obj${File.separator}project.assets.json").isFile } + projectFiles.any { isUnrestoredPackageReferenceProject(File(it).absoluteFile) } + +/** Every SDK-style project restores through PackageReference implicitly, as does a classic one + * that lists a PackageReference or opts in with RestoreProjectStyle. */ +private val PACKAGE_REFERENCE_PROJECT_MARKERS = listOf( + Regex("""\bSdk\s*=\s*""""), // or + Regex(""" + Regex("""\ in the project's folder or any folder above it, with the + * artifacts output layout (UseArtifactsOutput) - whose root defaults to the folder holding + * Directory.Build.props, which can be anywhere above the project. + * A project that moves its intermediate folder anywhere else (a custom BaseIntermediateOutputPath) + * shows up as unrestored, which only costs it a restore. + */ +private fun assetsFileCandidates(projectFile: File): Sequence { + val projectDir = projectFile.parentFile + val artifactsLayout = generateSequence(projectDir) { it.parentFile } + .map { File(it, "artifacts${File.separator}obj${File.separator}${projectFile.nameWithoutExtension}") } + return (sequenceOf(File(projectDir, "obj")) + artifactsLayout).map { File(it, "project.assets.json") } +} private val SLNX_PROJECT_PATH = Regex("""]*Path="([^"]+)"""") @@ -156,7 +201,8 @@ internal fun solutionBuild( * asked to build a specific project by a target name derived from its solution-folder path - so * the context the solution would otherwise have provided is passed explicitly instead: * - the project's own configuration|platform that the solution's active configuration maps it - * to ([mappings], from [parseSolutionProjectConfigurations]) - falling back to the solution + * to ([mappings], from [parseSolutionProjectConfigurations] or + * [parseSlnxProjectConfigurations]) - falling back to the solution * configuration's own names, as Visual Studio does for a project with no mapping of its own; * - the `SolutionDir`/`SolutionPath`/... properties MSBuild would have set had it come in * through the solution, which build logic commonly relies on (e.g. a shared output folder). @@ -224,9 +270,8 @@ private val SLN_ACTIVE_CFG_LINE = Regex( * solution configuration|platform builds (its `ProjectConfigurationPlatforms` section), keyed by * [normalizedPath] of each project file and then by solution "Configuration|Platform". * - * Returns an empty map for anything else (e.g. an XML .slnx, which only lists the exceptions to - * the same-names default, or a .sln this can't parse) - [projectsBuild] then falls back to the - * solution configuration's own names, which is what such solutions mean by default anyway. + * Returns an empty map for a .sln this can't parse - [projectsBuild] then falls back to the + * solution configuration's own names. An XML .slnx is read by [parseSlnxProjectConfigurations]. */ internal fun parseSolutionProjectConfigurations(solutionText: String, solutionDir: File): Map> { val projectPathByGuid = HashMap() @@ -244,6 +289,90 @@ internal fun parseSolutionProjectConfigurations(solutionText: String, solutionDi return result } +/** .NET project types whose platform a .slnx maps to "Any CPU" unless told otherwise. */ +private val MANAGED_PROJECT_EXTENSIONS = setOf("csproj", "vbproj", "fsproj") + +/** + * The same mapping as [parseSolutionProjectConfigurations], for an XML (.slnx) solution. + * + * Unlike a .sln, a .slnx doesn't spell out every project's configuration|platform for every + * solution one - only the exceptions to its project type's defaults, as ``/`` + * rules inside each ``. The defaults are what makes a plain fallback to the solution's + * own names wrong: a .NET project builds as "Any CPU" for every solution platform (a solution's + * "x64" doesn't make a C# library x64 - it would put its output in bin\x64\ instead of the bin\ + * Rider's own build uses), and a C++ project builds the solution's "x86" as "Win32". So each + * project starts from its type's default and its own rules are applied on top, in order, the + * last matching one winning. + * + * Solution configurations are the `` section's build types × platforms, each + * defaulting as Visual Studio's does when not declared (Debug and Release; Any CPU). + */ +internal fun parseSlnxProjectConfigurations(solutionText: String, solutionDir: File): Map> { + val root = parseXml(solutionText).documentElement + val declarations = root.childElements("Configurations").firstOrNull() + val buildTypes = declarations?.childElements("BuildType")?.mapNotNull { it.attributeOrNull("Name") }?.toList() + .orEmpty().ifEmpty { listOf("Debug", "Release") } + val platforms = declarations?.childElements("Platform")?.mapNotNull { it.attributeOrNull("Name") }?.toList() + .orEmpty().ifEmpty { listOf("Any CPU") } + + val result = HashMap>() + val projects = root.getElementsByTagName("Project") + for (i in 0 until projects.length) { + val project = projects.item(i) as Element + val path = project.attributeOrNull("Path") ?: continue + val projectFile = File(solutionDir, path.replace('\\', File.separatorChar).replace('/', File.separatorChar)) + val rules = project.childElements().filter { it.tagName == "BuildType" || it.tagName == "Platform" }.toList() + + val mapping = HashMap() + for (buildType in buildTypes) { + for (platform in platforms) { + var projectBuildType = buildType + var projectPlatform = defaultSlnxProjectPlatform(projectFile.extension.lowercase(), platform) + for (rule in rules) { + val target = rule.attributeOrNull("Project") ?: continue + if (!slnxRuleMatches(rule.attributeOrNull("Solution"), buildType, platform)) continue + if (rule.tagName == "BuildType") projectBuildType = target else projectPlatform = target + } + mapping["$buildType|$platform"] = "$projectBuildType|$projectPlatform" + } + } + result[normalizedPath(projectFile.path)] = mapping + } + return result +} + +private fun defaultSlnxProjectPlatform(extension: String, solutionPlatform: String): String = when { + extension in MANAGED_PROJECT_EXTENSIONS -> "Any CPU" + extension == "vcxproj" && solutionPlatform.equals("x86", ignoreCase = true) -> "Win32" + else -> solutionPlatform +} + +/** A rule's `Solution="BuildType|Platform"` pattern - either half may be `*` or left out, and a + * rule without one applies to every solution configuration. */ +private fun slnxRuleMatches(pattern: String?, buildType: String, platform: String): Boolean { + if (pattern.isNullOrBlank()) return true + val parts = pattern.split('|', limit = 2).map { it.trim() } + fun matches(part: String?, value: String) = part.isNullOrEmpty() || part == "*" || part.equals(value, ignoreCase = true) + return matches(parts[0], buildType) && matches(parts.getOrNull(1), platform) +} + +private fun parseXml(text: String): Document { + val factory = DocumentBuilderFactory.newInstance().apply { + // A solution file never needs a DTD - refusing one rules out entity-expansion tricks. + setFeature("http://apache.org/xml/features/disallow-doctype-decl", true) + isExpandEntityReferences = false + } + return factory.newDocumentBuilder().parse(InputSource(StringReader(text))) +} + +private fun Element.childElements(tagName: String? = null): Sequence = + (0 until childNodes.length).asSequence() + .map { childNodes.item(it) } + .filterIsInstance() + .filter { tagName == null || it.tagName == tagName } + +private fun Element.attributeOrNull(name: String): String? = getAttribute(name).takeIf { it.isNotEmpty() } + /** Canonical, case-insensitive form of a path, so a project path from Rider's model matches the * one resolved from the .sln regardless of `..`/separator/casing differences. */ internal fun normalizedPath(path: String): String = diff --git a/src/test/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunnerTest.kt b/src/test/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunnerTest.kt index 12728ef..7e28d85 100644 --- a/src/test/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunnerTest.kt +++ b/src/test/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunnerTest.kt @@ -55,6 +55,24 @@ class IncredibuildRunnerTest { assertEquals("\"%%TEMP%% dir\"", IncredibuildRunner.cmdQuoted("%TEMP% dir")) } + @Test + fun `cmdQuoted doubles trailing backslashes so they don't escape the closing quote`() { + assertEquals( + "\"-p:SolutionDir=C:\\My Projects\\App\\\\\"", + IncredibuildRunner.cmdQuoted("-p:SolutionDir=C:\\My Projects\\App\\") + ) + // Unquoted, a trailing backslash is just a literal one and needs nothing. + assertEquals("-p:SolutionDir=C:\\App\\", IncredibuildRunner.cmdQuoted("-p:SolutionDir=C:\\App\\")) + } + + @Test + fun `cmdQuoted quotes cmd operator characters and empty values`() { + assertEquals("\"C:\\R&D\\App.sln\"", IncredibuildRunner.cmdQuoted("C:\\R&D\\App.sln")) + assertEquals("\"C:\\Apps (old)\\App.sln\"", IncredibuildRunner.cmdQuoted("C:\\Apps (old)\\App.sln")) + assertEquals("\"a^b\"", IncredibuildRunner.cmdQuoted("a^b")) + assertEquals("\"\"", IncredibuildRunner.cmdQuoted("")) + } + @Test fun `VALID_SHELL_IDENTIFIER accepts ordinary environment variable names`() { assertTrue(VALID_SHELL_IDENTIFIER.matches("PATH")) diff --git a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt index 87a83f9..6b94c68 100644 --- a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt +++ b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt @@ -104,6 +104,65 @@ class MsBuildCommandTest { assertTrue(app.arguments.contains("-p:SolutionExt=.sln")) } + private val slnx = """ + + + + + + + + + + + + + + + + + + """.trimIndent() + + @Test + fun `slnx parsing maps managed projects to Any CPU by default`() { + val lib = parseSlnxProjectConfigurations(slnx, solutionDir)[normalizedPath(libProject)]!! + assertEquals("Debug|Any CPU", lib["Debug|Any CPU"]) + assertEquals("Release|Any CPU", lib["Release|x64"]) + } + + @Test + fun `slnx parsing applies a project's own rules over the defaults`() { + val app = parseSlnxProjectConfigurations(slnx, solutionDir)[normalizedPath(appProject)]!! + assertEquals("Release|x64", app["Debug|x64"]) + assertEquals("Release|Any CPU", app["Debug|Any CPU"]) + assertEquals("Release|x64", app["Release|x64"]) + } + + @Test + fun `slnx parsing maps x86 to Win32 for C++ projects`() { + val native = File(solutionDir, "Native${File.separator}Native.vcxproj").path + val mapping = parseSlnxProjectConfigurations(slnx, solutionDir)[normalizedPath(native)]!! + assertEquals("Debug|Win32", mapping["Debug|x86"]) + assertEquals("Debug|x64", mapping["Debug|x64"]) + } + + @Test + fun `slnx parsing defaults the solution configurations when none are declared`() { + val mappings = parseSlnxProjectConfigurations("""""", solutionDir) + assertEquals(setOf("Debug|Any CPU", "Release|Any CPU"), mappings[normalizedPath(libProject)]!!.keys) + } + + @Test + fun `projects build of an slnx keeps a managed project on AnyCPU for an x64 solution`() { + val mappings = parseSlnxProjectConfigurations(slnx, solutionDir) + val build = projectsBuild(msBuild, solutionFile, listOf(libProject), "Debug", "x64", mappings) + assertEquals( + listOf(libProject, "-t:Build", "-p:Configuration=Debug", "-p:Platform=AnyCPU"), + build.commands.single().arguments.take(4) + ) + } + @Test fun `projects build falls back to the solution configuration without a mapping`() { val build = projectsBuild(msBuild, solutionFile, listOf(appProject), "Release", "Any CPU", emptyMap()) @@ -130,22 +189,63 @@ class MsBuildCommandTest { assertTrue(projects.commands.single().arguments.contains(RESTORE_ARGUMENT)) } - @Test - fun `needsRestore is true only when a project has no assets file`() { + private fun withTempDir(block: (File) -> Unit) { val root = Files.createTempDirectory("msbuild-restore-test").toFile() try { - val restored = File(root, "Restored/Restored.csproj").apply { parentFile.mkdirs(); writeText("") } - File(restored.parentFile, "obj/project.assets.json").apply { parentFile.mkdirs(); writeText("{}") } - val fresh = File(root, "Fresh/Fresh.csproj").apply { parentFile.mkdirs(); writeText("") } - - assertFalse(needsRestore(listOf(restored.path))) - assertTrue(needsRestore(listOf(restored.path, fresh.path))) - assertFalse(needsRestore(emptyList())) + block(root) } finally { root.deleteRecursively() } } + private fun File.project(relativePath: String, text: String) = + File(this, relativePath).apply { parentFile.mkdirs(); writeText(text) } + + private fun File.assetsFile(relativeDir: String) = + File(this, "$relativeDir/project.assets.json").apply { parentFile.mkdirs(); writeText("{}") } + + private val sdkProject = """""" + + @Test + fun `needsRestore is true only when an SDK-style project has no assets file`() = withTempDir { root -> + val restored = root.project("Restored/Restored.csproj", sdkProject) + root.assetsFile("Restored/obj") + val fresh = root.project("Fresh/Fresh.csproj", sdkProject) + + assertFalse(needsRestore(listOf(restored.path))) + assertTrue(needsRestore(listOf(restored.path, fresh.path))) + assertFalse(needsRestore(emptyList())) + } + + @Test + fun `needsRestore ignores projects that never get an assets file`() = withTempDir { root -> + val classic = root.project("Classic/Classic.csproj", """""") + val shared = root.project("Shared/Shared.shproj", """""") + val cpp = root.project("Native/Native.vcxproj", """""") + val missing = File(root, "Gone/Gone.csproj").path + + assertFalse(needsRestore(listOf(classic.path, shared.path, cpp.path, missing))) + } + + @Test + fun `needsRestore counts classic projects using PackageReference`() = withTempDir { root -> + val classic = root.project( + "Classic/Classic.csproj", + """""" + ) + assertTrue(needsRestore(listOf(classic.path))) + root.assetsFile("Classic/obj") + assertFalse(needsRestore(listOf(classic.path))) + } + + @Test + fun `needsRestore finds the assets file in the artifacts output layout`() = withTempDir { root -> + val app = root.project("src/App/App.csproj", sdkProject) + assertTrue(needsRestore(listOf(app.path))) + root.assetsFile("artifacts/obj/App") + assertFalse(needsRestore(listOf(app.path))) + } + @Test fun `solutionProjectFiles lists the projects of an sln`() { assertEquals( From 1227d3a15c55d4559015091078e24ee6e627c5bf Mon Sep 17 00:00:00 2001 From: Anton Gorielikov Date: Tue, 13 Oct 2026 13:08:27 +0300 Subject: [PATCH 4/8] WIN-24578 :: Fix fromPath --- .../incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt index c621e6e..71cd5f3 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt @@ -45,7 +45,9 @@ internal class MsBuildTool(val executable: String, val leadingArguments: List Date: Wed, 14 Oct 2026 20:10:17 +0300 Subject: [PATCH 5/8] WIN-24578 :: projectBuild fix --- .../ibplugin/actions/IncredibuildRunner.kt | 6 +- .../actions/dotnet/DotNetBuildRunner.kt | 45 ++-- .../ibplugin/actions/dotnet/MsBuildCommand.kt | 210 ++++++------------ .../actions/dotnet/MsBuildCommandTest.kt | 143 +++++------- 4 files changed, 160 insertions(+), 244 deletions(-) diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt index 270e82b..291ff81 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt @@ -842,7 +842,7 @@ object IncredibuildRunner { /** * The .cmd [prepareNativeBuildWindows] points BuildConsole's /command= at: [NativeBuild.environment] * via `set`, then each command in turn, stopping at (and exiting with) the first non-zero - * exit code - so a multi-project build reports failure the same way a single command does. + * exit code - so a multi-command build reports failure the same way a single command does. */ internal fun windowsWrapperScript(build: NativeBuild): String { val cmdLines = StringBuilder("@echo off\r\n") @@ -870,8 +870,8 @@ object IncredibuildRunner { * command) is written into one script, each token quoted individually and safely via * [shellSingleQuoted]. * - * ib_console runs exactly one command, so a [NativeBuild] with more than one (a multi-project - * MSBuild selection) has them chained inside a `/bin/sh -c` that ib_console runs instead - + * ib_console runs exactly one command, so a [NativeBuild] with more than one has them + * chained inside a `/bin/sh -c` that ib_console runs instead - * every process they start is still a descendant of ib_console, so all of it is accelerated. * * No custom `--profile` here, unlike [prepareBuildLinux]'s RustRover-specific one: C/C++ diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt index e790051..b0b780d 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt @@ -71,15 +71,26 @@ internal object DotNetBuildRunner { restore = needsRestore(readSolutionProjectFiles(request.solutionFile)) ) - DotNetBuildKind.BUILD_PROJECTS -> projectsBuild( - tool, - request.solutionFile, - request.projectFiles, - request.configuration, - request.platform, - readProjectConfigurations(request.solutionFile), - restore = needsRestore(request.projectFiles) - ) + DotNetBuildKind.BUILD_PROJECTS -> { + val targetNames = readProjectTargets(request.solutionFile) + val missing = request.projectFiles.filter { normalizedPath(it) !in targetNames } + if (missing.isNotEmpty()) { + return showError( + project, + "Could not find these projects in ${File(request.solutionFile).name}, so they can't be " + + "built through it:\n" + missing.joinToString("\n") + ) + } + projectsBuild( + tool, + request.solutionFile, + request.projectFiles, + request.configuration, + request.platform, + targetNames, + restore = needsRestore(request.projectFiles) + ) + } } IncredibuildRunner.launchNativeBuild( @@ -93,16 +104,18 @@ internal object DotNetBuildRunner { }) } - private fun readProjectConfigurations(solutionFile: String): Map> { + /** The solution's per-project build targets - see [solutionProjectTargets]. Empty if the + * solution can't be read, which then reports every selected project as not found. */ + private fun readProjectTargets(solutionFile: String): Map { val file = File(solutionFile) return try { - when (file.extension.lowercase()) { - "sln" -> parseSolutionProjectConfigurations(file.readText(), file.absoluteFile.parentFile) - "slnx" -> parseSlnxProjectConfigurations(file.readText(), file.absoluteFile.parentFile) - else -> emptyMap() - } + solutionProjectTargets( + file.readText(), + file.absoluteFile.parentFile, + isSlnx = file.extension.equals("slnx", ignoreCase = true) + ) } catch (e: Exception) { - LOG.warn("Could not read project configuration mappings from $solutionFile", e) + LOG.warn("Could not read the project list from $solutionFile", e) emptyMap() } } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt index 71cd5f3..69b39ff 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt @@ -163,11 +163,11 @@ private val SLNX_PROJECT_PATH = Regex("""]*Path="([^"]+)"""") * Solution folders and non-project entries (anything not ending in "proj") are skipped. */ internal fun solutionProjectFiles(solutionText: String, solutionDir: File): List { - val relativePaths = SLN_PROJECT_LINE.findAll(solutionText).map { it.groupValues[1] } + + val relativePaths = SLN_PROJECT_LINE.findAll(solutionText).map { it.groupValues[2] } + SLNX_PROJECT_PATH.findAll(solutionText).map { it.groupValues[1] } return relativePaths .filter { it.endsWith("proj", ignoreCase = true) } - .map { File(solutionDir, it.replace('\\', File.separatorChar).replace('/', File.separatorChar)).path } + .map { File(solutionDir, nativeSeparators(it)).path } .distinct() .toList() } @@ -197,20 +197,17 @@ internal fun solutionBuild( /** * The accelerated build for individually selected projects - the equivalent of Rider's own * Build Selection, which also builds each selected project together with the projects it - * references (MSBuild follows ProjectReferences by itself). + * references. * - * Each project is built directly rather than through the solution, since a solution can only be - * asked to build a specific project by a target name derived from its solution-folder path - so - * the context the solution would otherwise have provided is passed explicitly instead: - * - the project's own configuration|platform that the solution's active configuration maps it - * to ([mappings], from [parseSolutionProjectConfigurations] or - * [parseSlnxProjectConfigurations]) - falling back to the solution - * configuration's own names, as Visual Studio does for a project with no mapping of its own; - * - the `SolutionDir`/`SolutionPath`/... properties MSBuild would have set had it come in - * through the solution, which build logic commonly relies on (e.g. a shared output folder). - * - * One MSBuild invocation per project, run one after the other: MSBuild only accepts a single - * project per invocation. Each one is still parallel within itself (see [COMMON_MSBUILD_ARGUMENTS]). + * Built through the solution, asking it for just those projects by the per-project targets its + * build defines ([targetNames], from [solutionProjectTargets] - every one of [projectFiles] must + * be in it), rather than by building each project file directly. Only a solution build maps each + * project, and each project it references, to the configuration|platform the solution's active + * configuration assigns it: a project built directly passes its own -p:Configuration/-p:Platform + * on to its references unchanged, so a library the solution builds as Debug|Any CPU would be + * built as the app's Release|x64, into a different bin\ than Rider's own build uses. Going through + * the solution also sets the SolutionDir/SolutionPath/... properties build logic relies on, and + * builds all the selected projects in one parallel invocation. */ internal fun projectsBuild( tool: MsBuildTool, @@ -218,145 +215,90 @@ internal fun projectsBuild( projectFiles: List, configuration: String, platform: String, - mappings: Map>, + targetNames: Map, restore: Boolean = false ): NativeBuild { - val solution = File(solutionFile).absoluteFile - val solutionDir = solution.parent.trimEnd(File.separatorChar) + File.separator - val solutionProperties = listOf( - "-p:SolutionDir=$solutionDir", - "-p:SolutionPath=${solution.path}", - "-p:SolutionName=${solution.nameWithoutExtension}", - "-p:SolutionFileName=${solution.name}", - "-p:SolutionExt=.${solution.extension}", - ) - - val commands = projectFiles.map { projectFile -> - val mapped = mappings[normalizedPath(projectFile)]?.get("$configuration|$platform") - val (projectConfiguration, projectPlatform) = mapped?.split('|', limit = 2)?.takeIf { it.size == 2 } - ?: listOf(configuration, platform) - val arguments = tool.leadingArguments + listOf( - projectFile, - "-t:${DotNetBuildKind.BUILD_PROJECTS.msBuildTarget}", - "-p:Configuration=$projectConfiguration", - "-p:Platform=${projectPlatformName(projectPlatform)}", - ) + solutionProperties + restoreArguments(restore) + COMMON_MSBUILD_ARGUMENTS - NativeCommand(tool.executable, arguments) - } - return NativeBuild(commands, solution.parent) + val targets = projectFiles.map { targetNames.getValue(normalizedPath(it)) } + val arguments = tool.leadingArguments + listOf( + solutionFile, + "-t:${targets.joinToString(";")}", + "-p:Configuration=$configuration", + "-p:Platform=$platform", + ) + restoreArguments(restore) + COMMON_MSBUILD_ARGUMENTS + return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(solutionFile).absoluteFile.parent) } private fun restoreArguments(restore: Boolean): List = if (restore) listOf(RESTORE_ARGUMENT) else emptyList() -/** - * Solutions spell the .NET "any CPU" platform with a space ("Any CPU"), project files without - * one ("AnyCPU") - MSBuild's own solution-to-project translation does the same rewrite when it - * builds a project through a solution, so it has to be done here when building one directly. - */ -internal fun projectPlatformName(platform: String): String = - if (platform.equals("Any CPU", ignoreCase = true)) "AnyCPU" else platform - +/** `Project("{type}") = "name", "path", "{guid}"` - solution folders included. */ private val SLN_PROJECT_LINE = Regex( - """^Project\("\{[^}]*}"\)\s*=\s*"[^"]*"\s*,\s*"([^"]*)"\s*,\s*"\{([^}]*)}"""", + """^Project\("\{[^}]*}"\)\s*=\s*"([^"]*)"\s*,\s*"([^"]*)"\s*,\s*"\{([^}]*)}"""", RegexOption.MULTILINE ) -/** e.g. `{GUID}.Debug|Any CPU.ActiveCfg = Debug|x64` */ -private val SLN_ACTIVE_CFG_LINE = Regex( - """^\s*\{([^}]*)}\.([^.=]+\|[^=]+?)\.ActiveCfg\s*=\s*(.+?)\s*$""", - RegexOption.MULTILINE -) +private val SLN_NESTED_PROJECTS_SECTION = + Regex("""GlobalSection\(NestedProjects\)(.*?)EndGlobalSection""", RegexOption.DOT_MATCHES_ALL) -/** - * Reads a classic (.sln) solution's own record of which project configuration|platform each - * solution configuration|platform builds (its `ProjectConfigurationPlatforms` section), keyed by - * [normalizedPath] of each project file and then by solution "Configuration|Platform". - * - * Returns an empty map for a .sln this can't parse - [projectsBuild] then falls back to the - * solution configuration's own names. An XML .slnx is read by [parseSlnxProjectConfigurations]. - */ -internal fun parseSolutionProjectConfigurations(solutionText: String, solutionDir: File): Map> { - val projectPathByGuid = HashMap() - for (match in SLN_PROJECT_LINE.findAll(solutionText)) { - val relativePath = match.groupValues[1].replace('\\', File.separatorChar).replace('/', File.separatorChar) - val guid = match.groupValues[2].uppercase() - projectPathByGuid[guid] = normalizedPath(File(solutionDir, relativePath).path) - } +/** `{child} = {parent}` - only meaningful inside [SLN_NESTED_PROJECTS_SECTION]: a project's + * ProjectDependencies section has lines of exactly the same shape. */ +private val SLN_NESTED_LINE = Regex("""\{([^}]*)}\s*=\s*\{([^}]*)}""") - val result = HashMap>() - for (match in SLN_ACTIVE_CFG_LINE.findAll(solutionText)) { - val projectPath = projectPathByGuid[match.groupValues[1].uppercase()] ?: continue - result.getOrPut(projectPath) { HashMap() }[match.groupValues[2].trim()] = match.groupValues[3] - } - return result -} +/** The characters MSBuild replaces with `_` in a solution's per-project target names. */ +private const val TARGET_NAME_CHARACTERS_TO_CLEANSE = "%$@;.()'" -/** .NET project types whose platform a .slnx maps to "Any CPU" unless told otherwise. */ -private val MANAGED_PROJECT_EXTENSIONS = setOf("csproj", "vbproj", "fsproj") +private fun cleansedTargetName(name: String): String = + name.map { if (it in TARGET_NAME_CHARACTERS_TO_CLEANSE) '_' else it }.joinToString("") /** - * The same mapping as [parseSolutionProjectConfigurations], for an XML (.slnx) solution. - * - * Unlike a .sln, a .slnx doesn't spell out every project's configuration|platform for every - * solution one - only the exceptions to its project type's defaults, as ``/`` - * rules inside each ``. The defaults are what makes a plain fallback to the solution's - * own names wrong: a .NET project builds as "Any CPU" for every solution platform (a solution's - * "x64" doesn't make a C# library x64 - it would put its output in bin\x64\ instead of the bin\ - * Rider's own build uses), and a C++ project builds the solution's "x86" as "Win32". So each - * project starts from its type's default and its own rules are applied on top, in order, the - * last matching one winning. - * - * Solution configurations are the `` section's build types × platforms, each - * defaulting as Visual Studio's does when not declared (Debug and Release; Any CPU). + * The target a solution build defines for building just one of its projects, keyed by + * [normalizedPath] of each project file: the project's solution-folder path and its name, joined + * with `\`, each part with [TARGET_NAME_CHARACTERS_TO_CLEANSE] replaced by `_` - e.g. the "My.Lib" + * project in the "src" folder is `src\My_Lib`. That's the name MSBuild's solution build gives it, + * for a .sln (project names as written in it, folders from its NestedProjects section) and a .slnx + * (project file names, folders from each ``) alike. */ -internal fun parseSlnxProjectConfigurations(solutionText: String, solutionDir: File): Map> { - val root = parseXml(solutionText).documentElement - val declarations = root.childElements("Configurations").firstOrNull() - val buildTypes = declarations?.childElements("BuildType")?.mapNotNull { it.attributeOrNull("Name") }?.toList() - .orEmpty().ifEmpty { listOf("Debug", "Release") } - val platforms = declarations?.childElements("Platform")?.mapNotNull { it.attributeOrNull("Name") }?.toList() - .orEmpty().ifEmpty { listOf("Any CPU") } +internal fun solutionProjectTargets(solutionText: String, solutionDir: File, isSlnx: Boolean): Map = + if (isSlnx) slnxProjectTargets(solutionText, solutionDir) else slnProjectTargets(solutionText, solutionDir) + +private fun slnProjectTargets(solutionText: String, solutionDir: File): Map { + class Entry(val name: String, val path: String) + + val entries = SLN_PROJECT_LINE.findAll(solutionText) + .associate { it.groupValues[3].uppercase() to Entry(it.groupValues[1], it.groupValues[2]) } + val parentOf = SLN_NESTED_PROJECTS_SECTION.find(solutionText)?.groupValues?.get(1) + ?.let { section -> SLN_NESTED_LINE.findAll(section).associate { it.groupValues[1].uppercase() to it.groupValues[2].uppercase() } } + .orEmpty() + + fun targetName(guid: String): String { + val parts = ArrayList() + var current: String? = guid + // Bounded by the number of entries, so a malformed (cyclic) NestedProjects can't hang this. + while (current != null && parts.size <= entries.size) { + parts += cleansedTargetName(entries.getValue(current).name) + current = parentOf[current]?.takeIf { it in entries } + } + return parts.asReversed().joinToString("\\") + } + + return entries.filterValues { it.path.endsWith("proj", ignoreCase = true) } + .entries.associate { (guid, entry) -> normalizedPath(File(solutionDir, nativeSeparators(entry.path)).path) to targetName(guid) } +} - val result = HashMap>() - val projects = root.getElementsByTagName("Project") +private fun slnxProjectTargets(solutionText: String, solutionDir: File): Map { + val projects = parseXml(solutionText).documentElement.getElementsByTagName("Project") + val result = HashMap() for (i in 0 until projects.length) { val project = projects.item(i) as Element val path = project.attributeOrNull("Path") ?: continue - val projectFile = File(solutionDir, path.replace('\\', File.separatorChar).replace('/', File.separatorChar)) - val rules = project.childElements().filter { it.tagName == "BuildType" || it.tagName == "Platform" }.toList() - - val mapping = HashMap() - for (buildType in buildTypes) { - for (platform in platforms) { - var projectBuildType = buildType - var projectPlatform = defaultSlnxProjectPlatform(projectFile.extension.lowercase(), platform) - for (rule in rules) { - val target = rule.attributeOrNull("Project") ?: continue - if (!slnxRuleMatches(rule.attributeOrNull("Solution"), buildType, platform)) continue - if (rule.tagName == "BuildType") projectBuildType = target else projectPlatform = target - } - mapping["$buildType|$platform"] = "$projectBuildType|$projectPlatform" - } - } - result[normalizedPath(projectFile.path)] = mapping + val projectFile = File(solutionDir, nativeSeparators(path)) + val folder = (project.parentNode as? Element)?.takeIf { it.tagName == "Folder" }?.attributeOrNull("Name") + val parts = folder?.split('/')?.filter { it.isNotEmpty() }.orEmpty() + projectFile.nameWithoutExtension + result[normalizedPath(projectFile.path)] = parts.joinToString("\\") { cleansedTargetName(it) } } return result } -private fun defaultSlnxProjectPlatform(extension: String, solutionPlatform: String): String = when { - extension in MANAGED_PROJECT_EXTENSIONS -> "Any CPU" - extension == "vcxproj" && solutionPlatform.equals("x86", ignoreCase = true) -> "Win32" - else -> solutionPlatform -} - -/** A rule's `Solution="BuildType|Platform"` pattern - either half may be `*` or left out, and a - * rule without one applies to every solution configuration. */ -private fun slnxRuleMatches(pattern: String?, buildType: String, platform: String): Boolean { - if (pattern.isNullOrBlank()) return true - val parts = pattern.split('|', limit = 2).map { it.trim() } - fun matches(part: String?, value: String) = part.isNullOrEmpty() || part == "*" || part.equals(value, ignoreCase = true) - return matches(parts[0], buildType) && matches(parts.getOrNull(1), platform) -} +private fun nativeSeparators(path: String): String = path.replace('\\', File.separatorChar).replace('/', File.separatorChar) private fun parseXml(text: String): Document { val factory = DocumentBuilderFactory.newInstance().apply { @@ -367,15 +309,9 @@ private fun parseXml(text: String): Document { return factory.newDocumentBuilder().parse(InputSource(StringReader(text))) } -private fun Element.childElements(tagName: String? = null): Sequence = - (0 until childNodes.length).asSequence() - .map { childNodes.item(it) } - .filterIsInstance() - .filter { tagName == null || it.tagName == tagName } - private fun Element.attributeOrNull(name: String): String? = getAttribute(name).takeIf { it.isNotEmpty() } /** Canonical, case-insensitive form of a path, so a project path from Rider's model matches the - * one resolved from the .sln regardless of `..`/separator/casing differences. */ + * one resolved from the solution regardless of `..`/separator/casing differences. */ internal fun normalizedPath(path: String): String = File(path).absoluteFile.normalize().path.replace('\\', '/').lowercase() diff --git a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt index 6b94c68..1ac5bba 100644 --- a/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt +++ b/src/test/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommandTest.kt @@ -38,20 +38,24 @@ class MsBuildCommandTest { private val sln = """ Microsoft Visual Studio Solution File, Format Version 12.00 + Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{33333333-3333-3333-3333-333333333333}" + EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "App", "src\App\App.csproj", "{11111111-1111-1111-1111-111111111111}" + ProjectSection(ProjectDependencies) = postProject + {22222222-2222-2222-2222-222222222222} = {22222222-2222-2222-2222-222222222222} + EndProjectSection EndProject - Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lib", "Lib\Lib.csproj", "{22222222-2222-2222-2222-222222222222}" + Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "My.Lib", "Lib\Lib.csproj", "{22222222-2222-2222-2222-222222222222}" EndProject Global - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {11111111-1111-1111-1111-111111111111}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {11111111-1111-1111-1111-111111111111}.Debug|Any CPU.Build.0 = Debug|Any CPU - {22222222-2222-2222-2222-222222222222}.Debug|Any CPU.ActiveCfg = Release|x64 - {22222222-2222-2222-2222-222222222222}.Debug|Any CPU.Build.0 = Release|x64 + GlobalSection(NestedProjects) = preSolution + {11111111-1111-1111-1111-111111111111} = {33333333-3333-3333-3333-333333333333} EndGlobalSection EndGlobal """.trimIndent() + private val targets = mapOf(normalizedPath(appProject) to "src\\App", normalizedPath(libProject) to "My_Lib") + @Test fun `MsBuildTool fromPath runs dotnet through its msbuild verb`() { val tool = MsBuildTool.fromPath("C:\\Program Files\\dotnet\\dotnet.exe") @@ -84,98 +88,68 @@ class MsBuildCommandTest { } @Test - fun `sln parsing maps each project to its own configuration`() { - val mappings = parseSolutionProjectConfigurations(sln, solutionDir) - assertEquals("Debug|Any CPU", mappings[normalizedPath(appProject)]?.get("Debug|Any CPU")) - assertEquals("Release|x64", mappings[normalizedPath(libProject)]?.get("Debug|Any CPU")) - } - - @Test - fun `projects build uses each project's mapped configuration and solution context`() { - val mappings = parseSolutionProjectConfigurations(sln, solutionDir) - val build = projectsBuild(msBuild, solutionFile, listOf(appProject, libProject), "Debug", "Any CPU", mappings) - - val (app, lib) = build.commands - assertEquals(listOf(appProject, "-t:Build", "-p:Configuration=Debug", "-p:Platform=AnyCPU"), app.arguments.take(4)) - assertEquals(listOf(libProject, "-t:Build", "-p:Configuration=Release", "-p:Platform=x64"), lib.arguments.take(4)) - assertTrue(app.arguments.contains("-p:SolutionDir=${solutionDir.path}${File.separator}")) - assertTrue(app.arguments.contains("-p:SolutionPath=$solutionFile")) - assertTrue(app.arguments.contains("-p:SolutionName=App")) - assertTrue(app.arguments.contains("-p:SolutionExt=.sln")) - } - - private val slnx = """ - - - - - - - - - - - - - - - - - - """.trimIndent() - - @Test - fun `slnx parsing maps managed projects to Any CPU by default`() { - val lib = parseSlnxProjectConfigurations(slnx, solutionDir)[normalizedPath(libProject)]!! - assertEquals("Debug|Any CPU", lib["Debug|Any CPU"]) - assertEquals("Release|Any CPU", lib["Release|x64"]) - } - - @Test - fun `slnx parsing applies a project's own rules over the defaults`() { - val app = parseSlnxProjectConfigurations(slnx, solutionDir)[normalizedPath(appProject)]!! - assertEquals("Release|x64", app["Debug|x64"]) - assertEquals("Release|Any CPU", app["Debug|Any CPU"]) - assertEquals("Release|x64", app["Release|x64"]) - } - - @Test - fun `slnx parsing maps x86 to Win32 for C++ projects`() { - val native = File(solutionDir, "Native${File.separator}Native.vcxproj").path - val mapping = parseSlnxProjectConfigurations(slnx, solutionDir)[normalizedPath(native)]!! - assertEquals("Debug|Win32", mapping["Debug|x86"]) - assertEquals("Debug|x64", mapping["Debug|x64"]) + fun `sln project targets follow solution folders and MSBuild's name cleansing`() { + // App's ProjectDependencies line has the same {guid} = {guid} shape as a nesting one - it + // must not make Lib App's parent. + assertEquals(targets, solutionProjectTargets(sln, solutionDir, isSlnx = false)) } @Test - fun `slnx parsing defaults the solution configurations when none are declared`() { - val mappings = parseSlnxProjectConfigurations("""""", solutionDir) - assertEquals(setOf("Debug|Any CPU", "Release|Any CPU"), mappings[normalizedPath(libProject)]!!.keys) + fun `sln project targets nest folders inside folders`() { + val nested = """ + Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{33333333-3333-3333-3333-333333333333}" + EndProject + Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "my.dir (x)", "my.dir (x)", "{44444444-4444-4444-4444-444444444444}" + EndProject + Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lib", "Lib\Lib.csproj", "{22222222-2222-2222-2222-222222222222}" + EndProject + Global + GlobalSection(NestedProjects) = preSolution + {44444444-4444-4444-4444-444444444444} = {33333333-3333-3333-3333-333333333333} + {22222222-2222-2222-2222-222222222222} = {44444444-4444-4444-4444-444444444444} + EndGlobalSection + EndGlobal + """.trimIndent() + assertEquals( + mapOf(normalizedPath(libProject) to "src\\my_dir _x_\\Lib"), + solutionProjectTargets(nested, solutionDir, isSlnx = false) + ) } @Test - fun `projects build of an slnx keeps a managed project on AnyCPU for an x64 solution`() { - val mappings = parseSlnxProjectConfigurations(slnx, solutionDir) - val build = projectsBuild(msBuild, solutionFile, listOf(libProject), "Debug", "x64", mappings) + fun `slnx project targets use folder paths and project file names`() { + val slnx = """ + + + + + + + """.trimIndent() assertEquals( - listOf(libProject, "-t:Build", "-p:Configuration=Debug", "-p:Platform=AnyCPU"), - build.commands.single().arguments.take(4) + mapOf(normalizedPath(libProject) to "src\\my_dir _x_\\Lib", normalizedPath(appProject) to "App"), + solutionProjectTargets(slnx, solutionDir, isSlnx = true) ) } @Test - fun `projects build falls back to the solution configuration without a mapping`() { - val build = projectsBuild(msBuild, solutionFile, listOf(appProject), "Release", "Any CPU", emptyMap()) + fun `projects build goes through the solution with one target per project`() { + // Through the solution, so MSBuild maps every project - and every project it references - + // to the solution's own configuration for it, instead of passing the selected one on. + val build = projectsBuild(msBuild, solutionFile, listOf(appProject, libProject), "Release", "x64", targets) + val command = build.commands.single() assertEquals( - listOf(appProject, "-t:Build", "-p:Configuration=Release", "-p:Platform=AnyCPU"), - build.commands.single().arguments.take(4) + listOf(solutionFile, "-t:src\\App;My_Lib", "-p:Configuration=Release", "-p:Platform=x64"), + command.arguments.take(4) ) + assertTrue(command.arguments.containsAll(COMMON_MSBUILD_ARGUMENTS)) + assertEquals(solutionDir.path, build.workingDirectory) } @Test fun `builds leave restore to Rider by default`() { val solution = solutionBuild(msBuild, solutionFile, DotNetBuildKind.BUILD_SOLUTION, "Debug", "Any CPU") - val projects = projectsBuild(msBuild, solutionFile, listOf(appProject), "Debug", "Any CPU", emptyMap()) + val projects = projectsBuild(msBuild, solutionFile, listOf(appProject), "Debug", "Any CPU", targets) assertFalse(solution.commands.single().arguments.contains(RESTORE_ARGUMENT)) assertFalse(projects.commands.single().arguments.contains(RESTORE_ARGUMENT)) } @@ -184,7 +158,7 @@ class MsBuildCommandTest { fun `builds restore when asked to`() { val solution = solutionBuild(msBuild, solutionFile, DotNetBuildKind.BUILD_SOLUTION, "Debug", "Any CPU", restore = true) val projects = - projectsBuild(msBuild, solutionFile, listOf(appProject), "Debug", "Any CPU", emptyMap(), restore = true) + projectsBuild(msBuild, solutionFile, listOf(appProject), "Debug", "Any CPU", targets, restore = true) assertTrue(solution.commands.single().arguments.contains(RESTORE_ARGUMENT)) assertTrue(projects.commands.single().arguments.contains(RESTORE_ARGUMENT)) } @@ -268,13 +242,6 @@ class MsBuildCommandTest { assertEquals(listOf(appProject, libProject), solutionProjectFiles(slnx, solutionDir)) } - @Test - fun `projectPlatformName only rewrites Any CPU`() { - assertEquals("AnyCPU", projectPlatformName("Any CPU")) - assertEquals("x64", projectPlatformName("x64")) - assertEquals("Mixed Platforms", projectPlatformName("Mixed Platforms")) - } - @Test fun `windows wrapper stops at the first failing command`() { val build = NativeBuild( From 272389e30e5741268dc65dff0aa26edbf10ee606 Mon Sep 17 00:00:00 2001 From: Anton Gorielikov Date: Sat, 17 Oct 2026 16:51:48 +0300 Subject: [PATCH 6/8] WIN-24578 :: Misc nit fixes --- CHANGELOG.md | 5 +- installer/install-common.ps1 | 11 +- installer/sfx-header.ps1 | 4 +- installer/standalone-header.ps1 | 4 +- scripts/install-intellij-ib-plugin.ps1 | 18 +-- .../ibplugin/actions/IncredibuildRunner.kt | 122 ++++++++++++++---- .../ibplugin/actions/dotnet/MsBuildLocator.kt | 19 +++ .../ibplugin/settings/IncredibuildSettings.kt | 9 +- .../actions/dotnet/MsBuildCommandTest.kt | 2 +- 9 files changed, 146 insertions(+), 48 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 176cda3..3e688d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,9 @@ ### 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 @@ -13,7 +16,7 @@ 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 Rider. +- The installers now also install the plugin into CLion and Rider. ## [1.0.3] diff --git a/installer/install-common.ps1 b/installer/install-common.ps1 index 26a3f1a..0baccd5 100644 --- a/installer/install-common.ps1 +++ b/installer/install-common.ps1 @@ -4,10 +4,11 @@ # install.ps1) via installer/build-installer.ps1 - edit this ONE file rather # than both generated scripts. -# RR = RustRover, IU = IntelliJ IDEA Ultimate, RD = Rider (the .NET actions - -# see rider-support.xml). Community editions (IC) don't carry +# RR = RustRover, IU = IntelliJ IDEA Ultimate, CL = CLion (the CMake actions - +# see cmake-support.xml), RD = Rider (the .NET actions - see +# rider-support.xml). Community editions (IC) don't carry # com.intellij.modules.ultimate, which the Rust plugin requires there. -$targetProductCodes = @("RR", "IU", "RD") +$targetProductCodes = @("RR", "IU", "CL", "RD") # Installs can land in quite a few places, so several roots are searched # recursively rather than assuming one fixed layout: @@ -31,7 +32,7 @@ $registryInstallLocations = @( } | ForEach-Object { Get-ItemProperty -Path $_.PSPath -ErrorAction SilentlyContinue } | Where-Object { - $_.DisplayName -match "RustRover|IntelliJ IDEA|Rider" -and $_.InstallLocation + $_.DisplayName -match "RustRover|IntelliJ IDEA|CLion|Rider" -and $_.InstallLocation } | ForEach-Object { $_.InstallLocation } | Select-Object -Unique $searchRoots = @( @@ -81,7 +82,7 @@ function Stop-InstallerTranscriptIfRunning { if (-not $installs) { $searched = ($searchRoots | Select-Object -Unique) -join "; " - $message = "No supported JetBrains IDE (RustRover, IntelliJ IDEA Ultimate or Rider) found. Searched: $searched." + $message = "No supported JetBrains IDE (RustRover, IntelliJ IDEA Ultimate, CLion or Rider) found. Searched: $searched." if ($allProducts) { $found = ($allProducts | ForEach-Object { "$($_.ProductName) [$($_.ProductCode)] at $($_.InfoPath)" }) -join "; " $message += " Found (but not supported by this plugin): $found." diff --git a/installer/sfx-header.ps1 b/installer/sfx-header.ps1 index de73806..6b47f6f 100644 --- a/installer/sfx-header.ps1 +++ b/installer/sfx-header.ps1 @@ -1,7 +1,7 @@ <# Installs (or updates) the Incredibuild Build Acceleration plugin into every -supported JetBrains IDE found on this machine (RustRover, and IntelliJ IDEA -Ultimate). Meant to be run from inside the self-extracting installer, +supported JetBrains IDE found on this machine (RustRover, IntelliJ IDEA +Ultimate, CLion, and Rider). Meant to be run from inside the self-extracting installer, alongside intellij-ib-plugin.zip. Detects installs by reading each product's own product-info.json rather than diff --git a/installer/standalone-header.ps1 b/installer/standalone-header.ps1 index 2defd0e..ef28994 100644 --- a/installer/standalone-header.ps1 +++ b/installer/standalone-header.ps1 @@ -1,8 +1,8 @@ <# .SYNOPSIS Installs (or updates) the "Incredibuild Build Acceleration" plugin into every -supported JetBrains IDE found on this machine (RustRover, and IntelliJ IDEA -Ultimate). +supported JetBrains IDE found on this machine (RustRover, IntelliJ IDEA +Ultimate, CLion, and Rider). .DESCRIPTION Fully self-contained: the plugin zip is embedded below as base64, so this is diff --git a/scripts/install-intellij-ib-plugin.ps1 b/scripts/install-intellij-ib-plugin.ps1 index 8db11a0..b8b7567 100644 --- a/scripts/install-intellij-ib-plugin.ps1 +++ b/scripts/install-intellij-ib-plugin.ps1 @@ -1,8 +1,8 @@ <# .SYNOPSIS Installs (or updates) the "Incredibuild Build Acceleration" plugin into every -supported JetBrains IDE found on this machine (RustRover, and IntelliJ IDEA -Ultimate). +supported JetBrains IDE found on this machine (RustRover, IntelliJ IDEA +Ultimate, CLion, and Rider). .DESCRIPTION Fully self-contained: the plugin zip is embedded below as base64, so this is @@ -30,9 +30,11 @@ $ErrorActionPreference = "Stop" # install.ps1) via installer/build-installer.ps1 - edit this ONE file rather # than both generated scripts. -# RR = RustRover, IU = IntelliJ IDEA Ultimate. Community editions (IC) don't -# carry com.intellij.modules.ultimate, which the Rust plugin requires there. -$targetProductCodes = @("RR", "IU") +# RR = RustRover, IU = IntelliJ IDEA Ultimate, CL = CLion (the CMake actions - +# see cmake-support.xml), RD = Rider (the .NET actions - see +# rider-support.xml). Community editions (IC) don't carry +# com.intellij.modules.ultimate, which the Rust plugin requires there. +$targetProductCodes = @("RR", "IU", "CL", "RD") # Installs can land in quite a few places, so several roots are searched # recursively rather than assuming one fixed layout: @@ -56,7 +58,7 @@ $registryInstallLocations = @( } | ForEach-Object { Get-ItemProperty -Path $_.PSPath -ErrorAction SilentlyContinue } | Where-Object { - $_.DisplayName -match "RustRover|IntelliJ IDEA" -and $_.InstallLocation + $_.DisplayName -match "RustRover|IntelliJ IDEA|CLion|Rider" -and $_.InstallLocation } | ForEach-Object { $_.InstallLocation } | Select-Object -Unique $searchRoots = @( @@ -106,7 +108,7 @@ function Stop-InstallerTranscriptIfRunning { if (-not $installs) { $searched = ($searchRoots | Select-Object -Unique) -join "; " - $message = "No supported JetBrains IDE (RustRover or IntelliJ IDEA Ultimate) found. Searched: $searched." + $message = "No supported JetBrains IDE (RustRover, IntelliJ IDEA Ultimate, CLion or Rider) found. Searched: $searched." if ($allProducts) { $found = ($allProducts | ForEach-Object { "$($_.ProductName) [$($_.ProductCode)] at $($_.InfoPath)" }) -join "; " $message += " Found (but not supported by this plugin): $found." @@ -129,7 +131,7 @@ if ($anyRunning) { } $pluginZipBase64 = @' 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 '@ $tempZip = Join-Path $env:TEMP "intellij-ib-plugin-install.zip" diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt index 291ff81..1f5168a 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt @@ -201,10 +201,7 @@ object IncredibuildRunner { ) { when (val prepared = prepareBuild(project, installFolder, cargoCommand, workingDirectory)) { is PreparedBuild.Failed -> showErrorOnEdt(project, prepared.message) - is PreparedBuild.Ready -> launchBuild(project, prepared.commandLine, actionType) { exitCode -> - prepared.cleanUp() - onFinished?.invoke(exitCode) - } + is PreparedBuild.Ready -> launchBuild(project, prepared, actionType, onFinished = onFinished) } } @@ -375,27 +372,38 @@ object IncredibuildRunner { return PreparedBuild.Ready(commandLine) { scriptFile.delete() } } + /** + * Runs [prepared] in the Incredibuild tool window - unless another build is still running + * (see [run]) - and deletes its temporary scripts once it ends, or straight away if it + * never starts. [onFinished] is only called for a build that actually ran. + */ private fun launchBuild( project: Project, - commandLine: GeneralCommandLine, + prepared: PreparedBuild.Ready, actionType: String, presentation: AcceleratedBuildPresentation? = null, - onFinished: (exitCode: Int) -> Unit + onFinished: ((exitCode: Int) -> Unit)? = null ) { - PostHogClient.capture("build_started", mapOf("action" to actionType)) - PostHogClient.captureOnce( - "com.incredibuild.ibplugin.analytics.firstBuildSent", - "first_build", - mapOf("action" to actionType) - ) - ApplicationManager.getApplication().invokeLater { val processHandler = run( project, - commandLine, + prepared.commandLine, presentation?.contentName ?: "Build", - presentation?.banner, - onFinished + presentation?.banner + ) { exitCode -> + prepared.cleanUp() + onFinished?.invoke(exitCode) + } + if (processHandler == null) { + prepared.cleanUp() + return@invokeLater + } + + PostHogClient.capture("build_started", mapOf("action" to actionType)) + PostHogClient.captureOnce( + "com.incredibuild.ibplugin.analytics.firstBuildSent", + "first_build", + mapOf("action" to actionType) ) if (presentation != null) { trackInStatusBar(project, processHandler, presentation) @@ -419,17 +427,21 @@ object IncredibuildRunner { override fun run(indicator: ProgressIndicator) { indicator.isIndeterminate = true indicator.text = presentation.progressTitle - var stopRequested = false + var cancelHandled = false while (!processHandler.waitFor(STATUS_POLL_INTERVAL_MS)) { - if (indicator.isCanceled && !stopRequested) { - stopRequested = true - indicator.text = "Stopping Incredibuild build..." + if (indicator.isCanceled && !cancelHandled) { + cancelHandled = true processHandler.destroyProcess() } + // Also reflects a stop from Stop Build or the tool window, not just this + // progress's own cancel button. + if (processHandler.wasStopRequested()) { + indicator.text = "Stopping Incredibuild build..." + } } val exitCode = processHandler.exitCode val (content, type) = when { - stopRequested -> "${presentation.contentName} was stopped." to NotificationType.INFORMATION + processHandler.wasStopRequested() -> "${presentation.contentName} was stopped." to NotificationType.INFORMATION exitCode == 0 -> "${presentation.contentName} succeeded." to NotificationType.INFORMATION else -> "${presentation.contentName} failed (exit code $exitCode). See the Incredibuild tool window for details." to NotificationType.ERROR @@ -465,6 +477,9 @@ object IncredibuildRunner { * the build was started from there (see [IncredibuildProjectTaskRunner]). * * [banner], if given, is printed at the top of the console before any build output. + * + * Must be called on the EDT. Returns null, without starting anything or calling + * [onFinished], if another build is still running - see [confirmNoBuildRunning]. */ fun run( project: Project, @@ -472,7 +487,8 @@ object IncredibuildRunner { contentName: String, banner: String? = null, onFinished: ((exitCode: Int) -> Unit)? = null - ): OSProcessHandler { + ): OSProcessHandler? { + if (!confirmNoBuildRunning(project)) return null val processHandler = createProcessHandler(commandLine) val console = ConsoleViewImpl(project, true) @@ -557,9 +573,14 @@ object IncredibuildRunner { */ private class ColoredIncredibuildProcessHandler( commandLine: GeneralCommandLine - ) : ColoredProcessHandler(commandLine) { + ) : ColoredProcessHandler(commandLine), IncredibuildProcessHandler { + + @Volatile + override var stopRequested = false + private set override fun destroyProcessImpl() { + stopRequested = true if (!requestGracefulStop()) super.destroyProcessImpl() } } @@ -582,17 +603,36 @@ object IncredibuildRunner { */ private class RawIncredibuildProcessHandler( commandLine: GeneralCommandLine - ) : KillableProcessHandler(commandLine) { + ) : KillableProcessHandler(commandLine), IncredibuildProcessHandler { + + @Volatile + override var stopRequested = false + private set override fun destroyProcessImpl() { + stopRequested = true if (!requestGracefulStop()) super.destroyProcessImpl() } override fun killProcess() { + stopRequested = true if (!requestGracefulStop()) super.killProcess() } } + /** + * Implemented by both handlers above, so whoever reports a build's outcome can tell a build + * that was stopped from one that failed. Every stop route - Stop Build, the tool windows' own + * stop buttons, cancelling the status-bar progress - ends in [destroyProcessImpl] or + * `killProcess` on the handler, which is where it's recorded; a stopped build's exit code + * alone (-1, or whatever Incredibuild exits with when cancelled) looks just like a failure. + */ + private interface IncredibuildProcessHandler { + val stopRequested: Boolean + } + + private fun OSProcessHandler.wasStopRequested(): Boolean = (this as? IncredibuildProcessHandler)?.stopRequested == true + /** * Asks Incredibuild to cancel the running build by build-id, returning false if there * is no build-id to cancel by or the request could not be dispatched - in which case @@ -619,6 +659,32 @@ object IncredibuildRunner { * by [StopBuildAction] to disable itself when there's nothing to stop. */ fun isBuildRunning(): Boolean = activeProcessHandler?.isProcessTerminated == false + /** + * One build at a time: returns true if nothing is running, otherwise offers to stop the + * running build and returns false - the new one isn't started either way, so the two never + * overlap while the old one winds down. Without this, a second build replaces the first one's + * tool window tab (its output disappears while it's still running) and becomes the only one + * Stop Build can reach; and while Windows' BuildConsole would queue it behind the first + * ("Waiting for a build to complete..."), nothing guarantees ib_console does the same. + * + * Checked in [run], on the EDT, right where the build is registered as the active one - so + * two quick clicks can't both get past it. A Rebuild's chained build is unaffected: its clean + * has already ended by the time the build starts. + */ + private fun confirmNoBuildRunning(project: Project): Boolean { + if (!isBuildRunning()) return true + val stop = Messages.showYesNoDialog( + project, + "An Incredibuild build is already running. Stop it before starting another one.", + "Incredibuild", + "Stop Running Build", + "Cancel", + Messages.getWarningIcon() + ) == Messages.YES + if (stop) stopActiveProcess(project) + return false + } + /** * Stops whichever build/clean process is currently running, if any. * @@ -725,9 +791,7 @@ object IncredibuildRunner { ) { when (val prepared = prepareNativeBuild(project, installFolder, build)) { is PreparedBuild.Failed -> showErrorOnEdt(project, prepared.message) - is PreparedBuild.Ready -> launchBuild(project, prepared.commandLine, actionType, presentation) { _ -> - prepared.cleanUp() - } + is PreparedBuild.Ready -> launchBuild(project, prepared, actionType, presentation) } } @@ -856,7 +920,9 @@ object IncredibuildRunner { } cmdLines.append("\r\n") if (index < build.commands.lastIndex) { - cmdLines.append("if errorlevel 1 exit /b %ERRORLEVEL%\r\n") + // Not "if errorlevel 1": that only matches codes >= 1, and a crashed process's + // exit code (e.g. 0xC0000005) reads as negative, which would let the chain go on. + cmdLines.append("if not \"%ERRORLEVEL%\"==\"0\" exit /b %ERRORLEVEL%\r\n") } } cmdLines.append("exit /b %ERRORLEVEL%\r\n") diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt index f06954a..24aa626 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildLocator.kt @@ -64,6 +64,20 @@ internal sealed interface MsBuildLocation { */ internal object MsBuildLocator { + /** + * What [detect] last found, so a build doesn't pay for vswhere (up to [VSWHERE_TIMEOUT_MS]) + * every time. Kept for the session, but dropped by [clearCache] when the MSBuild setting + * changes, and re-detected if the executable has since disappeared (e.g. Visual Studio was + * uninstalled). "Not found" is never cached, so installing MSBuild takes effect on the next + * build without restarting the IDE. + */ + @Volatile + private var detected: MsBuildTool? = null + + fun clearCache() { + detected = null + } + fun locate(): MsBuildLocation { val configured = IncredibuildSettings.getInstance().msBuildPath if (configured.isNotBlank()) { @@ -76,6 +90,11 @@ internal object MsBuildLocator { } } + detected?.takeIf { File(it.executable).isFile }?.let { return MsBuildLocation.Found(it) } + return detect().also { if (it is MsBuildLocation.Found) detected = it.tool } + } + + private fun detect(): MsBuildLocation { if (SystemInfo.isWindows) { findVisualStudioMsBuild(MSBUILD_COMPONENT, DOTNET_SDK_COMPONENT) ?.let { return MsBuildLocation.Found(MsBuildTool(it, emptyList(), it)) } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt index addefe5..f17f02e 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt @@ -15,6 +15,7 @@ */ package com.incredibuild.ibplugin.settings +import com.incredibuild.ibplugin.actions.dotnet.MsBuildLocator import com.intellij.openapi.application.ApplicationManager import com.intellij.openapi.components.PersistentStateComponent import com.intellij.openapi.components.Service @@ -66,7 +67,13 @@ class IncredibuildSettings : PersistentStateComponent Date: Wed, 21 Oct 2026 17:29:14 +0300 Subject: [PATCH 7/8] WIN-24578 :: Fix small comments --- .github/workflows/release.yml | 35 +++ CHANGELOG.md | 24 ++ README.md | 26 +- build.gradle.kts | 56 +++- gradle.properties | 2 +- .../pluginVerifier-ignoredProblems-rider.txt | 12 + ...ginVerifier-ignoredProblems-rustrover.txt} | 18 +- installer/README.md | 19 +- installer/build-installer.ps1 | 69 +++-- installer/install-common.ps1 | 2 +- .../IncredibuildBeforeRunTaskProviders.kt | 117 ++++++++ .../ibplugin/rider/RiderBuildInterceptor.kt | 42 +++ scripts/install-intellij-ib-plugin.ps1 | 157 ----------- .../ibplugin/actions/IdeBuildAcceleration.kt | 125 +++++++++ .../actions/IncredibuildInstallation.kt | 163 +++++++++++ .../ibplugin/actions/IncredibuildLocator.kt | 4 +- .../actions/IncredibuildProjectTaskRunner.kt | 26 +- .../ibplugin/actions/IncredibuildRunner.kt | 252 ++++++++++++----- .../actions/cmake/CMakeBuildCommand.kt | 52 +++- .../IncredibuildCMakeProjectTaskRunner.kt | 265 ++++++++++++++++++ .../actions/dotnet/DotNetBuildActions.kt | 58 ++-- .../actions/dotnet/DotNetBuildRunner.kt | 212 ++++++++++---- .../actions/dotnet/DotNetIdeBuilds.kt | 128 +++++++++ .../ibplugin/actions/dotnet/MsBuildCommand.kt | 21 +- .../settings/IncredibuildConfigurable.kt | 67 ++++- .../ibplugin/settings/IncredibuildSettings.kt | 6 +- src/main/resources/META-INF/cmake-support.xml | 10 + src/main/resources/META-INF/plugin.xml | 2 +- src/main/resources/META-INF/rider-support.xml | 17 ++ .../actions/IncredibuildInstallationTest.kt | 56 ++++ .../actions/dotnet/MsBuildCommandTest.kt | 80 ++++++ 31 files changed, 1741 insertions(+), 382 deletions(-) create mode 100644 gradle/pluginVerifier-ignoredProblems-rider.txt rename gradle/{pluginVerifier-ignoredProblems.txt => pluginVerifier-ignoredProblems-rustrover.txt} (56%) create mode 100644 rider/src/main/kotlin/com/incredibuild/ibplugin/rider/IncredibuildBeforeRunTaskProviders.kt create mode 100644 rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderBuildInterceptor.kt delete mode 100644 scripts/install-intellij-ib-plugin.ps1 create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/IdeBuildAcceleration.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildInstallation.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/IncredibuildCMakeProjectTaskRunner.kt create mode 100644 src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetIdeBuilds.kt create mode 100644 src/test/kotlin/com/incredibuild/ibplugin/actions/IncredibuildInstallationTest.kt diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d725f9b..4302f8a 100644 --- a/.github/workflows/release.yml +++ b/.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 diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e688d4..aab00dc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ ## [Unreleased] +## [1.1.0] + ### Added - CLion support for CMake projects: **Build**, **Rebuild** and **Build All** in the **Incredibuild** menu run @@ -17,6 +19,28 @@ - **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] diff --git a/README.md b/README.md index 89c56da..5e049d1 100644 --- a/README.md +++ b/README.md @@ -24,14 +24,24 @@ 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) diff --git a/build.gradle.kts b/build.gradle.kts index f91bcf4..2f07390 100644 --- a/build.gradle.kts +++ b/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") @@ -110,14 +111,16 @@ 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") @@ -131,6 +134,55 @@ intellijPlatform { } } +// 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}")) + } + if (taskName == "verifyPlugin") { + tasks.named(taskName, configure) + } else { + tasks.register(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 // ) - there's nothing to manually exercise there. Add a diff --git a/gradle.properties b/gradle.properties index 2b55b6c..18ab9c2 100644 --- a/gradle.properties +++ b/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 diff --git a/gradle/pluginVerifier-ignoredProblems-rider.txt b/gradle/pluginVerifier-ignoredProblems-rider.txt new file mode 100644 index 0000000..5b5f092 --- /dev/null +++ b/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 diff --git a/gradle/pluginVerifier-ignoredProblems.txt b/gradle/pluginVerifier-ignoredProblems-rustrover.txt similarity index 56% rename from gradle/pluginVerifier-ignoredProblems.txt rename to gradle/pluginVerifier-ignoredProblems-rustrover.txt index 229d987..8f01029 100644 --- a/gradle/pluginVerifier-ignoredProblems.txt +++ b/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 // ":" or just "". No version field, so these keep applying across @@ -11,17 +12,8 @@ // (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 com.incredibuild.ibplugin:Access to unresolved class com\.jetbrains\.cidr\.cpp\.execution\.CMakeAppRunConfiguration -// -// The line below is the same 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 lines above -// don't apply to Rider: it bundles com.intellij.cmake itself.) -com.incredibuild.ibplugin:Package 'org\.rust' is not found diff --git a/installer/README.md b/installer/README.md index 8fc2eb0..3be25fc 100644 --- a/installer/README.md +++ b/installer/README.md @@ -2,12 +2,16 @@ Produces both distributable installers from `build/distributions/intellij-ib-plugin.zip`: -- `scripts/install-intellij-ib-plugin.ps1` - a single, self-contained PowerShell - script (the plugin zip is embedded as base64) for anyone who'd rather not run - an unsigned `.exe`. +- `build/distributions/install-intellij-ib-plugin.ps1` - a single, self-contained + PowerShell script (the plugin zip is embedded as base64) for anyone who'd + rather not run an unsigned `.exe`. - `build/distributions/intellij-ib-plugin.exe` - a self-extracting installer with zero visible windows, for double-click installs. +Neither is committed to the repo. Publishing a GitHub release runs the +**Release** workflow, whose `installers` job builds both on a Windows runner from +the exact plugin zip the release published, and attaches them to the release. + ## Usage ``` @@ -19,6 +23,13 @@ This runs `.\gradlew.bat buildPlugin` itself first, so source before either installer is packaged - it can never silently package a stale zip left over from an earlier build. +To package an already-built zip instead (what the release workflow does), pass it +with `-PluginZip`: + +``` +powershell -ExecutionPolicy Bypass -File .\installer\build-installer.ps1 -PluginZip path\to\intellij-ib-plugin.zip +``` + Prerequisites (both are standard on a Windows dev machine, neither is bundled): - **7-Zip** (`7z.exe` on `PATH`, or installed at `C:\Program Files\7-Zip`) - used @@ -36,7 +47,7 @@ plugin zip and report progress: | | `install-common.ps1` sandwiched between... | plugin zip | output | |---|---|---|---| -| Standalone script | `standalone-header.ps1` / `standalone-footer.ps1` | embedded as base64 | `scripts/install-intellij-ib-plugin.ps1` (committed to the repo) | +| Standalone script | `standalone-header.ps1` / `standalone-footer.ps1` | embedded as base64 | `build/distributions/install-intellij-ib-plugin.ps1` (attached to each GitHub release) | | SFX installer | `sfx-header.ps1` / `sfx-footer.ps1` | packaged alongside as a sibling file | assembled at build time, only shipped inside the `.exe` | ### The `.exe`'s pieces diff --git a/installer/build-installer.ps1 b/installer/build-installer.ps1 index 7811b3f..81b5960 100644 --- a/installer/build-installer.ps1 +++ b/installer/build-installer.ps1 @@ -1,7 +1,7 @@ <# .SYNOPSIS -Builds both distributable installers from the current build/distributions/intellij-ib-plugin.zip: - - scripts/install-intellij-ib-plugin.ps1 (self-contained, base64-embedded script) +Builds both distributable installers from the plugin zip: + - build/distributions/install-intellij-ib-plugin.ps1 (self-contained, base64-embedded script) - build/distributions/intellij-ib-plugin.exe (self-extracting installer, zero visible windows) .DESCRIPTION @@ -9,45 +9,68 @@ Just run this script - it runs `.\gradlew buildPlugin` itself first, so build/distributions/intellij-ib-plugin.zip is always current: powershell -ExecutionPolicy Bypass -File .\installer\build-installer.ps1 +Neither output is committed: the release workflow (.github/workflows/release.yml) runs this +with -PluginZip pointing at the zip it just published, so the installers attached to a GitHub +release always carry exactly that build. + +.PARAMETER PluginZip +An already-built plugin zip to package, instead of running `gradlew buildPlugin`. + Both generated scripts share the IDE-detection/validation logic in install-common.ps1 (edit that ONE file for both, rather than either generated script directly - regenerate by re-running this script). See installer/README.md for the full pipeline explanation and prerequisites. #> +param( + [string]$PluginZip +) + $ErrorActionPreference = "Stop" $installerDir = $PSScriptRoot $repoRoot = Split-Path -Parent $installerDir -$pluginZip = Join-Path $repoRoot "build\distributions\intellij-ib-plugin.zip" -$standaloneScriptOut = Join-Path $repoRoot "scripts\install-intellij-ib-plugin.ps1" -$exeOut = Join-Path $repoRoot "build\distributions\intellij-ib-plugin.exe" +$outDir = Join-Path $repoRoot "build\distributions" +$standaloneScriptOut = Join-Path $outDir "install-intellij-ib-plugin.ps1" +$exeOut = Join-Path $outDir "intellij-ib-plugin.exe" # --- 0. Rebuild the plugin so the zip can never be stale ------------------- -$gradlew = Join-Path $repoRoot "gradlew.bat" -if (-not (Test-Path $gradlew)) { - Write-Error "$gradlew not found - expected at the repo root." - exit 1 -} +if ($PluginZip) { + if (-not (Test-Path $PluginZip)) { + Write-Error "$PluginZip not found." + exit 1 + } + $pluginZip = (Resolve-Path $PluginZip).Path +} else { + $pluginZip = Join-Path $outDir "intellij-ib-plugin.zip" -Write-Host "Running '.\gradlew.bat buildPlugin' ..." -Push-Location $repoRoot -try { - & $gradlew buildPlugin --console=plain - if ($LASTEXITCODE -ne 0) { - Write-Error "gradlew buildPlugin failed (exit $LASTEXITCODE)." + $gradlew = Join-Path $repoRoot "gradlew.bat" + if (-not (Test-Path $gradlew)) { + Write-Error "$gradlew not found - expected at the repo root." exit 1 } -} finally { - Pop-Location -} -if (-not (Test-Path $pluginZip)) { - Write-Error "$pluginZip still not found after 'gradlew buildPlugin' - check the buildPlugin task's output archive name/path." - exit 1 + Write-Host "Running '.\gradlew.bat buildPlugin' ..." + Push-Location $repoRoot + try { + & $gradlew buildPlugin --console=plain + if ($LASTEXITCODE -ne 0) { + Write-Error "gradlew buildPlugin failed (exit $LASTEXITCODE)." + exit 1 + } + } finally { + Pop-Location + } + + if (-not (Test-Path $pluginZip)) { + Write-Error "$pluginZip still not found after 'gradlew buildPlugin' - check the buildPlugin task's output archive name/path." + exit 1 + } } +New-Item -ItemType Directory -Path $outDir -Force | Out-Null + # --- Locate prerequisites --------------------------------------------------- $sevenZip = Get-Command "7z.exe" -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Source @@ -86,7 +109,7 @@ try { exit 1 } - # --- 2. Assemble scripts/install-intellij-ib-plugin.ps1 (standalone) --- + # --- 2. Assemble install-intellij-ib-plugin.ps1 (standalone) ----------- Write-Host "Assembling $standaloneScriptOut ..." $pluginZipBase64 = [System.Convert]::ToBase64String([System.IO.File]::ReadAllBytes($pluginZip)) diff --git a/installer/install-common.ps1 b/installer/install-common.ps1 index 0baccd5..3f09292 100644 --- a/installer/install-common.ps1 +++ b/installer/install-common.ps1 @@ -1,5 +1,5 @@ # Shared by both installer/standalone-footer.ps1 (assembled into the -# self-contained scripts/install-intellij-ib-plugin.ps1) and +# self-contained install-intellij-ib-plugin.ps1) and # installer/sfx-footer.ps1 (assembled into the SFX installer's own # install.ps1) via installer/build-installer.ps1 - edit this ONE file rather # than both generated scripts. diff --git a/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/IncredibuildBeforeRunTaskProviders.kt b/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/IncredibuildBeforeRunTaskProviders.kt new file mode 100644 index 0000000..f34fe00 --- /dev/null +++ b/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/IncredibuildBeforeRunTaskProviders.kt @@ -0,0 +1,117 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.rider + +import com.intellij.execution.BeforeRunTask +import com.intellij.execution.BeforeRunTaskProvider +import com.intellij.execution.configurations.RunConfiguration +import com.intellij.execution.runners.ExecutionEnvironment +import com.intellij.openapi.actionSystem.DataContext +import com.intellij.openapi.diagnostic.Logger +import com.intellij.openapi.util.Key +import com.jetbrains.rider.build.tasks.BuildProjectBeforeRunTask +import com.jetbrains.rider.build.tasks.BuildProjectBeforeRunTaskProvider +import com.jetbrains.rider.build.tasks.BuildSolutionBeforeRunTask +import com.jetbrains.rider.build.tasks.BuildSolutionBeforeRunTaskProvider +import com.jetbrains.rider.run.configurations.IProjectBasedRunConfiguration +import com.jetbrains.rider.run.configurations.multiPlatform.RiderMultiPlatformConfiguration +import org.jetbrains.concurrency.Promise +import javax.swing.Icon + +private val LOG = Logger.getInstance("com.incredibuild.ibplugin.rider.IncredibuildBeforeRunTaskProviders") + +/** + * Stands in for one of Rider's own before-run build steps, so the build that runs before a run + * configuration starts can go through Incredibuild. + * + * Rider offers no hook into that build - its providers hand it straight to the ReSharper backend + * (`BuildTaskThrottler`/`BuildHost`, both final) - so this is registered with Rider's provider's own + * [Key] and order="first" (rider-support.xml): the platform runs a before-run task with the first + * provider registered for its key (`BeforeRunTaskProvider.getProvider`), so it reaches this one. + * Everything else is left to Rider's provider, so existing run configurations, their saved + * before-run steps and the step's editor are untouched: + * - [createTask] returns null, which keeps this provider out of the "Add before-run task" list and + * out of the default steps a new run configuration gets (both skip a provider that creates + * nothing) - Rider's provider still creates every task, and loading a saved step resolves to it + * as well (the platform's id-to-provider map keeps the last one registered); + * - presentation and configuration are delegated to [rider]; + * - [executeTask] asks [RiderBuildInterceptor] to build, and hands the task back to Rider's own + * provider whenever that declines (the setting is off, Incredibuild is unavailable, ...). + */ +abstract class IncredibuildBeforeRunTaskProvider> : BeforeRunTaskProvider() { + + /** Rider's own provider. Stateless, so a private instance behaves exactly like the registered one. */ + protected abstract val rider: BeforeRunTaskProvider + + /** The project to build for [configuration]/[task], or null for the whole solution. */ + protected abstract fun projectFile(configuration: RunConfiguration, task: T): String? + + override fun getId(): Key = rider.id + + override fun getName(): String = rider.name + + override fun getIcon(): Icon? = rider.icon + + override fun getTaskIcon(task: T): Icon? = rider.getTaskIcon(task) + + override fun getDescription(task: T): String = rider.getDescription(task) + + override fun isConfigurable(): Boolean = rider.isConfigurable + + override fun configureTask(context: DataContext, configuration: RunConfiguration, task: T): Promise = + rider.configureTask(context, configuration, task) + + override fun createTask(runConfiguration: RunConfiguration): T? = null + + override fun canExecuteTask(configuration: RunConfiguration, task: T): Boolean = + rider.canExecuteTask(configuration, task) + + override fun executeTask( + context: DataContext, + configuration: RunConfiguration, + environment: ExecutionEnvironment, + task: T + ): Boolean { + val accelerated = try { + RiderBuildInterceptor.getInstance()?.buildBeforeRun(configuration.project, projectFile(configuration, task)) + } catch (e: Exception) { + LOG.warn("Incredibuild before-run build failed to start; falling back to Rider's build", e) + null + } + return accelerated ?: rider.executeTask(context, configuration, environment, task) + } +} + +/** Rider's default "Build Project" before-run step - builds the run configuration's project. */ +class IncredibuildBuildProjectBeforeRunTaskProvider : IncredibuildBeforeRunTaskProvider() { + + override val rider = BuildProjectBeforeRunTaskProvider() + + /** Resolved the way Rider's own provider resolves it: the step's own project, else the run configuration's. */ + override fun projectFile(configuration: RunConfiguration, task: BuildProjectBeforeRunTask): String? = + task.selectedProject?.path?.toString() + ?: (configuration as? RiderMultiPlatformConfiguration)?.parameters?.projectFilePath?.value + ?: (configuration as? IProjectBasedRunConfiguration)?.getProjectFilePath() + ?: throw IllegalStateException("No project to build for ${configuration.name}") +} + +/** Rider's "Build Solution" before-run step. */ +class IncredibuildBuildSolutionBeforeRunTaskProvider : IncredibuildBeforeRunTaskProvider() { + + override val rider = BuildSolutionBeforeRunTaskProvider() + + override fun projectFile(configuration: RunConfiguration, task: BuildSolutionBeforeRunTask): String? = null +} diff --git a/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderBuildInterceptor.kt b/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderBuildInterceptor.kt new file mode 100644 index 0000000..6757648 --- /dev/null +++ b/rider/src/main/kotlin/com/incredibuild/ibplugin/rider/RiderBuildInterceptor.kt @@ -0,0 +1,42 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.rider + +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.project.Project + +/** + * Takes over the build Rider runs before a run configuration starts - see + * [IncredibuildBuildProjectBeforeRunTaskProvider]. Declared here, implemented in the root module + * (which owns Incredibuild and MSBuild), and wired together as an application service in + * rider-support.xml - this module can't call into the root module directly, since the root module + * depends on it. + */ +interface RiderBuildInterceptor { + + /** + * Builds [projectFile] (and the projects it references) - or the whole solution when null - + * through Incredibuild, blocking until it ends. Returns whether it succeeded, or null to let + * Rider build it as usual instead (the setting is off, Incredibuild is unavailable, ...). + * Called off the EDT. + */ + fun buildBeforeRun(project: Project, projectFile: String?): Boolean? + + companion object { + fun getInstance(): RiderBuildInterceptor? = + ApplicationManager.getApplication().getService(RiderBuildInterceptor::class.java) + } +} diff --git a/scripts/install-intellij-ib-plugin.ps1 b/scripts/install-intellij-ib-plugin.ps1 deleted file mode 100644 index b8b7567..0000000 --- a/scripts/install-intellij-ib-plugin.ps1 +++ /dev/null @@ -1,157 +0,0 @@ -<# -.SYNOPSIS -Installs (or updates) the "Incredibuild Build Acceleration" plugin into every -supported JetBrains IDE found on this machine (RustRover, IntelliJ IDEA -Ultimate, CLion, and Rider). - -.DESCRIPTION -Fully self-contained: the plugin zip is embedded below as base64, so this is -the only file needed. Run it with: - powershell -ExecutionPolicy Bypass -File .\install-intellij-ib-plugin.ps1 - -Detects installs by reading each product's own product-info.json rather than -guessing the config folder name from the install folder's display name - -that heuristic does NOT generalize across products (e.g. RustRover's config -folder is "RustRover2026.2", a simple space-strip of its install folder name, -but IntelliJ IDEA Ultimate's is "IntelliJIdea2026.2", which does not follow -the same pattern at all). - -All detected target IDEs must be closed before running this script - it will -refuse to proceed otherwise, since IntelliJ Platform IDEs load plugins at -startup and don't reliably pick up a plugin folder replaced while already -running. -#> - -$ErrorActionPreference = "Stop" - -# Shared by both installer/standalone-footer.ps1 (assembled into the -# self-contained scripts/install-intellij-ib-plugin.ps1) and -# installer/sfx-footer.ps1 (assembled into the SFX installer's own -# install.ps1) via installer/build-installer.ps1 - edit this ONE file rather -# than both generated scripts. - -# RR = RustRover, IU = IntelliJ IDEA Ultimate, CL = CLion (the CMake actions - -# see cmake-support.xml), RD = Rider (the .NET actions - see -# rider-support.xml). Community editions (IC) don't carry -# com.intellij.modules.ultimate, which the Rust plugin requires there. -$targetProductCodes = @("RR", "IU", "CL", "RD") - -# Installs can land in quite a few places, so several roots are searched -# recursively rather than assuming one fixed layout: -# - "C:\Program Files\JetBrains\" - the standalone installer's -# default when run elevated. -# - "%LOCALAPPDATA%\JetBrains\..." - covers both JetBrains Toolbox (which -# nests several levels deeper, under "Toolbox\apps\\ch-0\") -# and the standalone installer's own default when run WITHOUT admin -# rights, which silently falls back to a per-user install here instead -# of Program Files. -# - Whatever the Windows registry's own Uninstall entries report as the -# InstallLocation for a matching product - the authoritative source for -# a custom install path (e.g. a different drive), which no fixed-path -# guess can anticipate. -$registryInstallLocations = @( - "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", - "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall", - "HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall" -) | Where-Object { Test-Path $_ } | ForEach-Object { - Get-ChildItem -Path $_ -ErrorAction SilentlyContinue -} | ForEach-Object { - Get-ItemProperty -Path $_.PSPath -ErrorAction SilentlyContinue -} | Where-Object { - $_.DisplayName -match "RustRover|IntelliJ IDEA|CLion|Rider" -and $_.InstallLocation -} | ForEach-Object { $_.InstallLocation } | Select-Object -Unique - -$searchRoots = @( - "C:\Program Files\JetBrains", - (Join-Path $env:LOCALAPPDATA "JetBrains") -) + $registryInstallLocations - -# Every JetBrains product found (any productCode), so a "not found" error can -# report what actually IS here - e.g. a Community edition, which is filtered -# out below but is useful to see rather than a bare "nothing found". -$allProducts = $searchRoots | Where-Object { Test-Path $_ } | ForEach-Object { - Get-ChildItem -Path $_ -Recurse -Filter "product-info.json" -ErrorAction SilentlyContinue -} | ForEach-Object { - $infoPath = $_.FullName - try { - $info = Get-Content $infoPath -Raw | ConvertFrom-Json - } catch { - return - } - [PSCustomObject]@{ - InfoPath = $infoPath - ProductName = $info.name - ProductCode = $info.productCode - DataDirectoryName = $info.dataDirectoryName - Launch = $info.launch - } -} - -$installs = $allProducts | Where-Object { $targetProductCodes -contains $_.ProductCode } | ForEach-Object { - $product = $_ - $winLaunch = $product.Launch | Where-Object { $_.os -eq "Windows" } | Select-Object -First 1 - if (-not $winLaunch) { return } - - [PSCustomObject]@{ - Name = Split-Path -Leaf (Split-Path -Parent $product.InfoPath) - DataDirectoryName = $product.DataDirectoryName - ProcessName = [System.IO.Path]::GetFileNameWithoutExtension($winLaunch.launcherPath) - } -} | Sort-Object -Property DataDirectoryName -Unique - -# A no-op if no transcript is running (Start-Transcript is only called in the -# SFX installer's copy of this logic, not the standalone script's), safe to -# call unconditionally from both under $ErrorActionPreference = "Stop". -function Stop-InstallerTranscriptIfRunning { - try { Stop-Transcript | Out-Null } catch {} -} - -if (-not $installs) { - $searched = ($searchRoots | Select-Object -Unique) -join "; " - $message = "No supported JetBrains IDE (RustRover, IntelliJ IDEA Ultimate, CLion or Rider) found. Searched: $searched." - if ($allProducts) { - $found = ($allProducts | ForEach-Object { "$($_.ProductName) [$($_.ProductCode)] at $($_.InfoPath)" }) -join "; " - $message += " Found (but not supported by this plugin): $found." - } - Write-Error $message - Stop-InstallerTranscriptIfRunning - exit 1 -} - -$anyRunning = $false -foreach ($install in $installs) { - if (Get-Process -Name $install.ProcessName -ErrorAction SilentlyContinue) { - Write-Error "$($install.Name) is currently running. Close it, then re-run this installer." - $anyRunning = $true - } -} -if ($anyRunning) { - Stop-InstallerTranscriptIfRunning - exit 1 -} - -$pluginZipBase64 = @' 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 -'@ - -$tempZip = Join-Path $env:TEMP "intellij-ib-plugin-install.zip" -$pluginZipBytes = [System.Convert]::FromBase64String(($pluginZipBase64 -replace '\s', '')) -[System.IO.File]::WriteAllBytes($tempZip, $pluginZipBytes) - -foreach ($install in $installs) { - $pluginsDir = Join-Path $env:APPDATA "JetBrains\$($install.DataDirectoryName)\plugins" - if (-not (Test-Path $pluginsDir)) { - New-Item -ItemType Directory -Path $pluginsDir -Force | Out-Null - } - - $targetPluginDir = Join-Path $pluginsDir "intellij-ib-plugin" - if (Test-Path $targetPluginDir) { - Remove-Item -Recurse -Force $targetPluginDir - } - - Expand-Archive -Path $tempZip -DestinationPath $pluginsDir -Force - Write-Host "Installed into $($install.Name) ($pluginsDir)." -} - -Remove-Item $tempZip -Force -Write-Host "Install complete. Start the IDE to use the Incredibuild plugin." diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IdeBuildAcceleration.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IdeBuildAcceleration.kt new file mode 100644 index 0000000..6ac4354 --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IdeBuildAcceleration.kt @@ -0,0 +1,125 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions + +import com.incredibuild.ibplugin.analytics.PostHogClient +import com.incredibuild.ibplugin.settings.IncredibuildConfigurable +import com.incredibuild.ibplugin.settings.IncredibuildSettings +import com.intellij.ide.BrowserUtil +import com.intellij.notification.NotificationAction +import com.intellij.notification.NotificationGroupManager +import com.intellij.notification.NotificationType +import com.intellij.openapi.options.ShowSettingsUtil +import com.intellij.openapi.project.Project +import com.intellij.openapi.util.Key +import java.io.File +import java.util.Collections + +/** Reasons already reported in this project, so a fallback is announced once per session rather than on every build. */ +private val REPORTED_FALLBACKS = Key.create>("Incredibuild.ReportedIdeBuildFallbacks") + +/** + * What the IDE's own Build/Rebuild actions share when they are routed through Incredibuild (the + * "Use Incredibuild for the IDE's build actions" setting) - in RustRover, CLion and Rider alike: + * whether to route at all, and what happens when Incredibuild can't take the build. + * + * The rule throughout is that a standard IDE command must never fail because of this plugin: if + * Incredibuild is missing, unlicensed or too old, the build goes ahead with the IDE's own builder + * and the user is told why, once, with a way to fix it. + */ +object IdeBuildAcceleration { + + /** The opt-in setting - off by default. */ + val isEnabled: Boolean + get() = IncredibuildSettings.getInstance().accelerateIdeBuilds + + /** + * The install folder to run an IDE build through, or null - after telling the user why - if + * the build should fall back to [standardBuilder] (e.g. "Cargo", "CMake", "Rider's build"). + * Blocking; never call it on the EDT. + */ + fun installFolderOrFallBack(project: Project, flavor: BuildFlavor, standardBuilder: String): File? = + when (val status = IncredibuildInstallation.check(flavor)) { + is InstallationStatus.Ready -> status.installFolder + else -> { + notifyFallback(project, status, standardBuilder) + null + } + } + + /** + * Tells the user an IDE build that should have gone through Incredibuild is running with + * [standardBuilder] instead, because of [status]. Shown once per project session per kind of + * problem, so a team member without Incredibuild isn't nagged on every build - the settings + * page shows the same status permanently. + */ + fun notifyFallback(project: Project, status: InstallationStatus, standardBuilder: String) { + val reasonKey = when (status) { + InstallationStatus.NotInstalled -> "not_installed" + is InstallationStatus.UnsupportedVersion -> "unsupported_version" + is InstallationStatus.NotLicensed -> "not_licensed" + is InstallationStatus.Ready -> return + } + notifyOnce( + project, + reasonKey, + IncredibuildInstallation.describe(status), + standardBuilder, + offerDownload = status !is InstallationStatus.NotLicensed + ) + } + + /** + * Tells the user an IDE build fell back to [standardBuilder] for a reason other than the + * installation itself - e.g. the build command couldn't be prepared. Same once-per-session rule. + */ + fun notifyFallback(project: Project, reason: String, standardBuilder: String) { + notifyOnce(project, "other:$reason", reason, standardBuilder, offerDownload = false) + } + + private fun notifyOnce( + project: Project, + reasonKey: String, + reason: String, + standardBuilder: String, + offerDownload: Boolean + ) { + val reported = synchronized(project) { + project.getUserData(REPORTED_FALLBACKS) + ?: Collections.synchronizedSet(HashSet()).also { project.putUserData(REPORTED_FALLBACKS, it) } + } + if (!reported.add(reasonKey)) return + + PostHogClient.capture("ide_build_fallback", mapOf("reason" to reasonKey.substringBefore(':'))) + val notification = NotificationGroupManager.getInstance() + .getNotificationGroup(NOTIFICATION_GROUP_ID) + .createNotification( + "Building without Incredibuild", + "$reason
This build runs with $standardBuilder instead.", + NotificationType.WARNING + ) + .addAction(NotificationAction.createSimple("Incredibuild settings") { + ShowSettingsUtil.getInstance().showSettingsDialog(project, IncredibuildConfigurable::class.java) + }) + if (offerDownload) { + notification.addAction(NotificationAction.createSimple("Download Incredibuild") { + PostHogClient.capture("download_latest_version_opened") + BrowserUtil.browse(INCREDIBUILD_DOWNLOAD_PAGE) + }) + } + notification.notify(project) + } +} diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildInstallation.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildInstallation.kt new file mode 100644 index 0000000..f14dc8b --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildInstallation.kt @@ -0,0 +1,163 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions + +import com.intellij.execution.configurations.GeneralCommandLine +import com.intellij.execution.util.ExecUtil +import com.intellij.openapi.diagnostic.Logger +import com.intellij.openapi.util.SystemInfo +import java.io.File + +private val LOG = Logger.getInstance(IncredibuildInstallation::class.java) + +/** How long the license query may take before it's treated as inconclusive - see [IncredibuildInstallation.queryLicense]. */ +private const val LICENSE_QUERY_TIMEOUT_MS = 5_000 + +/** Matches the "InitiatorRegType Floating" / "CIInitiatorRegType None" lines of `BuildConsole /QueryLicense`. */ +private val INITIATOR_REG_TYPE_REGEX = Regex("""^\s*(?:CI)?InitiatorRegType\s+(\S+)""", RegexOption.MULTILINE) + +/** + * Which kind of build an installation is being validated for. Rust build support needed a + * specific Incredibuild release (see [minimumVersion]); the native CMake/MSBuild support has no + * known minimum. + */ +enum class BuildFlavor { + RUST, + NATIVE; + + /** The oldest supported Incredibuild version for this flavor on the current OS, or null if any version is fine. */ + fun minimumVersion(): String? = when (this) { + RUST -> if (SystemInfo.isLinux) MINIMUM_RUST_BUILD_VERSION_LINUX else MINIMUM_RUST_BUILD_VERSION + NATIVE -> null + } + + internal companion object { + const val MINIMUM_RUST_BUILD_VERSION = "10.37.1" + + // The Linux team found an issue with an earlier released Linux Incredibuild + // version during RustRover integration testing, hence this gate. Deliberately a + // separate constant, not shared with the Windows one: Windows and Linux + // Incredibuild use entirely unrelated version-numbering schemes (e.g. + // "10.37.0.12597" vs "3.18.0"). + const val MINIMUM_RUST_BUILD_VERSION_LINUX = "4.29.3" + } +} + +/** + * The Incredibuild installation the plugin would use, and whether it can accelerate a build - + * shown on the settings page, and consulted before the IDE's own build actions are routed + * through Incredibuild (where anything but [Ready] falls back to the IDE's standard build). + */ +sealed interface InstallationStatus { + /** The install folder, when one was found at all. */ + val installFolder: File? + + object NotInstalled : InstallationStatus { + override val installFolder: File? = null + } + + class UnsupportedVersion( + override val installFolder: File, + val installedVersion: String, + val minimumVersion: String + ) : InstallationStatus + + class NotLicensed(override val installFolder: File, val installedVersion: String?) : InstallationStatus + + /** + * Usable. [licensed] is null where the license couldn't be determined (always on Linux, + * which has no license query; on Windows if the query failed) - that isn't treated as a + * reason to fall back, since Incredibuild itself reports a licensing problem in the build + * output anyway. + */ + class Ready( + override val installFolder: File, + val installedVersion: String?, + val licensed: Boolean? + ) : InstallationStatus +} + +object IncredibuildInstallation { + + /** + * Locates and validates the installation for [flavor]. Blocking (registry query, file reads + * and a short-lived BuildConsole process), so never call it on the EDT. + */ + fun check(flavor: BuildFlavor): InstallationStatus { + val installFolder = IncredibuildLocator.findInstallFolder() ?: return InstallationStatus.NotInstalled + val installedVersion = IncredibuildLocator.findVersion() + + val minimumVersion = flavor.minimumVersion() + if (minimumVersion != null && installedVersion != null && + IncredibuildLocator.compareVersions(installedVersion, minimumVersion) < 0 + ) { + return InstallationStatus.UnsupportedVersion(installFolder, installedVersion, minimumVersion) + } + + val licensed = queryLicense(installFolder) + if (licensed == false) return InstallationStatus.NotLicensed(installFolder, installedVersion) + return InstallationStatus.Ready(installFolder, installedVersion, licensed) + } + + /** + * Whether this machine holds an Incredibuild initiator license, from `BuildConsole + * /QueryLicense` - or null if that can't be determined (Linux, a missing BuildConsole, a + * failed or timed-out query, or output in an unrecognized shape). + */ + private fun queryLicense(installFolder: File): Boolean? { + if (!SystemInfo.isWindows) return null + val buildConsole = File(installFolder, "BuildConsole.exe") + if (!buildConsole.exists()) return null + return try { + val output = ExecUtil.execAndGetOutput( + GeneralCommandLine(buildConsole.absolutePath, "/QueryLicense"), + LICENSE_QUERY_TIMEOUT_MS + ) + if (output.isTimeout || output.exitCode != 0) null else parseLicenseQuery(output.stdout) + } catch (e: Exception) { + LOG.info("Could not query the Incredibuild license", e) + null + } + } + + /** + * Reads `BuildConsole /QueryLicense` output: licensed if either the developer + * (`InitiatorRegType`) or CI (`CIInitiatorRegType`) initiator registration is anything but + * "None" - a machine can start builds with either. Null if neither line is present. + */ + internal fun parseLicenseQuery(output: String): Boolean? { + val regTypes = INITIATOR_REG_TYPE_REGEX.findAll(output).map { it.groupValues[1] }.toList() + if (regTypes.isEmpty()) return null + return regTypes.any { !it.equals("None", ignoreCase = true) } + } + + /** One line describing [status], for the settings page and fallback notifications. */ + fun describe(status: InstallationStatus): String = when (status) { + InstallationStatus.NotInstalled -> "Incredibuild is not installed on this machine." + is InstallationStatus.UnsupportedVersion -> + "Incredibuild ${status.installedVersion} (${status.installFolder.absolutePath}) is not supported - " + + "version ${status.minimumVersion} or later is required." + is InstallationStatus.NotLicensed -> + "Incredibuild${status.installedVersion?.let { " $it" } ?: ""} (${status.installFolder.absolutePath}) " + + "is installed, but this machine has no Incredibuild license." + is InstallationStatus.Ready -> buildString { + append("Incredibuild") + status.installedVersion?.let { append(' ').append(it) } + append(" (").append(status.installFolder.absolutePath).append(')') + if (status.licensed == true) append(" - licensed") + } + } +} diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildLocator.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildLocator.kt index ffef765..7397534 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildLocator.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildLocator.kt @@ -65,8 +65,8 @@ object IncredibuildLocator { * "10.37.0.12597"), or from `IB_SHORT_VERSION` in `version_info.src` on Linux * (e.g. "3.18.0") - or null if unavailable. The two platforms use unrelated * version-numbering schemes, so callers must compare against a platform-specific - * minimum (see [com.incredibuild.ibplugin.actions.IncredibuildRunner]'s - * `MINIMUM_RUST_BUILD_VERSION`/`MINIMUM_RUST_BUILD_VERSION_LINUX`), never mix them. + * minimum (see [com.incredibuild.ibplugin.actions.BuildFlavor.minimumVersion]), + * never mix them. */ fun findVersion(): String? { if (SystemInfo.isLinux) { diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildProjectTaskRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildProjectTaskRunner.kt index e69cbac..bdec856 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildProjectTaskRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildProjectTaskRunner.kt @@ -28,7 +28,6 @@ import com.intellij.task.ProjectTaskContext import com.intellij.task.ProjectTaskRunner import com.intellij.task.TaskRunnerResults import com.incredibuild.ibplugin.analytics.PostHogClient -import com.incredibuild.ibplugin.settings.IncredibuildSettings import org.jetbrains.concurrency.AsyncPromise import org.jetbrains.concurrency.Promise import org.rust.cargo.runconfig.buildtool.CargoBuildAdapter @@ -82,7 +81,7 @@ class IncredibuildProjectTaskRunner : ProjectTaskRunner() { override fun canRun(projectTask: ProjectTask): Boolean = false override fun canRun(project: Project, projectTask: ProjectTask, context: ProjectTaskContext?): Boolean { - if (!IncredibuildSettings.getInstance().accelerateIdeBuilds) return false + if (!IdeBuildAcceleration.isEnabled) return false val cargoRunner = cargoBuildTaskRunner() ?: return false return try { cargoRunner.canRun(project, projectTask, context) @@ -118,11 +117,11 @@ class IncredibuildProjectTaskRunner : ProjectTaskRunner() { tasks: Array, promise: AsyncPromise ) { - val installFolder = IncredibuildLocator.findInstallFolder() + // No dialog here, unlike the explicit menu actions: this path is a standard IDE build + // the user did not ask Incredibuild for by name, so it must not block - it builds + // normally, with a one-off notification saying why. + val installFolder = IdeBuildAcceleration.installFolderOrFallBack(project, BuildFlavor.RUST, CARGO) if (installFolder == null) { - // No dialog here, unlike the explicit menu actions: this path is a standard IDE - // build the user did not ask Incredibuild for, so it must stay silent and simply - // build normally. delegateToCargo(project, context, tasks, promise) return } @@ -138,6 +137,13 @@ class IncredibuildProjectTaskRunner : ProjectTaskRunner() { // (several Cargo projects in one IDE project) they must not compete for the build // tool window. for (planned in plannedBuilds) { + // One Incredibuild build at a time, as for the Incredibuild menu's builds - this one + // reports into the Build tool window rather than ours, but would still overlap one + // running there. Checked before the clean too, which must not run under a build. + if (!IncredibuildRunner.awaitNoBuildRunning(project)) { + promise.setResult(TaskRunnerResults.ABORTED) + return + } if (!planned.isIncrementalBuild && !cleanBeforeRebuild(project, planned.buildConfiguration)) { promise.setResult(TaskRunnerResults.FAILURE) return @@ -248,7 +254,10 @@ class IncredibuildProjectTaskRunner : ProjectTaskRunner() { resolved.invocation.workingDirectory ) if (prepared !is IncredibuildRunner.PreparedBuild.Ready) { - if (prepared is IncredibuildRunner.PreparedBuild.Failed) LOG.warn(prepared.message) + if (prepared is IncredibuildRunner.PreparedBuild.Failed) { + LOG.warn(prepared.message) + IdeBuildAcceleration.notifyFallback(project, prepared.message, CARGO) + } return null } @@ -342,5 +351,8 @@ class IncredibuildProjectTaskRunner : ProjectTaskRunner() { /** Shown as the build's name and progress text in the Build tool window. */ private const val BUILD_TASK_NAME = "Build" private const val BUILD_PROGRESS_TITLE = "Building with Incredibuild…" + + /** The standard builder a fallback build runs with, as named in the fallback notification. */ + private const val CARGO = "Cargo" } } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt index 1f5168a..0f7ba95 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/IncredibuildRunner.kt @@ -31,6 +31,7 @@ import com.intellij.execution.process.ProcessListener import com.intellij.execution.util.ExecUtil import com.intellij.ide.BrowserUtil import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.ModalityState import com.intellij.openapi.progress.ProgressIndicator import com.intellij.openapi.progress.ProgressManager import com.intellij.openapi.progress.Task @@ -41,6 +42,7 @@ import com.intellij.openapi.util.SystemInfo import com.intellij.openapi.wm.ToolWindowManager import com.incredibuild.ibplugin.analytics.PostHogClient import java.io.File +import java.util.concurrent.atomic.AtomicBoolean /** Matches the "Build ID: {}" line BuildConsole prints to stdout when a build starts. * Windows only - ib_console on Linux never prints a build-id, so this simply never matches @@ -48,22 +50,13 @@ import java.io.File private val BUILD_ID_REGEX = Regex("""Build ID:\s*\{([0-9A-Fa-f-]+)}""") // Used for both Windows and Linux - same landing page for both. -private const val INCREDIBUILD_WEBSITE = "https://www.incredibuild.com/integrations/jetbrains-ides" +internal const val INCREDIBUILD_WEBSITE = "https://www.incredibuild.com/integrations/jetbrains-ides" -private const val INCREDIBUILD_DOWNLOAD_PAGE = +internal const val INCREDIBUILD_DOWNLOAD_PAGE = "https://docs.incredibuild.com/site-landing/download-docs-center" -private const val MINIMUM_RUST_BUILD_VERSION = "10.37.1" - -// The Linux team found an issue with an earlier released Linux Incredibuild -// version during RustRover integration testing, hence this gate. Deliberately a -// separate constant, not shared with the Windows one: Windows and Linux -// Incredibuild use entirely unrelated version-numbering schemes (e.g. -// "10.37.0.12597" vs "3.18.0"). -private const val MINIMUM_RUST_BUILD_VERSION_LINUX = "4.29.3" - /** Declared in plugin.xml. */ -private const val NOTIFICATION_GROUP_ID = "Incredibuild" +internal const val NOTIFICATION_GROUP_ID = "Incredibuild" private const val STATUS_POLL_INTERVAL_MS = 250L @@ -101,7 +94,7 @@ object IncredibuildRunner { return null } - val minimumVersion = if (SystemInfo.isLinux) MINIMUM_RUST_BUILD_VERSION_LINUX else MINIMUM_RUST_BUILD_VERSION + val minimumVersion = requireNotNull(BuildFlavor.RUST.minimumVersion()) val installedVersion = IncredibuildLocator.findVersion() if (installedVersion != null && IncredibuildLocator.compareVersions(installedVersion, minimumVersion) < 0 @@ -385,29 +378,27 @@ object IncredibuildRunner { onFinished: ((exitCode: Int) -> Unit)? = null ) { ApplicationManager.getApplication().invokeLater { - val processHandler = run( + run( project, prepared.commandLine, presentation?.contentName ?: "Build", - presentation?.banner + presentation?.banner, + onNotStarted = prepared.cleanUp, + onStarted = { processHandler -> + PostHogClient.capture("build_started", mapOf("action" to actionType)) + PostHogClient.captureOnce( + "com.incredibuild.ibplugin.analytics.firstBuildSent", + "first_build", + mapOf("action" to actionType) + ) + if (presentation != null) { + trackInStatusBar(project, processHandler, presentation) + } + } ) { exitCode -> prepared.cleanUp() onFinished?.invoke(exitCode) } - if (processHandler == null) { - prepared.cleanUp() - return@invokeLater - } - - PostHogClient.capture("build_started", mapOf("action" to actionType)) - PostHogClient.captureOnce( - "com.incredibuild.ibplugin.analytics.firstBuildSent", - "first_build", - mapOf("action" to actionType) - ) - if (presentation != null) { - trackInStatusBar(project, processHandler, presentation) - } } } @@ -478,17 +469,32 @@ object IncredibuildRunner { * * [banner], if given, is printed at the top of the console before any build output. * - * Must be called on the EDT. Returns null, without starting anything or calling - * [onFinished], if another build is still running - see [confirmNoBuildRunning]. + * Must be called on the EDT. Only one build runs at a time (see [whenNoBuildRunning]), so + * this may start the process later - once a running build the user chose to stop has + * stopped - or not at all: [onStarted] gets the running process, [onNotStarted] is called + * instead (and [onFinished] never is) if the user cancels. */ fun run( project: Project, commandLine: GeneralCommandLine, contentName: String, banner: String? = null, + onNotStarted: () -> Unit = {}, + onStarted: (OSProcessHandler) -> Unit = {}, onFinished: ((exitCode: Int) -> Unit)? = null - ): OSProcessHandler? { - if (!confirmNoBuildRunning(project)) return null + ) { + whenNoBuildRunning(project, onNotStarted) { + onStarted(start(project, commandLine, contentName, banner, onFinished)) + } + } + + private fun start( + project: Project, + commandLine: GeneralCommandLine, + contentName: String, + banner: String?, + onFinished: ((exitCode: Int) -> Unit)? + ): OSProcessHandler { val processHandler = createProcessHandler(commandLine) val console = ConsoleViewImpl(project, true) @@ -660,30 +666,72 @@ object IncredibuildRunner { fun isBuildRunning(): Boolean = activeProcessHandler?.isProcessTerminated == false /** - * One build at a time: returns true if nothing is running, otherwise offers to stop the - * running build and returns false - the new one isn't started either way, so the two never - * overlap while the old one winds down. Without this, a second build replaces the first one's - * tool window tab (its output disappears while it's still running) and becomes the only one - * Stop Build can reach; and while Windows' BuildConsole would queue it behind the first - * ("Waiting for a build to complete..."), nothing guarantees ib_console does the same. + * One build at a time: calls [start] straight away if nothing is running; otherwise offers to + * stop the running build, and if the user agrees, calls [start] once it has actually stopped - + * never while it's still winding down, so the two never overlap. [onDeclined] if they cancel. + * Without this, a second build replaces the first one's tool window tab (its output disappears + * while it's still running) and becomes the only one Stop Build can reach; and while Windows' + * BuildConsole would queue it behind the first ("Waiting for a build to complete..."), nothing + * guarantees ib_console does the same. * - * Checked in [run], on the EDT, right where the build is registered as the active one - so - * two quick clicks can't both get past it. A Rebuild's chained build is unaffected: its clean - * has already ended by the time the build starts. + * Checked in [run], on the EDT, and [start] registers the build as the active one in the same + * EDT event - so two quick clicks can't both get past it. After a stop the check runs again + * before starting, in case something else started meanwhile. A Rebuild's chained build is + * unaffected: its clean has already ended by the time the build starts. Builds started from a + * background thread wait with [awaitNoBuildRunning] instead. + */ + private fun whenNoBuildRunning(project: Project, onDeclined: () -> Unit, start: () -> Unit) { + val running = activeProcessHandler?.takeUnless { it.isProcessTerminated } + if (running == null) { + start() + return + } + if (!askToStopRunningBuild(project)) { + onDeclined() + return + } + val retried = AtomicBoolean() + val retry = { + if (retried.compareAndSet(false, true)) { + ApplicationManager.getApplication().invokeLater { whenNoBuildRunning(project, onDeclined, start) } + } + } + running.addProcessListener(object : ProcessListener { + override fun processTerminated(event: ProcessEvent) = retry() + }) + // It may have ended between the check above and adding the listener, which then never fires. + if (running.isProcessTerminated) retry() + stopActiveProcess(project) + } + + /** + * [whenNoBuildRunning] for a build started from a background thread - the IDE's build pipeline + * (see [IncredibuildProjectTaskRunner]), which reports its own outcome and so must wait here + * rather than be called back. Blocks until nothing is running and returns true, or returns + * false if the user chose not to stop the running build. */ - private fun confirmNoBuildRunning(project: Project): Boolean { - if (!isBuildRunning()) return true - val stop = Messages.showYesNoDialog( + internal fun awaitNoBuildRunning(project: Project): Boolean { + while (true) { + val running = activeProcessHandler?.takeUnless { it.isProcessTerminated } ?: return true + var stop = false + ApplicationManager.getApplication().invokeAndWait({ stop = askToStopRunningBuild(project) }, ModalityState.any()) + if (!stop) return false + PostHogClient.capture("stop_build_clicked", mapOf("hadActiveProcess" to true)) + // Graceful where possible - see stopActiveProcess. + running.destroyProcess() + running.waitFor() + } + } + + private fun askToStopRunningBuild(project: Project): Boolean = + Messages.showYesNoDialog( project, - "An Incredibuild build is already running. Stop it before starting another one.", + "An Incredibuild build is already running. Stop it and start this one once it has stopped?", "Incredibuild", "Stop Running Build", "Cancel", Messages.getWarningIcon() ) == Messages.YES - if (stop) stopActiveProcess(project) - return false - } /** * Stops whichever build/clean process is currently running, if any. @@ -758,11 +806,18 @@ object IncredibuildRunner { * that fails), from [workingDirectory], with [environment] set on top of the inherited one. * Kept as executable + argument lists rather than pre-joined strings so quoting is only ever * done once, by whichever wrapper script actually launches them. + * + * [buildCache] opts the build into Incredibuild's Build Cache - `/BUILDCACHELOCAL=ON` on + * Windows, `--build-cache-local-shared` on Linux. On for the C/C++ compilers a CMake build + * runs, which the cache supports; off for MSBuild, since Build Cache doesn't support .NET + * builds yet, so .NET builds are accelerated without it rather than relying on the cache + * passing their tools through untouched. */ internal class NativeBuild( val commands: List, val workingDirectory: String, - val environment: Map = emptyMap() + val environment: Map = emptyMap(), + val buildCache: Boolean = true ) /** @@ -795,6 +850,67 @@ object IncredibuildRunner { } } + /** How a build started from the IDE's own build pipeline ended - see [launchNativeBuildForIde]. */ + internal sealed interface IdeBuildOutcome { + object Succeeded : IdeBuildOutcome + object Failed : IdeBuildOutcome + object Stopped : IdeBuildOutcome + + /** Another Incredibuild build was running and the user chose not to stop it (see [whenNoBuildRunning]). */ + object NotStarted : IdeBuildOutcome + + /** The command couldn't be prepared - the caller should fall back to the IDE's own build. */ + class NotPrepared(val message: String) : IdeBuildOutcome + } + + /** + * As [launchNativeBuild], for a build the IDE's own Build/Rebuild started (see + * [IdeBuildAcceleration]): the same Incredibuild tool window, status-bar progress and + * notification, but with the outcome handed to [onOutcome] - exactly once, on the EDT, or + * straight away on the calling thread for [IdeBuildOutcome.NotPrepared] - so the caller can + * complete the IDE's build promise. Must be called from a background thread. + */ + internal fun launchNativeBuildForIde( + project: Project, + installFolder: File, + build: NativeBuild, + actionType: String, + presentation: AcceleratedBuildPresentation, + onOutcome: (IdeBuildOutcome) -> Unit + ) { + val prepared = when (val result = prepareNativeBuild(project, installFolder, build)) { + is PreparedBuild.Failed -> return onOutcome(IdeBuildOutcome.NotPrepared(result.message)) + is PreparedBuild.Ready -> result + } + ApplicationManager.getApplication().invokeLater { + var processHandler: OSProcessHandler? = null + run( + project, + prepared.commandLine, + presentation.contentName, + presentation.banner, + onNotStarted = { + prepared.cleanUp() + onOutcome(IdeBuildOutcome.NotStarted) + }, + onStarted = { started -> + processHandler = started + PostHogClient.capture("ide_build_accelerated", mapOf("action" to actionType)) + trackInStatusBar(project, started, presentation) + } + ) { exitCode -> + prepared.cleanUp() + onOutcome( + when { + processHandler?.wasStopRequested() == true -> IdeBuildOutcome.Stopped + exitCode == 0 -> IdeBuildOutcome.Succeeded + else -> IdeBuildOutcome.Failed + } + ) + } + } + } + /** * Resolves [kind]'s cmake invocation and, if Incredibuild is installed, runs it through * Incredibuild. Everything here - locating Incredibuild, reading the CMake project model - @@ -879,18 +995,7 @@ object IncredibuildRunner { val scriptFile = File.createTempFile("incredibuild-build-", ".ps1") scriptFile.deleteOnExit() scriptFile.writeText( - "& \"${buildConsolePath.absolutePath}\" " + - "${powerShellSingleQuoted("/command=\"${wrapperCmd.absolutePath}\"")} " + - "${powerShellSingleQuoted("/title=\"${project.name}\"")} " + - // Explicitly opts this session into Build Cache, the same way the Linux - // ib_console invocation below already does via --build-cache-local-shared - no - // /BuildCacheProfile= is passed alongside it because cl.exe/clang/gcc are - // already covered by BuildConsole's own built-in default profile (the bespoke - // *.xml sample profiles in the Incredibuild install's "BuildCache Profiles" - // folder are only for tools that default profile doesn't already know, e.g. - // rustc/lib for the Cargo build above, or nvcc/perl). - "/BUILDCACHELOCAL=ON\n" + - "exit \$LASTEXITCODE\n" + windowsLauncherScript(buildConsolePath.absolutePath, wrapperCmd.absolutePath, project.name, build.buildCache) ) val commandLine = GeneralCommandLine("powershell") @@ -903,6 +1008,24 @@ object IncredibuildRunner { } } + /** + * The PowerShell script [prepareNativeBuildWindows] runs: BuildConsole with /command= pointed + * at [wrapperCmd] (see [windowsWrapperScript]), exiting with BuildConsole's own exit code. + */ + internal fun windowsLauncherScript(buildConsole: String, wrapperCmd: String, title: String, buildCache: Boolean): String = + "& \"$buildConsole\" " + + "${powerShellSingleQuoted("/command=\"$wrapperCmd\"")} " + + powerShellSingleQuoted("/title=\"$title\"") + + // Explicitly opts this session into Build Cache, the same way the Linux ib_console + // invocation does via --build-cache-local-shared - no /BuildCacheProfile= is passed + // alongside it because cl.exe/clang/gcc are already covered by BuildConsole's own + // built-in default profile (the bespoke *.xml sample profiles in the Incredibuild + // install's "BuildCache Profiles" folder are only for tools that default profile + // doesn't already know, e.g. rustc/lib for the Cargo build above, or nvcc/perl). + // Left off where the build doesn't want it - see NativeBuild.buildCache. + (if (buildCache) " /BUILDCACHELOCAL=ON" else "") + "\n" + + "exit \$LASTEXITCODE\n" + /** * The .cmd [prepareNativeBuildWindows] points BuildConsole's /command= at: [NativeBuild.environment] * via `set`, then each command in turn, stopping at (and exiting with) the first non-zero @@ -975,7 +1098,10 @@ object IncredibuildRunner { } script.append("exec ").append(shellSingleQuoted(consolePath)) .append(" --caption ").append(shellSingleQuoted(caption)) - .append(" --ib-quiet --build-cache-local-shared --build-cache-basedir=\"\$PWD\" -- ") + .append(" --ib-quiet") + // Left off where the build doesn't want it - see NativeBuild.buildCache. + if (build.buildCache) script.append(" --build-cache-local-shared --build-cache-basedir=\"\$PWD\"") + script.append(" -- ") val commandTexts = build.commands.map { command -> (listOf(command.executable) + command.arguments).joinToString(" ") { shellSingleQuoted(it) } } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/CMakeBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/CMakeBuildCommand.kt index da5ae19..74c3bb5 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/CMakeBuildCommand.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/CMakeBuildCommand.kt @@ -19,6 +19,7 @@ import com.incredibuild.ibplugin.settings.IncredibuildSettings import com.intellij.openapi.application.ReadAction import com.intellij.openapi.diagnostic.Logger import com.intellij.openapi.project.Project +import com.jetbrains.cidr.cpp.cmake.model.CMakeConfiguration import com.jetbrains.cidr.cpp.cmake.workspace.CMakeWorkspace import com.jetbrains.cidr.cpp.execution.CMakeAppRunConfiguration import com.jetbrains.cidr.cpp.toolchains.CPPBuildUtil @@ -96,10 +97,49 @@ internal fun deriveCMakeBuild(project: Project, kind: CMakeBuildKind): CMakeBuil null } +/** + * The cmake invocation for one [buildConfiguration] (a target in one CMake profile) handed over + * by CLion's own build pipeline - see [IncredibuildCMakeProjectTaskRunner]. [targetName] null + * means every target, cmake's default "all". Must be called from a background thread. + */ +internal fun deriveCMakeBuild( + project: Project, + buildConfiguration: CMakeConfiguration, + targetName: String?, + cleanFirst: Boolean +): CMakeBuildResolution? = + try { + ReadAction.compute { + resolveCMakeBuild(project, buildConfiguration, targetName, cleanFirst) + } + } catch (e: Exception) { + LOG.warn("Could not derive the CMake build command for ${buildConfiguration.name}", e) + null + } + private fun resolveCMakeBuild(project: Project, kind: CMakeBuildKind): CMakeBuildResolution? { val buildAndRun = CMakeAppRunConfiguration.getSelectedBuildAndRunConfigurations(project) ?: return null val buildConfiguration = buildAndRun.buildConfiguration + // An explicit target set on the run configuration (e.g. "Build 'foo'" instead of just + // "Build") wins over the target the configuration would otherwise produce - matching + // CMakeAppRunConfiguration.BuildAndRunConfigurations' own field of the same name. + // wholeProject (Build All) passes no target at all: cmake's own default target already + // means "build everything", the same "all"/"ALL_BUILD" pseudo-target CLion's own Build + // Project action builds. + val targetName = if (kind.wholeProject) { + null + } else { + buildAndRun.explicitBuildTargetName?.takeIf { it.isNotBlank() } ?: buildConfiguration.target.name + } + return resolveCMakeBuild(project, buildConfiguration, targetName, kind.cleanFirst) +} +private fun resolveCMakeBuild( + project: Project, + buildConfiguration: CMakeConfiguration, + targetName: String?, + cleanFirst: Boolean +): CMakeBuildResolution? { val profileInfo = CMakeWorkspace.getInstance(project).getProfileInfoFor(buildConfiguration) val environment = profileInfo.environment ?: return null @@ -139,19 +179,11 @@ private fun resolveCMakeBuild(project: Project, kind: CMakeBuildKind): CMakeBuil // directory itself was configured and just ignore --config. buildConfiguration.buildType.takeIf { it.isNotBlank() }?.let { parameters += listOf("--config", it) } - if (!kind.wholeProject) { - // An explicit target set on the run configuration (e.g. "Build 'foo'" instead of just - // "Build") wins over the target the configuration would otherwise produce - matching - // CMakeAppRunConfiguration.BuildAndRunConfigurations' own field of the same name. - val targetName = buildAndRun.explicitBuildTargetName?.takeIf { it.isNotBlank() } - ?: buildConfiguration.target.name + if (targetName != null) { parameters += listOf("--target", targetName) } - // wholeProject (Build All) omits --target entirely: cmake's own default target already - // means "build everything", the same "all"/"ALL_BUILD" pseudo-target CLion's own Build - // Project action builds. - if (kind.cleanFirst) { + if (cleanFirst) { parameters += "--clean-first" } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/IncredibuildCMakeProjectTaskRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/IncredibuildCMakeProjectTaskRunner.kt new file mode 100644 index 0000000..fe9e1a7 --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/cmake/IncredibuildCMakeProjectTaskRunner.kt @@ -0,0 +1,265 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.cmake + +import com.incredibuild.ibplugin.actions.BuildFlavor +import com.incredibuild.ibplugin.actions.IdeBuildAcceleration +import com.incredibuild.ibplugin.actions.IncredibuildRunner +import com.incredibuild.ibplugin.actions.IncredibuildRunner.AcceleratedBuildPresentation +import com.incredibuild.ibplugin.actions.IncredibuildRunner.IdeBuildOutcome +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.ModalityState +import com.intellij.openapi.application.ReadAction +import com.intellij.openapi.diagnostic.Logger +import com.intellij.openapi.fileEditor.FileDocumentManager +import com.intellij.openapi.project.Project +import com.intellij.task.ModuleBuildTask +import com.intellij.task.ModuleFilesBuildTask +import com.intellij.task.ProjectModelBuildTask +import com.intellij.task.ProjectTask +import com.intellij.task.ProjectTaskContext +import com.intellij.task.ProjectTaskRunner +import com.intellij.task.TaskRunnerResults +import com.jetbrains.cidr.cpp.cmake.model.CMakeConfiguration +import com.jetbrains.cidr.cpp.execution.CMakeExplicitTargetConfiguration +import com.jetbrains.cidr.cpp.execution.build.runners.CMakeProjectTaskRunner +import com.jetbrains.cidr.execution.build.tasks.CidrCleanTask +import org.jetbrains.concurrency.AsyncPromise +import org.jetbrains.concurrency.Promise +import java.util.concurrent.CompletableFuture + +/** + * Runs CLion's own CMake build actions through Incredibuild: Build, Rebuild, Build Project, the + * toolbar's build button, and the build that runs before a CMake run configuration starts. + * + * All of those converge on the platform's [ProjectTaskRunner] dispatch, which CLion serves with + * [CMakeProjectTaskRunner]; `ProjectTaskManagerImpl` gives each task to the *first* runner whose + * `canRun` accepts it, so this is registered ahead of that one (cmake-support.xml) - the same + * arrangement as the Cargo [com.incredibuild.ibplugin.actions.IncredibuildProjectTaskRunner]. + * + * Likewise, everything about *what* to build is left to CLion: [CMakeProjectTaskRunner] is asked + * whether it would handle the task and to expand it into per-profile builds (and the clean that + * a Rebuild adds), and only the execution is replaced - by `cmake --build` under Incredibuild, + * the same invocation the Incredibuild menu's CMake actions run. + * + * Declining is always safe: when [canRun] says no, or anything goes wrong before the accelerated + * build starts, CLion's own runner builds as usual. + */ +class IncredibuildCMakeProjectTaskRunner : ProjectTaskRunner() { + + /** See the identical override in [com.incredibuild.ibplugin.actions.IncredibuildProjectTaskRunner]. */ + override fun canRun(projectTask: ProjectTask): Boolean = false + + /** + * Also called by CLion's Build Project action on every toolbar/menu update (on a background + * thread) to decide whether it's available, so this must stay cheap and must not throw. + */ + override fun canRun(project: Project, projectTask: ProjectTask, context: ProjectTaskContext?): Boolean { + if (!IdeBuildAcceleration.isEnabled) return false + // Only builds: compiling a single file (ModuleFilesBuildTask, itself a ModuleBuildTask), + // installing and plain Clean stay with CLion. + if (projectTask is ModuleFilesBuildTask) return false + if (projectTask !is ModuleBuildTask && projectTask !is ProjectModelBuildTask<*>) return false + val cmakeRunner = cmakeProjectTaskRunner() ?: return false + return try { + cmakeRunner.canRun(project, projectTask, context) + } catch (e: Exception) { + LOG.warn("Could not ask CLion whether it handles this build task", e) + false + } + } + + override fun run(project: Project, context: ProjectTaskContext, vararg tasks: ProjectTask): Promise { + val promise = AsyncPromise() + // Locating Incredibuild and reading the CMake model must both stay off the EDT. + ApplicationManager.getApplication().executeOnPooledThread { + try { + runOnPooledThread(project, context, tasks, promise) + } catch (e: Exception) { + LOG.warn("Incredibuild build failed to start; falling back to CLion's build", e) + delegateToCMake(project, context, tasks, promise) + } + } + return promise + } + + private fun runOnPooledThread( + project: Project, + context: ProjectTaskContext, + tasks: Array, + promise: AsyncPromise + ) { + val installFolder = IdeBuildAcceleration.installFolderOrFallBack(project, BuildFlavor.NATIVE, CLION_BUILD) + if (installFolder == null) { + delegateToCMake(project, context, tasks, promise) + return + } + + val plan = planBuilds(project, tasks) + if (plan.builds.isEmpty()) { + delegateToCMake(project, context, tasks, promise) + return + } + + val resolvedBuilds = plan.builds.map { planned -> + when (val resolution = deriveCMakeBuild(project, planned.configuration, planned.targetName, plan.cleanFirst)) { + is CMakeBuildResolution.Ready -> planned to resolution.build + is CMakeBuildResolution.Unsupported -> return fallBack(project, resolution.reason, context, tasks, promise) + null -> return fallBack( + project, + "Could not determine the cmake command for ${planned.configuration.name}.", + context, + tasks, + promise + ) + } + } + + // CLion's own build saves unsaved editors first, and cmake reads from disk. + ApplicationManager.getApplication().invokeAndWait( + { FileDocumentManager.getInstance().saveAllDocuments() }, + ModalityState.any() + ) + + // One at a time, blocking this pooled thread on each: Build Project expands to one build + // per CMake profile, and those must not compete for the Incredibuild tool window. + for ((planned, resolved) in resolvedBuilds) { + val build = IncredibuildRunner.NativeBuild( + listOf(IncredibuildRunner.NativeCommand(resolved.executable, resolved.arguments)), + resolved.workingDirectory, + resolved.environment + ) + val outcome = CompletableFuture() + IncredibuildRunner.launchNativeBuildForIde( + project, + installFolder, + build, + if (plan.cleanFirst) "cmake_ide_rebuild" else "cmake_ide_build", + presentation(planned, plan.cleanFirst) + ) { outcome.complete(it) } + + when (val result = outcome.get()) { + IdeBuildOutcome.Succeeded -> continue + IdeBuildOutcome.Failed -> { + promise.setResult(TaskRunnerResults.FAILURE) + return + } + IdeBuildOutcome.Stopped, IdeBuildOutcome.NotStarted -> { + promise.setResult(TaskRunnerResults.ABORTED) + return + } + is IdeBuildOutcome.NotPrepared -> { + fallBack(project, result.message, context, tasks, promise) + return + } + } + } + promise.setResult(TaskRunnerResults.SUCCESS) + } + + /** One `cmake --build` to run: a CMake profile's configuration, and the target (null for all). */ + private class PlannedBuild(val configuration: CMakeConfiguration, val targetName: String?) + + private class BuildPlan(val builds: List, val cleanFirst: Boolean) + + /** + * The builds behind [tasks], as CLion's own runner expands them. A Rebuild shows up as a + * [CidrCleanTask] ahead of each build - mapped to `--clean-first` rather than a separate + * clean, so the clean is accelerated along with the build, as the menu's Rebuild does. + */ + private fun planBuilds(project: Project, tasks: Array): BuildPlan { + val cmakeRunner = cmakeProjectTaskRunner() ?: return BuildPlan(emptyList(), false) + val expanded = ReadAction.compute, Throwable> { + tasks.flatMap { task -> + try { + cmakeRunner.runnerForTask(task, project)?.expandTask(task) ?: emptyList() + } catch (e: Exception) { + LOG.warn("Could not expand build task ${task.presentableName}", e) + emptyList() + } + } + } + val builds = expanded.filterIsInstance>().mapNotNull { task -> + when (val element = task.buildableElement) { + is CMakeConfiguration -> PlannedBuild(element, element.target.name) + // Build Project's per-profile "all" target - which, like the menu's Build All, + // is cmake's default target, so no --target at all (also right for the Visual + // Studio generators, whose equivalent is called ALL_BUILD). + is CMakeExplicitTargetConfiguration -> PlannedBuild( + element.cmakeConfiguration, + element.explicitBuildTargetName?.takeUnless { it.isBlank() || it == ALL_TARGET } + ) + else -> null + } + } + return BuildPlan(builds, cleanFirst = expanded.any { it is CidrCleanTask }) + } + + private fun presentation(planned: PlannedBuild, cleanFirst: Boolean): AcceleratedBuildPresentation { + val actionName = if (cleanFirst) "Rebuild" else "Build" + val target = planned.targetName ?: "all targets" + return AcceleratedBuildPresentation( + contentName = actionName, + banner = "Incredibuild: $actionName (accelerated)\n" + + " Building: $target\n" + + " Profile: ${planned.configuration.profileName}", + progressTitle = "${if (cleanFirst) "Rebuilding" else "Building"} $target with Incredibuild" + ) + } + + private fun fallBack( + project: Project, + reason: String, + context: ProjectTaskContext, + tasks: Array, + promise: AsyncPromise + ) { + LOG.warn(reason) + IdeBuildAcceleration.notifyFallback(project, reason, CLION_BUILD) + delegateToCMake(project, context, tasks, promise) + } + + /** Hands the build back to CLion, mirroring its result into [promise]. */ + private fun delegateToCMake( + project: Project, + context: ProjectTaskContext, + tasks: Array, + promise: AsyncPromise + ) { + val cmakeRunner = cmakeProjectTaskRunner() + if (cmakeRunner == null) { + promise.setResult(TaskRunnerResults.FAILURE) + return + } + cmakeRunner.run(project, context, *tasks) + .onSuccess { promise.setResult(it) } + .onError { promise.setError(it) } + } + + /** CLion's own registered runner, taken from the extension point so it's the instance the platform would have used. */ + private fun cmakeProjectTaskRunner(): CMakeProjectTaskRunner? = + EP_NAME.extensionList.filterIsInstance().firstOrNull() + + private companion object { + private val LOG = Logger.getInstance(IncredibuildCMakeProjectTaskRunner::class.java) + + /** The pseudo-target CLion's Build Project expands to - see [planBuilds]. */ + private const val ALL_TARGET = "all" + + /** The standard builder a fallback build runs with, as named in the fallback notification. */ + private const val CLION_BUILD = "CLion's own CMake build" + } +} diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt index b4ad8e3..9847a96 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildActions.kt @@ -21,6 +21,7 @@ import com.intellij.openapi.actionSystem.ActionUpdateThread import com.intellij.openapi.actionSystem.AnAction import com.intellij.openapi.actionSystem.AnActionEvent import com.intellij.openapi.project.DumbAware +import com.intellij.openapi.project.Project import com.intellij.openapi.ui.Messages /** @@ -45,31 +46,22 @@ abstract class DotNetBuildWithIncredibuildActionBase internal constructor( return } - val selection = RiderSolutionModel.selection(e.dataContext) + // The selection is only read where it matters - the context menu, and Build Selected + // Projects - since this runs on every menu and toolbar update. if (e.isFromContextMenu) { // Same rule as Rider's own Build Selection: offered on the solution, solution // folders and projects in the Solution Explorer, not on files/references inside them. - e.presentation.isEnabledAndVisible = selection != SolutionSelection.Nothing + e.presentation.isEnabledAndVisible = RiderSolutionModel.selection(e.dataContext) != SolutionSelection.Nothing return } e.presentation.isVisible = true - e.presentation.isEnabled = kind != DotNetBuildKind.BUILD_PROJECTS || selection != SolutionSelection.Nothing + e.presentation.isEnabled = kind != DotNetBuildKind.BUILD_PROJECTS || + RiderSolutionModel.selection(e.dataContext) != SolutionSelection.Nothing } override fun actionPerformed(e: AnActionEvent) { val project = e.project ?: return - val entryPoint = RiderSolutionModel.buildEntryPoint(project) - val solutionFile = RiderSolutionModel.solutionFile(project) - val configuration = RiderSolutionModel.activeConfiguration(project) - if (entryPoint == null || solutionFile == null || configuration == null) { - Messages.showErrorDialog( - project, - "Could not determine what to build. Is a solution loaded, with an active configuration selected?", - "Incredibuild" - ) - return - } var effectiveKind = kind var projectFiles = emptyList() @@ -90,21 +82,35 @@ abstract class DotNetBuildWithIncredibuildActionBase internal constructor( } } - DotNetBuildRunner.build( - project, - DotNetBuildRequest( - effectiveKind, - entryPoint, - solutionFile, - configuration.configuration, - configuration.platform, - projectFiles - ), - actionType - ) + val request = dotNetBuildRequest(project, effectiveKind, projectFiles) + if (request == null) { + Messages.showErrorDialog( + project, + "Could not determine what to build. Is a solution loaded, with an active configuration selected?", + "Incredibuild" + ) + return + } + DotNetBuildRunner.build(project, request, actionType) } } +/** + * What Rider's own build of [kind] would build right now - the open solution (or solution filter) + * in its active configuration|platform - or null if there is no solution or active configuration. + * Reads Rider's solution model, so call it on the EDT. + */ +internal fun dotNetBuildRequest( + project: Project, + kind: DotNetBuildKind, + projectFiles: List = emptyList() +): DotNetBuildRequest? { + val entryPoint = RiderSolutionModel.buildEntryPoint(project) ?: return null + val solutionFile = RiderSolutionModel.solutionFile(project) ?: return null + val configuration = RiderSolutionModel.activeConfiguration(project) ?: return null + return DotNetBuildRequest(kind, entryPoint, solutionFile, configuration.configuration, configuration.platform, projectFiles) +} + /** The accelerated equivalent of Rider's own Build Solution. */ class BuildSolutionWithIncredibuildAction : DotNetBuildWithIncredibuildActionBase(DotNetBuildKind.BUILD_SOLUTION, "dotnet_build_solution") diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt index b0b780d..e8f8a36 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetBuildRunner.kt @@ -15,9 +15,13 @@ */ package com.incredibuild.ibplugin.actions.dotnet +import com.incredibuild.ibplugin.actions.BuildFlavor +import com.incredibuild.ibplugin.actions.IdeBuildAcceleration import com.incredibuild.ibplugin.actions.IncredibuildRunner import com.incredibuild.ibplugin.actions.IncredibuildRunner.AcceleratedBuildPresentation +import com.incredibuild.ibplugin.actions.IncredibuildRunner.IdeBuildOutcome import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.ModalityState import com.intellij.openapi.diagnostic.Logger import com.intellij.openapi.fileEditor.FileDocumentManager import com.intellij.openapi.progress.ProgressIndicator @@ -25,10 +29,15 @@ import com.intellij.openapi.progress.ProgressManager import com.intellij.openapi.progress.Task import com.intellij.openapi.project.Project import com.intellij.openapi.ui.Messages +import com.intellij.openapi.util.ThrowableComputable import java.io.File +import java.util.concurrent.CompletableFuture private val LOG = Logger.getInstance("com.incredibuild.ibplugin.actions.dotnet.DotNetBuildRunner") +/** The standard builder a fallback build runs with, as named in the fallback notification. */ +private const val RIDER_BUILD = "Rider's own build" + /** * Everything about Rider's own state an accelerated .NET build needs, captured up front by the * action (on the thread it runs on) so the background part never touches Rider's models. @@ -47,6 +56,7 @@ internal class DotNetBuildRequest( internal object DotNetBuildRunner { + /** The explicit "... with Incredibuild" actions: report problems with dialogs, never fall back. */ fun build(project: Project, request: DotNetBuildRequest, actionType: String) { // Rider's own build saves unsaved editors first, so the build sees what's on screen; // MSBuild reads from disk, so this has to as well. @@ -55,53 +65,142 @@ internal object DotNetBuildRunner { ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Locating Incredibuild") { override fun run(indicator: ProgressIndicator) { val installFolder = IncredibuildRunner.ensureIncredibuildInstalled(project, actionType) ?: return - - val tool = when (val location = MsBuildLocator.locate()) { - is MsBuildLocation.NotFound -> return showError(project, location.reason) - is MsBuildLocation.Found -> location.tool + when (val prepared = prepare(request)) { + is PreparedDotNetBuild.Failed -> showError(project, prepared.message) + is PreparedDotNetBuild.Ready -> IncredibuildRunner.launchNativeBuild( + project, + installFolder, + prepared.build, + actionType, + presentation(request, prepared.tool) + ) } + } + }) + } - val build = when (request.kind) { - DotNetBuildKind.BUILD_SOLUTION, DotNetBuildKind.REBUILD_SOLUTION -> solutionBuild( - tool, - request.entryPoint, - request.kind, - request.configuration, - request.platform, - restore = needsRestore(readSolutionProjectFiles(request.solutionFile)) - ) + /** + * For Rider's own build actions (see [DotNetIdeBuildActionWrapper]): checks Incredibuild and + * prepares the MSBuild invocation under a short modal progress - synchronously, because if + * anything is missing the caller must hand the very same action event back to Rider's own + * action, which it can only do before its own actionPerformed returns. Returns null, after + * telling the user why, when the build should fall back to Rider's. Must be called on the EDT. + */ + fun prepareForIdeAction(project: Project, request: DotNetBuildRequest): IdeBuild? { + FileDocumentManager.getInstance().saveAllDocuments() + return ProgressManager.getInstance().runProcessWithProgressSynchronously( + ThrowableComputable { prepareForIde(project, request) }, + "Preparing Incredibuild build", + false, + project + ) + } - DotNetBuildKind.BUILD_PROJECTS -> { - val targetNames = readProjectTargets(request.solutionFile) - val missing = request.projectFiles.filter { normalizedPath(it) !in targetNames } - if (missing.isNotEmpty()) { - return showError( - project, - "Could not find these projects in ${File(request.solutionFile).name}, so they can't be " + - "built through it:\n" + missing.joinToString("\n") - ) - } - projectsBuild( - tool, - request.solutionFile, - request.projectFiles, - request.configuration, - request.platform, - targetNames, - restore = needsRestore(request.projectFiles) - ) - } - } + /** Starts a build [prepareForIdeAction] prepared, in the Incredibuild tool window. */ + fun launchIdeBuild(project: Project, ideBuild: IdeBuild, actionType: String) { + ApplicationManager.getApplication().executeOnPooledThread { + IncredibuildRunner.launchNativeBuild( + project, + ideBuild.installFolder, + ideBuild.prepared.build, + actionType, + presentation(ideBuild.request, ideBuild.prepared.tool) + ) + } + } + + /** + * For the build Rider runs before a run configuration starts: builds through Incredibuild and + * blocks until it ends, returning whether it succeeded - or null, after telling the user why, + * when Rider should build instead. Must be called off the EDT. + */ + fun buildBlockingForIde(project: Project, request: DotNetBuildRequest, actionType: String): Boolean? { + ApplicationManager.getApplication().invokeAndWait( + { FileDocumentManager.getInstance().saveAllDocuments() }, + ModalityState.any() + ) + val ideBuild = prepareForIde(project, request) ?: return null + val outcome = CompletableFuture() + IncredibuildRunner.launchNativeBuildForIde( + project, + ideBuild.installFolder, + ideBuild.prepared.build, + actionType, + presentation(request, ideBuild.prepared.tool) + ) { outcome.complete(it) } + return when (val result = outcome.get()) { + IdeBuildOutcome.Succeeded -> true + IdeBuildOutcome.Failed, IdeBuildOutcome.Stopped, IdeBuildOutcome.NotStarted -> false + is IdeBuildOutcome.NotPrepared -> { + IdeBuildAcceleration.notifyFallback(project, result.message, RIDER_BUILD) + null + } + } + } + + /** A build of Rider's own that is ready to go through Incredibuild. */ + internal class IdeBuild( + val request: DotNetBuildRequest, + val installFolder: File, + val prepared: PreparedDotNetBuild.Ready + ) - IncredibuildRunner.launchNativeBuild( - project, - installFolder, - build, - actionType, - presentation(request, tool) + private fun prepareForIde(project: Project, request: DotNetBuildRequest): IdeBuild? { + val installFolder = IdeBuildAcceleration.installFolderOrFallBack(project, BuildFlavor.NATIVE, RIDER_BUILD) + ?: return null + return when (val prepared = prepare(request)) { + is PreparedDotNetBuild.Failed -> { + IdeBuildAcceleration.notifyFallback(project, prepared.message, RIDER_BUILD) + null + } + is PreparedDotNetBuild.Ready -> IdeBuild(request, installFolder, prepared) + } + } + + /** The MSBuild invocation for a request, or why there isn't one. */ + internal sealed interface PreparedDotNetBuild { + class Ready(val tool: MsBuildTool, val build: IncredibuildRunner.NativeBuild) : PreparedDotNetBuild + class Failed(val message: String) : PreparedDotNetBuild + } + + /** Locates MSBuild and builds the command for [request]. Blocking - reads the solution file. */ + private fun prepare(request: DotNetBuildRequest): PreparedDotNetBuild { + val tool = when (val location = MsBuildLocator.locate()) { + is MsBuildLocation.NotFound -> return PreparedDotNetBuild.Failed(location.reason) + is MsBuildLocation.Found -> location.tool + } + + val build = when (request.kind) { + DotNetBuildKind.BUILD_SOLUTION, DotNetBuildKind.REBUILD_SOLUTION -> solutionBuild( + tool, + request.entryPoint, + request.kind, + request.configuration, + request.platform, + restore = needsRestore(readEntryPointProjectFiles(request.entryPoint)) + ) + + DotNetBuildKind.BUILD_PROJECTS -> { + val targetNames = readProjectTargets(request.solutionFile) + val missing = request.projectFiles.filter { normalizedPath(it) !in targetNames } + if (missing.isNotEmpty()) { + return PreparedDotNetBuild.Failed( + "Could not find these projects in ${File(request.solutionFile).name}, so they can't be " + + "built through it:\n" + missing.joinToString("\n") + ) + } + projectsBuild( + tool, + request.solutionFile, + request.projectFiles, + request.configuration, + request.platform, + targetNames, + restore = needsRestore(request.projectFiles) ) } - }) + } + return PreparedDotNetBuild.Ready(tool, build) } /** The solution's per-project build targets - see [solutionProjectTargets]. Empty if the @@ -120,14 +219,22 @@ internal object DotNetBuildRunner { } } - /** The solution's project files, for [needsRestore] - empty if they can't be read, which then - * leaves restore to Rider, as it is for every already-restored solution. */ - private fun readSolutionProjectFiles(solutionFile: String): List { - val file = File(solutionFile) + /** + * The project files a whole-solution build of [entryPoint] builds, for [needsRestore]: the + * solution's, or only those an open solution filter includes - so a project the filter leaves + * out can't add `-restore` to every filtered build. Empty if they can't be read, which then + * leaves restore to Rider, as it is for every already-restored solution. + */ + private fun readEntryPointProjectFiles(entryPoint: String): List { + val file = File(entryPoint).absoluteFile return try { - solutionProjectFiles(file.readText(), file.absoluteFile.parentFile) + if (file.extension.equals("slnf", ignoreCase = true)) { + solutionFilterProjectFiles(file.readText(), file.parentFile) + } else { + solutionProjectFiles(file.readText(), file.parentFile) + } } catch (e: Exception) { - LOG.warn("Could not read the project list from $solutionFile", e) + LOG.warn("Could not read the project list from $entryPoint", e) emptyList() } } @@ -141,7 +248,7 @@ internal object DotNetBuildRunner { } val target = when (request.kind) { DotNetBuildKind.BUILD_PROJECTS -> - request.projectFiles.joinToString(", ") { File(it).nameWithoutExtension } + cappedProjectList(request.projectFiles.map { File(it).nameWithoutExtension }) else -> File(request.entryPoint).name } val progressVerb = if (request.kind == DotNetBuildKind.REBUILD_SOLUTION) "Rebuilding" else "Building" @@ -155,6 +262,15 @@ internal object DotNetBuildRunner { ) } + /** + * [names] for the banner, cut short after [shown] so a large selection doesn't make it + * unreadable: "App, Lib +12 more". + */ + internal fun cappedProjectList(names: List, shown: Int = 2): String { + if (names.size <= shown + 1) return names.joinToString(", ") + return names.take(shown).joinToString(", ") + " +${names.size - shown} more" + } + private fun showError(project: Project, message: String) { ApplicationManager.getApplication().invokeLater { Messages.showErrorDialog(project, message, "Incredibuild") diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetIdeBuilds.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetIdeBuilds.kt new file mode 100644 index 0000000..7577248 --- /dev/null +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/DotNetIdeBuilds.kt @@ -0,0 +1,128 @@ +/* + * Copyright 2026 Incredibuild + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.incredibuild.ibplugin.actions.dotnet + +import com.incredibuild.ibplugin.actions.IdeBuildAcceleration +import com.incredibuild.ibplugin.rider.RiderBuildInterceptor +import com.incredibuild.ibplugin.rider.RiderSolutionModel +import com.incredibuild.ibplugin.rider.SolutionSelection +import com.intellij.openapi.actionSystem.ActionManager +import com.intellij.openapi.actionSystem.AnAction +import com.intellij.openapi.actionSystem.AnActionEvent +import com.intellij.openapi.actionSystem.AnActionWrapper +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.ModalityState +import com.intellij.openapi.project.Project +import com.intellij.openapi.startup.ProjectActivity + +/** One of Rider's own build actions that is routed through Incredibuild when the setting is on. */ +private class WrappedRiderAction(val actionId: String, val kind: DotNetBuildKind, val actionType: String) + +/** + * Rider's Build menu's Build Solution and Rebuild Solution, and the Solution Explorer's Build + * Selection. Build Solution's id is also what the toolbar's build button (registered as + * "BuildSolutionAction", carrying Rider's Build shortcuts) runs whenever no build is in progress, so + * wrapping it covers that button and those shortcuts too. + */ +private val WRAPPED_RIDER_ACTIONS = listOf( + WrappedRiderAction("BuildWholeSolutionAction", DotNetBuildKind.BUILD_SOLUTION, "dotnet_ide_build_solution"), + WrappedRiderAction("RebuildSolutionAction", DotNetBuildKind.REBUILD_SOLUTION, "dotnet_ide_rebuild_solution"), + WrappedRiderAction("BuildSelection", DotNetBuildKind.BUILD_PROJECTS, "dotnet_ide_build_selection"), +) + +/** + * Wraps Rider's own build actions (see [WRAPPED_RIDER_ACTIONS]) in [DotNetIdeBuildActionWrapper], + * keeping their ids - so menus, toolbars, keymaps and anything else that refers to them by id get + * the wrapper - and keeping Rider's original instance to delegate to. + * + * Rider has no extension point for intercepting a build: its actions hand it straight to the + * ReSharper backend, which runs MSBuild in its own process tree where Incredibuild can't wrap it. + * + * Done when the first project opens rather than through `actionConfigurationCustomizer`, whose + * interface is internal API the Plugin Verifier rejects; nothing can be built before a project is + * open anyway. Idempotent, so later projects find the wrappers already in place. + */ +class DotNetIdeBuildActionInstaller : ProjectActivity { + + override suspend fun execute(project: Project) { + val actionManager = ActionManager.getInstance() + for (wrapped in WRAPPED_RIDER_ACTIONS) { + val original = actionManager.getAction(wrapped.actionId) ?: continue + if (original is DotNetIdeBuildActionWrapper) continue + actionManager.replaceAction( + wrapped.actionId, + DotNetIdeBuildActionWrapper(original, wrapped.kind, wrapped.actionType) + ) + } + } +} + +/** + * One of Rider's own build actions, run through Incredibuild when "Use Incredibuild for the IDE's + * own Build and Rebuild actions" is on - and exactly as Rider would run it otherwise: when the + * setting is off, when there's no solution or selection to build, and (after a notification saying + * why) when Incredibuild or MSBuild isn't available. Presentation is always Rider's. + */ +internal class DotNetIdeBuildActionWrapper( + delegate: AnAction, + private val kind: DotNetBuildKind, + private val actionType: String +) : AnActionWrapper(delegate) { + + override fun actionPerformed(e: AnActionEvent) { + val project = e.project + val request = if (project != null && IdeBuildAcceleration.isEnabled) requestFor(project, e) else null + val ideBuild = request?.let { DotNetBuildRunner.prepareForIdeAction(project!!, it) } + if (ideBuild == null) { + super.actionPerformed(e) + return + } + DotNetBuildRunner.launchIdeBuild(project!!, ideBuild, actionType) + } + + /** What Rider's own action would build, or null to leave the build to it. */ + private fun requestFor(project: Project, e: AnActionEvent): DotNetBuildRequest? { + if (!RiderSolutionModel.hasSolution(project)) return null + if (kind != DotNetBuildKind.BUILD_PROJECTS) return dotNetBuildRequest(project, kind) + return when (val selection = RiderSolutionModel.selection(e.dataContext)) { + // As in Rider's own Build Selection, the solution node means the whole solution. + SolutionSelection.WholeSolution -> dotNetBuildRequest(project, DotNetBuildKind.BUILD_SOLUTION) + is SolutionSelection.Projects -> dotNetBuildRequest(project, kind, selection.projectFiles) + SolutionSelection.Nothing -> null + } + } +} + +/** The [RiderBuildInterceptor] behind the before-run build steps (rider-support.xml). */ +class DotNetIdeBuildInterceptor : RiderBuildInterceptor { + + override fun buildBeforeRun(project: Project, projectFile: String?): Boolean? { + if (!IdeBuildAcceleration.isEnabled) return null + // Rider's solution model is read on the EDT, like the actions above read it. + var request: DotNetBuildRequest? = null + ApplicationManager.getApplication().invokeAndWait({ + if (RiderSolutionModel.hasSolution(project)) { + request = if (projectFile == null) { + dotNetBuildRequest(project, DotNetBuildKind.BUILD_SOLUTION) + } else { + dotNetBuildRequest(project, DotNetBuildKind.BUILD_PROJECTS, listOf(projectFile)) + } + } + }, ModalityState.any()) + val ready = request ?: return null + return DotNetBuildRunner.buildBlockingForIde(project, ready, "dotnet_ide_before_run") + } +} diff --git a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt index 69b39ff..273c7fe 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/actions/dotnet/MsBuildCommand.kt @@ -15,6 +15,7 @@ */ package com.incredibuild.ibplugin.actions.dotnet +import com.google.gson.JsonParser import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeBuild import com.incredibuild.ibplugin.actions.IncredibuildRunner.NativeCommand import org.w3c.dom.Document @@ -172,6 +173,22 @@ internal fun solutionProjectFiles(solutionText: String, solutionDir: File): List .toList() } +/** + * The project files a solution filter (.slnf) includes - for [needsRestore], so a filtered build + * only restores when one of *its* projects needs it, not when some project the filter leaves out + * does. A filter is JSON, `{"solution": {"path": ..., "projects": [...]}}`: `path` is the .sln + * relative to the filter's own directory ([filterDir]), and each project is relative to that + * solution's directory, as MSBuild resolves them. + */ +internal fun solutionFilterProjectFiles(filterText: String, filterDir: File): List { + val solution = JsonParser.parseString(filterText).asJsonObject.getAsJsonObject("solution") + val solutionDir = File(filterDir, nativeSeparators(solution.get("path").asString)).normalize().parentFile + return solution.getAsJsonArray("projects") + .map { File(solutionDir, nativeSeparators(it.asString)).path } + .filter { it.endsWith("proj", ignoreCase = true) } + .distinct() +} + /** * The accelerated build for a whole solution - the equivalent of Rider's own Build/Rebuild * Solution. [entryPoint] is the .sln/.slnx, or the .slnf when a solution filter is open (MSBuild @@ -191,7 +208,7 @@ internal fun solutionBuild( "-p:Configuration=$configuration", "-p:Platform=$platform", ) + restoreArguments(restore) + COMMON_MSBUILD_ARGUMENTS - return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(entryPoint).absoluteFile.parent) + return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(entryPoint).absoluteFile.parent, buildCache = false) } /** @@ -225,7 +242,7 @@ internal fun projectsBuild( "-p:Configuration=$configuration", "-p:Platform=$platform", ) + restoreArguments(restore) + COMMON_MSBUILD_ARGUMENTS - return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(solutionFile).absoluteFile.parent) + return NativeBuild(listOf(NativeCommand(tool.executable, arguments)), File(solutionFile).absoluteFile.parent, buildCache = false) } private fun restoreArguments(restore: Boolean): List = if (restore) listOf(RESTORE_ARGUMENT) else emptyList() diff --git a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt index 13d12c6..dab7f90 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildConfigurable.kt @@ -15,11 +15,18 @@ */ package com.incredibuild.ibplugin.settings +import com.incredibuild.ibplugin.actions.BuildFlavor +import com.incredibuild.ibplugin.actions.IncredibuildInstallation +import com.incredibuild.ibplugin.actions.InstallationStatus +import com.intellij.icons.AllIcons import com.intellij.ide.plugins.PluginManagerCore import com.intellij.openapi.actionSystem.ActionManager +import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.ModalityState import com.intellij.openapi.extensions.PluginId import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory import com.intellij.openapi.options.BoundConfigurable +import com.intellij.ui.components.JBLabel import com.intellij.ui.dsl.builder.AlignX import com.intellij.ui.dsl.builder.bindIntText import com.intellij.ui.dsl.builder.bindSelected @@ -27,34 +34,47 @@ import com.intellij.ui.dsl.builder.bindText import com.intellij.ui.dsl.builder.panel private val RUST_PLUGIN_ID = PluginId.getId("com.jetbrains.rust") +private val CMAKE_PLUGIN_ID = PluginId.getId("com.intellij.cmake") // Registered by rider-support.xml, so present exactly when the .NET half is loaded. Checked instead // of the com.intellij.modules.rider alias it's gated on: PluginManagerCore.isLoaded() only matches // real plugin ids, not module aliases, and PlatformUtils.isRider() is internal API. private const val RIDER_ACTION_ID = "Incredibuild.DotNet.BuildSolution" -/** Settings > Tools > Incredibuild - the "-j"/"--parallel" job count, (RustRover only) IDE build - * acceleration, and (Rider only) the MSBuild to use. */ +/** Settings > Tools > Incredibuild - the installation in use, the "-j"/"--parallel" job count, IDE + * build acceleration (RustRover, CLion and Rider), and (Rider only) the MSBuild to use. */ class IncredibuildConfigurable : BoundConfigurable("Incredibuild") { + private val isRust = PluginManagerCore.isLoaded(RUST_PLUGIN_ID) + private val isCMake = PluginManagerCore.isLoaded(CMAKE_PLUGIN_ID) + private val isRider = ActionManager.getInstance().getAction(RIDER_ACTION_ID) != null + + private val installationLabel = JBLabel() + override fun createPanel() = panel { + row("Installation:") { + cell(installationLabel).align(AlignX.FILL) + button("Re-check") { refreshInstallation() } + } // "-j" for a Cargo build, "--parallel" for a CMake one - same setting either way. row("Parallel jobs:") { intTextField(1..999).bindIntText(IncredibuildSettings.getInstance()::jobCount) } - // Only meaningful where the Rust plugin's own ProjectTaskRunner exists for this to - // stand in for (see rust-support.xml) - in CLion this checkbox would do nothing at - // all, so it's hidden there rather than shown as a dead setting. + // Only meaningful where there is an IDE build for this to stand in for (see + // rust-support.xml, cmake-support.xml and rider-support.xml) - anywhere else this + // checkbox would do nothing at all, so it's hidden rather than shown as a dead setting. row { - checkBox("Accelerate the IDE's own build actions") + checkBox("Use Incredibuild for the IDE's own Build and Rebuild actions") .bindSelected(IncredibuildSettings.getInstance()::accelerateIdeBuilds) .comment( - "When on, Build Project and the build that runs before Run and " + - "Test go through Incredibuild instead of Cargo.
" + - "When off, those actions behave exactly as they do without this plugin.
" + + "When on, the IDE's standard Build and Rebuild actions go through Incredibuild - " + + "from the Build menu, the toolbar, keyboard shortcuts, and the build that runs before a " + + "run configuration starts.
" + + "If Incredibuild is not installed, not licensed or too old, those builds run normally " + + "instead and a notification explains why.
" + "The actions in the Incredibuild menu always use Incredibuild, either way." ) - }.visible(PluginManagerCore.isLoaded(RUST_PLUGIN_ID)) + }.visible(isRust || isCMake || isRider) // Only meaningful for the .NET actions (see rider-support.xml), so only shown in Rider. row("MSBuild executable:") { textFieldWithBrowseButton( @@ -63,10 +83,33 @@ class IncredibuildConfigurable : BoundConfigurable("Incredibuild") { .align(AlignX.FILL) .bindText(IncredibuildSettings.getInstance()::msBuildPath) .comment( - "Used by the ... with Incredibuild .NET build actions. Leave empty to detect it " + + "Used by the .NET builds that go through Incredibuild. Leave empty to detect it " + "automatically: Visual Studio's MSBuild.exe on Windows if it has the .NET SDK component, otherwise " + "dotnet msbuild. Either MSBuild.exe or the dotnet executable can be given." ) - }.visible(ActionManager.getInstance().getAction(RIDER_ACTION_ID) != null) + }.visible(isRider) + }.also { refreshInstallation() } + + /** + * Shows the installation the plugin would use, checked on a background thread - locating it + * reads the registry and queries the license, neither of which may block the settings dialog. + */ + private fun refreshInstallation() { + installationLabel.icon = AllIcons.Process.Step_1 + installationLabel.text = "Checking..." + // Validated against the strictest flavor present: Rust builds need a minimum version, + // native (CMake/MSBuild) ones don't. + val flavor = if (isRust) BuildFlavor.RUST else BuildFlavor.NATIVE + ApplicationManager.getApplication().executeOnPooledThread { + val status = IncredibuildInstallation.check(flavor) + ApplicationManager.getApplication().invokeLater({ + installationLabel.icon = when (status) { + is InstallationStatus.Ready -> AllIcons.General.InspectionsOK + InstallationStatus.NotInstalled -> AllIcons.General.Error + else -> AllIcons.General.Warning + } + installationLabel.text = IncredibuildInstallation.describe(status) + }, ModalityState.any()) + } } } diff --git a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt index f17f02e..664f2b6 100644 --- a/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt +++ b/src/main/kotlin/com/incredibuild/ibplugin/settings/IncredibuildSettings.kt @@ -31,8 +31,10 @@ class IncredibuildSettings : PersistentStateComponent + + + + + + + + + + + + +