Rust Language Server VS polonius

In the last there was RLS that did exactly that. But the approach of rust-analyzer was found to be more performant.

LSP support seems to be lacking as well, at least rust doesn't seem to have Cargo.toml support? https://github.com/rust-lang/rls/issues/785

apparently, it means that you're using the old RLS-based Rust plugin for VS Code, rather than the rust-analyzer plugin. You probably won't see a lot of people familiar with RLS's error messages.

Why: The rust-analyzer extension integrates with rust-analyzer, an alternative language server for Rust. rust-analyzer tends to perform better and get less confused with your code as compared to RLS, which the Rust extension uses.

I have tried writing websites with rust instead of JavaScript. Unfortunately, the tooling is just not there. More specifically, I am talking about wasm-bindgen, which provides two-way bindings. The problem with it is that since all the declarations are generated with build.rs, there is no autocompletion. Since I am spoiled by modern tooling, no autocompletion to me means not feasible pass demo stage. (https://github.com/rust-lang/rls/issues/1489)

Aside from the lack of autocompletion, passing rust closures to js land (DOM) is extremely janky as well. However, that might be caused by my lack of experience with rust.

(If you are curious, this is what I made: https://github.com/SCLeoX/non-grid-path-finder)

Python the core devs don't care about tooling and they have IDE's, Java is an enterprise monolith so IDE's are the standard, Rust yes it is (https://github.com/rust-lang/rls), Elm I have no idea I don't use it.

Correctness prover which uses lifetimes (Polonius).

And, well, polonius (Rust borrow checker magic) I believe is built on datalog-ish concepts: https://github.com/rust-lang/polonius

There is also polonius (https://github.com/rust-lang/polonius) which should replace the borrow checker but does not receive a lot of development resources.

This is eventually going to be a feature-complete compiler, targeting a specific rustc version. I believe the plan is to use polonius [1], presumably as an "optional" feature so they can build a stage 1 without it, use that to build polonius, then build the final compiler with it included.

[1] https://github.com/rust-lang/polonius

E.g. there you may just stop using current borrow-checker and switch to Polonius.

The borrow checker is too dumb (https://github.com/rust-lang/polonius) fixes a lot of this.

It looks like an official borrow checker implementation called Polonius uses it as a dependency, so it makes sense: https://github.com/rust-lang/polonius/blob/981785c101b68ff54...

If you click around a little, you end up on a blog post with this tidbit:

> This project got put together rather suddenly, in response to some work the Rust folks are doing[1] on their new and improved borrow checker.

I don't think I could tell you more than "Frank wrote it to help rust folks who were previously doing work with differential-dataflow directly."

1. https://github.com/rust-lang/polonius/pull/36#issuecomment-3...

Good news is that there's also works going on to relax the restrictions, like polonius. But it seems that it still have a long way to go before it can land in stable Rust...

GCC-rs isn't intended for bootstrapping, it is intended to be an actual fully featured Rust compiler in the future, mrustc is a Rust compiler intended for bootstrapping though. GCC-rs is still very early targeting an older version of the reference compiler without things like a borrow checker, but that's not going to be the case forever. The GCC-rs folks have expressed interest in re-using the borrow checker library used by the reference compiler called polonius enabling them to relatively easily add borrow checking.