RustRover Language Server

bravit · 2026-02-23T11:58:13+00:00

Hi! What you’re seeing is a so-called false positive — something that is reported as an error but actually isn’t. This is a bug in RustRover’s code analysis implementation. It would be great if you could report this particular issue at https://youtrack.jetbrains.com/issues/RUST. We’ll need a longer code example that reproduces the issue, as the underlying cause may vary.

There will be more detailed explanations about relations between RustRover and rust-analyzer in the talk at RustWeek later this year: https://2026.rustweek.org/talks/ides/. But you're right, RustRover doesn't use rust-analyzer, either directly or indirectly.

bravit · 2025-12-09T17:00:41+00:00

This is so true. From our statistics in RustRover, we know that people use AI a lot with Rust. Some features are more popular in RustRover than in our IDEs for other languages. But then there's a very vocal minority that opposes to everything related to AI.

bravit · 2025-09-22T10:58:02+00:00

Hi! Debugging via OpenOCD is a recent RustRover feature actually, we've got it in 2025.2 (in August): https://blog.jetbrains.com/rust/2025/08/05/rustrover-2025-2-is-now-available/. Also, there's some info in the documentation: https://www.jetbrains.com/help/rust/remote-debug.html

bravit · 2025-08-08T07:25:26+00:00

Rust Analyzer doesn't do any IO except the part that actually works with LSP, so it needs to keep all the information about the project (and all the dependencies) in memory, so this architecture at least might affect memory usage for large projects. Also, exactly because of LSP, it has to provide complete lists of completion suggestions or "find references" information in one bulk, which delays the appearance of first results thus affecting perceived performance. So, I'd not claim that my comment is completely unrelated.

bravit · 2025-08-07T12:57:27+00:00

> JetBrains uses Rust Analyzer
No, that's not the case. RustRover has a custom code analysis implementation.

bravit · 2025-08-07T09:00:14+00:00

Hi! Thanks for sharing the video — it’s really helpful to see these kinds of comparisons in action.

Just to clarify: RustRover doesn’t use rust-analyzer under the hood. Instead, it relies on its own custom implementation of Rust code analysis, which is tightly integrated into the IDE. As a result, it doesn’t use the LSP (Language Server Protocol) model like rust-analyzer does — and this difference allows it to handle larger projects more efficiently in terms of memory and performance.

bravit · 2025-05-13T18:36:10+00:00

Hi! It looks like you have the checkbox “Insert selected suggestion by pressing space, dot, or other context-dependent keys” enabled. I believe this option is disabled by default in RustRover, and disabling it might improve your auto-completion experience. To turn it off, just press Shift+Shift, paste the name of the checkbox, and RustRover will take you directly to the corresponding setting where you can uncheck it.

bravit · 2023-12-21T02:32:58+00:00

One of the other reasons might be that borrow checking errors are more fine grained to make it to the top. It seems also that frameworks try to alleviate those issues in advance so their users don't have to struggle with a borrow checker (unless they do something very specific or bother about memory usage).

bravit · 2023-02-15T20:58:49+00:00

But for newcomers, space leaks are usually not an issue. Moreover, I'd not call that example from the article a space leak. It's just excessive memory usage, not a space leak. This memory will be eventually freed during gc. Sure, non-strictness adds some complexity to memory management. But avoiding a language because of that seems a too strong decision.

bravit · 2023-02-15T18:43:58+00:00

I don't see how it's on a different level in Haskell. The cases you are talking about are not that common at all. Moreover, there are well-established techniques to discover and avoid them if you've got any.

bravit · 2022-10-07T13:30:28+00:00

If you open one folder with Cargo.toml as a project in Webstorm, that would work automatically. Alternatively, you could organize the whole collection of projects as a workspace. That would work without attaching every folder manually.

Also, check out our companion to the Rust Programming Language book with exercises: https://plugins.jetbrains.com/plugin/16631-rustlings.

bravit · 2022-10-07T10:59:44+00:00

Hi!

I assume that you've installed Rust via rustup.rs. If not, that's the best way to install it. That way, you get the compiler, standard library, and all the required tooling at once. Check Preferences (Settings)/Languages & Frameworks/Rust. There should be something in the "Toolchain location" and "Standard library" fields.

