I would much rather they don't do that and instead offer tools that can answer IDE-like queries (e.g. "Who calls this function?", "Where is this identifier defined?", etc.) and let people integrate that into Emacs, Vim, Atom, and other editors and IDEs. This brings all the communities together and doesn't dictate one particular tool over all others.
https://www.rust-lang.org/ides.html
>We propose a new tool, an 'oracle' which takes input from the compiler, maintains a project-wide view of the code and it's type information, and provides data about the project to IDEs and other tools. The oracle is a long-running daemon and presents an API via IPC.
Which is great idea. But it is not implemented yet (AFAIK).
personal opinion : Rust with this pace, will be absolutely one of the best language in term of usage/tools in next 5 year.
Java doesn't have really good canonical tools that ship with the JDK nor is there a necessarily an industry preferred choice (Javadoc is probably the only exception). This of course includes more than just build tools. The fragmentation is huge.
For example Java doesn't have a defined format tool like gofmt or rustfmt nor does it have a preferred build/dep system like crate (there are several ... maven, gradle, ant). Even more annoying is that unlike code completion and refactoring tools (Rust racer) for Java are tightly coupled with the IDE and there are really only two choices: morbidly obese and broke: Eclipse or trust fund expensive but works: intellij.
With Racer you can use whatever editor or IDE you like. I wish I had something like that for Java.
I think calling IntelliJ "trust fund" expensive is rather extreme. My company pays substantially more for my Visual Studio license than I do for my personal JetBrains All-Products subscription, $150/yr (which breaks down to $12.50/mo) saves me far more than 5 hours of time between all the work I do in IntelliJ, DataGrip, PyCharm, WebStorm and soon Rider (7 seconds to open a solution that takes Visual Studio 30 seconds to load and without the constant lockups - now I just need it to be able to run/debug ASP.net apps and run NUnit tests).
We too use intellij as well jrebel and these tools pay for themselves fairly quickly.
TL;DR: There exist Rust plugins for Eclipse, IntelliJ, Visual Studio, Atom, Emacs, Sublime Text, Vim, and VS Code.
We're also working on ways to improve the compiler to better support the IDE use case: https://github.com/rust-lang/rfcs/pull/1317
I will try to give another chance to Rust in half year and see if it improved.
But I would suggest to look at Swift SourceKit https://github.com/apple/swift/tree/master/tools/SourceKit or OmniSharp http://www.omnisharp.net/ SourceKit provides really nice Swift support in Xcode. If you can deliver same thing built on top of VSCode, Intellij IDEA with integrated debugger, I am sold.
- Be able to see inferred type
- Be able to see documentation for types and methods
- Better auto completion was sometimes suggesting non senses and after selecting it placed a cursor on wrong place
- Integrated debugger
- Go to definition (including Rust std)
- Syntax checking
- Integrated formatter
> - Be able to see inferred type
https://github.com/phildawes/racer/issues/304
> - Be able to see documentation for types and methods
https://github.com/phildawes/racer/issues/415
> - Better auto completion was sometimes suggesting non senses and after selecting it placed a cursor on wrong place
Seems like a bug, never experienced this myself though.
> - Integrated debugger
I'm currently using nemiver and atom-gdb to set breakpoints from within Atom and launch nemiver. But you're right: A great integrated debugger would be awesome :)
> - Go to definition (including Rust std)
This works with atom-racer: Ctrl+Shift+P and type "racer find definition"
> - Syntax checking
https://atom.io/packages/linter-rust
> - Integrated formatter
https://github.com/rust-lang-nursery/rustfmt/blob/master/ato...
> This works with atom-racer: Ctrl+Shift+P and type "racer find definition"
Nice, unfortunately it works only for my methods and not for std.
> - Syntax checking
Oh, you right, I got wrong path to Cargo so it didn't work out of box but still it is not like you have it in IDE and you don't see errors as you type but you need to save.
> - Integrated formatter
Cool, thanks!
That's strange. It works for me for std, too. Have you set RUST_SRC_PATH?
Among similarly new language, I think the strength of the tooling is one of the notable positives of Rust.
> and maybe introduced officially supported IDE
While I get that some programmers prefer IDEs and that IDEs might actually be generally preferable for some Rust use cases, I think there is a lot more utility in the Rust team focusing on lower-level tooling (which IDE and enhanced-editor-plugin developers can leverage) rather than focusing on an officially supported IDE.
Agreed, I hope that a good "Language service" API is on the horizon, so that tool authors don't need to reinvent the wheel in order to support parsing, error display, highlighting, completions and so on.
A step in the right direction is the possibility of getting machine-readable (json) error messages from the compiler.
Being able to just call the compiler as a library to produce AST's from source would be very handy, though it would probably complicate the compiler to be able to provide useful output from broken/incomplete source, which is critical for tool use.
https://github.com/rust-lang/rfcs/pull/1317
Nim does a good job with their IDE support
What makes you say this? Many programmers don't use IDEs or anything.
However, some programmers like an IDE more. Which is fine, but for this type of programmer, Rust still has a long way to go. There are some immature plugins for existing IDEs, and even a couple "rust-specific" IDE projects, but nothing near what (say) Java or C# have.
[1]: https://github.com/murarth/rusti [2]: https://play.rust-lang.org/
This is a very hard feature for compiled languages, its just a con of this execution model (which is has a lot of pros).
It also has tools for code completion (Racer), build orchestration (Cargo again), benchmarking (the built-in benchmark runner), compiler version management (multirust), and automatic source code formatting (rustfmt, though this one's a WIP).
In Swift you can just Cmd+Click to do this (assuming SourceKit hasn't crashed) and it's very useful for that kind of exploration.
The way forward on that front would require, IMO, some external actor to smell profit in a Rust IDE. That has been sloooowly becoming more likely as the stdlib inches toward stability.
That said, in my brief experience with rust I got the impression that their tooling is very high quality for something so new. Have you seen how pretty their compiler error messages are, for example?