Introduction
Considering Rust’s popularity it is quite surprising that no dedicated IDE has come out for this language. That all changed today, the 13th of September 2023, when RustRover, Jetbrains’s new Rust came out in Preview. Of course, I could not resist trying it out, and try it out. Spoiler: it is excellent.
Later this week I will discuss RustRover on my youtube channel, this will be a very preliminary look. The link to the video will be shared here, keep watching this space.
Caveat: I am sharing my impressions about the preview version, and this should not be considered a full review. I am testing this on a 10 year old laptop with a 500 GB SSD and 12 GB memory.
Installation
You can install RustRover in two ways:
- Downloading it from the Jetbrains page
- Using the Jetbrains toolbox app, this is usually the method I prefer (I use other Jetbrains products as well)
Rustrover’s installation is straightforward, at least on Windows. Also the startup speed is quite decent.
Imagine my excitement when I saw this screen:
After the usual screens about privacy and sharing your experiences (which I allowed, not something I normally do), you are presented with this screen:
As you can see RustRover, or Rover for short, seems to built on solid ground.
Using it
I decided to open an existing project, which can be found here to test out some of Rover’s capabilities.
This looks quite normal and familiar. The only thing is that indexing the files and updating the crates index takes quite a long time. Whether this is due to the relative age of my laptop or the fact that I am dealing with a preview version I am not sure.
As you can see is quite a standard view. Let us open a file:
I find three things noticeable:
- The usages annotations
- The type annotations
- The small I in the green circle, indicating that the struct has implementations
Now let us see how Rover can help us code, take this simple trait and struct:
Now we will see how Rover can help us:
The autocomplete list seems correct and fitting. We go on:
Again this seems ok. And we go on:
Ok, this seems ok as well. It would have been nice to have an ‘implement trait’ refactoring, but this alone is a big help when coding
Now for completeness’ sake the finished product looks like this (a trivial implementation):
In my upcoming video I will look at more refactorings. What is noticeable is the correctness and the speed of the autocompletion
Debugging
Another thing I want to touch upon this first impression is debugging. Debugging is important, even for a language like Rust which forces developers to write correct code.
You can set all kinds of breakpoints, like permanent breakpoints, conditional breakpoint and once-hit breakpoints, which are removed after hit for the first time.
Furthermore you can view the state of the local and global variables realtime. The debugging experience, even in this preview version is quite good. A first look:
The breakpoint has been set. Now we run the program.
I must say that I found, but maybe I looked in the wrong place, that you have to manually add a Cargo-configuration. Maybe this can be made automatic.
Either way, after hitting the breakpoint you can see this:
Honesty commands me to tell you that I hit ‘step into’ once, and ‘step over’ twice. In the variables pane in the lower left you can see the value, even of the struct, which is a huge improvement over the old Rust debugger:
Conclusion
Considering this is a public preview it looks very promising. Especially the debugging capabilities seem to be impressive. Yet to make it a polished product many things have to happen, but knowing Jetbrains those will happen.
I encourage you all to download (and install) this IDE and try it out.
Later this week I will post a more extensive review on youtube, a link to that will be found on this page.
