IntelliJ Rust: Updates for 2022.3

The results of the Developer Ecosystem Survey 2022 are in! Every year JetBrains conducts a survey to deepen our knowledge of the developer community and how it has changed over the past year.  Let’s dive into the report’s findings with the help of three members of the Rust community: Work or hobby?  The share of developers using Rust for work grew from 16% in 2020 and 2021 to 18% in 2022. Expert analysis Florian: “I’ve noticed that although Rust is growing, the relative numbers here are staying the same. That's good! It means the number of Rust hobbyis

We use a lot of tools for software development. Compilers, linkers, package managers, code linters, and, of course, IDEs are essential parts of our work and life. There are areas where single-tool efforts are not enough to provide the best user experience. In Rust, macro support is definitely something we can’t wholly tackle without broad community understanding and collaborative effort. We, the IntelliJ Rust plugin team, are now partially enabling support for procedural macros, specifically enabling function-like and derive procedural macro expansion by default while hiding support for att

Hello, We are interested in learning how exactly Rust and C/C++ ecosystems coexist. That’s why we’d like to learn from Rust developers about their experience and best practices with C and C++ code in their Rust code base. We would appreciate it if you could take 5 minutes to fill out a survey. The data will be used internally to further develop JetBrains Rust tools and their positioning in the ecosystem. We might publish some anonymized summaries later on our website, blog, twitter, or other outlets. SHARE EXPERIENCE We’ll hold a raffle where selected participants will receive Amazon gift ca

Build scripts is a Cargo feature that allows executing any code prior to building a package. We implemented support for build scripts evaluation in the IntelliJ Rust plugin a long time ago, but up until now, we hid it under the org.rust.cargo.evaluate.build.scripts experimental feature. As we are now enabling this feature by default, we’ve decided to explain what it means for our users. What is a build script, and why should we care? Most Rust projects use build scripts to deal with native dependencies, configure platform-specific options, or generate some source code. Let’s recall the b

In this release cycle, we’ve enabled a new approach for detecting changes in configuration files, as well as a new way to reload project models. We’ve improved performance and implemented various type inference improvements. IntelliJ Rust now highlights outdated or missing dependencies in Cargo.toml. The plugin can convert JSON to structs via copy-paste. There are plenty of other features and improvements – to learn about them all, read the detailed description below. Language Support Project model reloading In v2022.2, we’ve improved the way IntelliJ Rust updates the projec

In our previous blog post, we discussed the essence of Rust’s procedural macros. Now we invite you to dive deeper into how they are processed by the compiler and the IDE. Compilation of procedural macros To start, let’s see how we might write a ‘Hello, world’ program using a separate crate inside a procedural macro: In order to build this project, Cargo performs 2 calls to rustc:  cargo build -vv rustc --crate-name my_proc_macro --crate-type proc-macro --out-dir ./target/debug/deps my-proc-macro/src/lib.rs rustc --crate-name my-hello-world --crate-type bin --out-d

In this release cycle, we’ve improved our language support, code insight, run/debug support, and tool integrations, and added many enhancements and fixes.  Language Support Single-step macro expansion  We’ve significantly improved how macro expansion works. Previously the macro expansion process was implemented in multiple steps – up to 64. The indexing would start after every step. This approach was not ideal. First, the macro expansion was slower than it could be because the cache memory would be cleared out at the end of indexing. And second, multiple steps caused

Have you ever wondered how Rust’s procedural macros work? In this blog post series, we will get into the details! A member of our team, Vladislav Beskrovny, recently gave a talk on the topic at RustCon. This series is based on that talk, with some slight modifications and additions. In this post, we’ll look at the basics of macros in Rust and get into the procedural macros specifics, paying close attention to their API. Macros in general Macros are everywhere in Rust, but there are some programming languages that don’t use them at all. Let’s investigate what macros are and what opportunities

In this release cycle, we focused on enriching language support and adding more code insight features. The run and debug functionality has received a few major updates, too. Read on to learn the details. (more…)

Almost two years ago, we published a blog post on the essentials of debugging Rust in CLion. It’s still a great reference for the general debugging procedure. In this blog post, we would like to summarize what’s been improved and updated since then, and also discuss how you can debug with IntelliJ Rust not only in CLion but in other JetBrains IDEs as well. (more…)

For IntelliJ Rust, this release cycle has been full of significant updates. We have added new functionality to language support, code insight, and run/debug support, along with many fixes and smaller enhancements. (more…)

This is the first entry we are publishing in a dedicated blog for IntelliJ Rust! Previously hosted on the CLion blog, our articles were tied closely to that particular IDE. From now on, we’ll be describing the plugin’s news and features with regard to all the IDEs it’s compatible with. Have you already explored the documentation we released a while ago? If not, we encourage you to check it out! It describes the plugin in full detail and also gives some general IDE-related info. Our documentation system is still in active development on both the frontend and the content edge, so your feedback i