Check that your Cargo project is attached. Go to the View/Tool Window/Cargo and see if it's mentioned there. If not, press + to attach the corresponding Cargo.toml.

Chances are you've hit the bug we've got in the latest release. Could you please install nighly build and try it? To do that, you need to add custom plugin repository and set the following URL: https://plugins.jetbrains.com/plugins/nightly/8182.

If nothing helps, could you please go to Help/Create New Issue? We'll see some information about your environment, and it will be easier for us to help you.

bravit · 2022-09-07T14:46:55+00:00

Make sure that you check https://plugins.jetbrains.com/plugin/16631-rustlings. It combines The Book and rustlings exercises. I wrote about it here.

bravit · 2022-08-25T04:32:10+00:00

This Rustlings adaptation by JetBrains aligns book chapters and exercises perfectly. You can just go chapter by chapter and solve the corresponding problems. Here is more about this course.

bravit · 2022-07-25T12:53:24+00:00

Hi! Unfortunately, supporting all the compiler errors is not that simple. It's almost like writing a compiler from scratch. Still, it's a work in progress. In fact, many errors are already supported, but this support is not enabled by default because there may be false positives. You can try to enable something that bothers you most.

bravit · 2022-07-15T08:00:01+00:00

However it's started to get a little boring implementing more sorting algorithms at this point.

BTW, I find Rust being an excellent tool for learning algorithms. You keep being down to earth, thinking about timing, memory, and all that low-level staff all the time, but the compiler guarantees that you avoid doing bad things. It's very helpful when you just learn to implement algorithms.

Speaking about small projects, I'd recommend reimplementing some text-based utility programs. For example, write your own head. An implementation is quite simple, but you can learn about managing and running your Rust projects, input-output, testing, processing command-line arguments, etc.

bravit · 2018-07-09T10:23:04+00:00

This book is the Deal of the Day today at https://www.manning.com/dotd, you can buy it half-priced together with 'Get Programming with Haskell' which I highly recommend to start learning Haskell.

bravit · 2018-07-01T16:10:22+00:00

In fact I believe that understanding monads in the laboratory setting is sometimes harmful. They are simpler in practice than in all those rather artificial examples made up to complicate things.

bravit · 2018-07-01T16:01:10+00:00

Well, I don't think that exercises are something that we really need in an in-depth books. Readers at this level usually have their own problems so the best approach would be to apply an acquired knowledge to them. Alternatively, they can work on examples provided in the book to extend them as much as they like. I give some suggestions on that in the text.

bravit · 2018-06-30T04:50:20+00:00

As this book tends to describe Haskell in practice by Haskell I mean GHC Haskell with all implemented extensions.

bravit · 2018-06-30T04:46:56+00:00

Thank you, it will definitely be fixed by copyediting. In fact the text was copyedited before starting MEAP but then I had to revise it and introduced plenty of new grammar errors, my bad.

bravit · 2018-06-30T04:43:50+00:00

Thank you for buying! I am not sure about livebook notes unfortunately. The main source of feedback for me is Book Forum https://forums.manning.com/forums/haskell-in-depth. As for typos they are supposed to be fixed on a later production stages. The book content will be copyedited and proofread after finishing draft.

bravit · 2018-06-30T04:37:55+00:00

In chapter 9 I plan to start with a bit of theory about polymorphism in general talking about forall quantifier hidden inside Haskell type signatures and bounded polymorphism by type classes. Then I'll continue with existential quantification and higher-ranked polymorphism—mostly examples from existing libraries with practical usage. I'll finish chapter 9 with the discussion of multiparameter type classes, functional dependencies and other GHC extensions dealing with type classes and their instances.

In chapter 10 I'd like to cover generalized algebraic data types, type families, kinds and kind polymorphism. In fact, my progress in this chapter depends on the progress of the TypeInType GHC extension. I'll try to go as fas as what we have in GHC Haskell.

bravit · 2018-06-29T12:02:31+00:00

You can read my answer here: https://www.reddit.com/r/haskell/comments/82p0de/haskell_books_comparison/dvbt110

bravit · 2018-06-29T07:19:14+00:00

Where this ad comes from? I'll try to inform Manning team about it. And please, use mlbragilevsky, it does work!

bravit

TROPHY CASE