F# support in Rider is implemented as a plugin made of two major components:
- ReSharper.Host plugin (referred to as the backend) that adds F# support to ReSharper and is implemented in ReSharper.FSharp solution. ReSharper.Host is a modification of ReSharper used as a language service that the IntelliJ Platform interacts with. The backend is written in F# and C#.
- IntelliJ Platform plugin for Rider (referred to as the frontend) that defines F# as a new IntelliJ Platform language but delegates most of the work to the backend. This part also adds F# Interactive support. The frontend is written in Kotlin and Java.
F# support in Rider makes use of open source software, most notably FSharp.Compiler.Service and Fantomas.
- .NET SDK 5 or newer
- IntelliJ IDEA
- JetBrains Rider or a different .NET IDE
-
Install SDK and prepare backend plugin build using Gradle
-
if using IntelliJ IDEA:
Open the
rider-fsharp
project in IntelliJ IDEA. When suggested to import Gradle projects, accept the suggestion: Gradle will download Rider SDK and set up all necessary dependencies.rider-fsharp
uses the gradle-intellij-plugin Gradle plugin that downloads the IntelliJ Platform SDK, packs the F# plugin and installs it into a sandboxed IDE or its test shell, which allows testing the plugin in a separate environment.Open the Gradle tool window in IntelliJ IDEA (View | Tool Windows | Gradle), and execute the
rider-fsharp/prepare
task. -
if using Gradle command line:
$ cd ./rider-fsharp $ ./gradlew prepare
-
-
Open
ReSharper.FSharp.sln
solution and build using theDebug
configuration. The output assemblies are later copied to the frontend plugin directories by Gradle. (If you're seeing build errors in Rider, choose File | Settings | Build, Execution, Deployment | Toolset and Build, and in the Use MSBuild version drop-down, make sure that Rider uses MSBuild shipped with .NET Core SDK.) -
Launch Rider with the plugin installed
-
if using IntelliJ IDEA:
Open the Gradle tool window in IntelliJ IDEA (View | Tool Windows | Gradle), and execute the
intellij/runIde
task. This will build the frontend, install the plugin to a sandbox, and launch Rider with the plugin. -
if using Gradle command line:
$ ./gradlew runIde
-
- Build the
Debug
configuration inReSharper.FSharp.sln
. - Execute the
buildPlugin
Gradle task. - Install the plugin (
rider-fsharp/build/distributions/*.zip
) to your Rider installation from disk.
We welcome contributions that address any F# plugin issues that are open in Rider's issue tracker. Some of these issues are marked as Up for grabs: we expect issues tagged this way to be easier addressed by external contributors as they are unlikely to require any changes outside the F# plugin. Note that some issues are marked as third-party problems, and addressing them requires fixes from FCS or other projects that this plugin depends on.
If you are willing to work on an issue, please leave a comment under the issue. Doing this will make sure that the team doesn't start working on the same issue, and help you get any necessary assistance.
New code is usually written in F#, except for the FSharp.Psi
project that is written in C#.
As soon as you are done with changes in your fork, please open a pull request for review.
Note that the public CI server is not set up at this point but it's going to be available shortly.
We suggest that you read docs on the two SDKs that this plugin uses:
The main development branch is changed on each release (i.e. net212
correspond to 2021.2 development cycle), and builds from this branch are bundled with nightly Rider builds available via JetBrains Toolbox App.
By default, the project depends on nightly SDK builds, but a specific SDK version can be referenced in rider-fsharp/build.gradle if necessary.
Gradle downloads a newer SDK from time to time. To force an update, run the prepare --refresh-dependencies
Gradle task.
To debug the backend, attach debugger to the ReSharper.Host process launched via the runIde
Gradle task. To debug the frontend, start the runIde
task in Debug mode.
Rider's JVM-based frontend and .NET-based backend communicate using RdProtocol with APIs available on both sides. For backend-frontend communication in plugins, RdProtocol should be used as well. Protocol model is defined in this file.
Running backend tests is not yet possible on macOS and Linux.