Skip to main content

Setting Up Your Development Environment (Part 2): Configuring VS Code

In the previous article, we installed the Rust toolchain and the rust-analyzer extension for Visual Studio Code. Now, let's dive deeper and explore how to configure your editor for a truly productive and ergonomic Rust development experience.

📚 Prerequisites​

Before we begin, you should have:

  • The Rust toolchain installed (via rustup).
  • Visual Studio Code installed.
  • The rust-analyzer extension installed in VS Code.

🎯 Article Outline: What You'll Master​

In this article, you will learn how to:

  • ✅ Enable Format on Save: Keep your code clean and consistent automatically.
  • ✅ Use Clippy for Advanced Linting: Catch a wider range of issues and learn idiomatic Rust.
  • ✅ Configure Inlay Hints: Get useful contextual information directly in your code.
  • ✅ Set up Debugging: Use the VS Code debugger to step through your Rust code.

🧠 Section 1: Format on Save​

One of the first things you should set up is automatic formatting. The Rust toolchain includes a tool called rustfmt that automatically formats your code according to the official Rust style guide. This saves you time and ensures that your code is always clean and readable.

To enable format on save in VS Code:

  1. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P on Mac).
  2. Search for "Preferences: Open User Settings" and select it.
  3. In the search bar of the Settings UI, type "Format On Save".
  4. Make sure the checkbox for "Editor: Format On Save" is checked.

Now, whenever you save a Rust file, rust-analyzer will use rustfmt to automatically format it.

💻 Section 2: Supercharge Your Linting with Clippy​

The Rust compiler is excellent at catching errors, but Clippy takes it a step further. Clippy is a collection of lints that checks your code for a wide range of common mistakes, performance issues, and un-idiomatic code. It's an invaluable tool for learning to write better Rust.

You can configure rust-analyzer to use Clippy for its checks instead of the standard cargo check.

  1. Open your settings.json file (you can find it via the Command Palette: "Preferences: Open User Settings (JSON)").
  2. Add the following line: 
    "rust-analyzer.check.command": "clippy"

Now, when you save your file, rust-analyzer will run cargo clippy in the background, and you will see Clippy's suggestions directly in the editor's "Problems" pane.

🧠 Section 3: Understanding Inlay Hints​

rust-analyzer provides "inlay hints" to show you useful information directly in your code. These are not part of your actual code but are rendered by the editor to provide extra context.

By default, rust-analyzer shows hints for chained method calls and inferred types. For example:

// With inlay hints, you might see the inferred type `i32` here
let my_number = 5;

// And you'll see the types of each step in the chain
let words = vec!["hello", "world"];
let upper_words: Vec<String> = words.iter()
                                    .map(|s| s.to_uppercase()) // <- map: impl FnMut(&&str) -> String
                                    .collect();                // <- collect: Vec<String>

You can configure these hints in your settings.json file. For example, to turn off the hints for chained methods, you could add:

"rust-analyzer.inlayHints.chainingHints.enable": false

It's worth exploring the rust-analyzer.inlayHints.* settings to see what's available and customize it to your liking.

🛠️ Section 4: Setting Up the Debugger​

To debug Rust code in VS Code, you need to install a debugger extension. The recommended extension is CodeLLDB.

  1. Go to the Extensions view in VS Code.
  2. Search for CodeLLDB and install it.

Once CodeLLDB is installed, you can debug your Rust code just like you would in any other language:

  1. Open the Rust file you want to debug (e.g., src/main.rs).
  2. Set a breakpoint by clicking in the gutter to the left of the line numbers. A red dot will appear.
  3. Go to the Run and Debug view in the Activity Bar.
  4. Click the "Run and Debug" button. VS Code will ask you to select a debugger. Choose "LLDB".

VS Code will then build and run your program with the debugger attached. The execution will pause at your breakpoint, and you can inspect variables, step through the code, and use the debug console.

✨ Conclusion & Key Takeaways​

With these configurations, your VS Code is now a powerful and ergonomic IDE for Rust development. You have a setup that will help you write clean, correct, and idiomatic Rust code more efficiently.

Let's summarize the key takeaways:

  • Automate Formatting: Use rustfmt with format-on-save to keep your code clean.
  • Embrace Clippy: Use Clippy to learn best practices and catch more errors.
  • Customize Inlay Hints: Tailor the hints to your preferences to get the right amount of context.
  • Use the Debugger: Step through your code with CodeLLDB to understand how it works and to fix bugs.

Challenge Yourself: Create a new project with cargo new. Add a simple loop to main.rs. Set a breakpoint inside the loop and run the debugger. Can you step through the loop and watch the value of the loop variable change?

➡️ Next Steps​

You are now fully equipped to write, analyze, and debug Rust code. In the next article, "Your First Rust Program: 'Hello, World!' (Part 1)", we will finally write and run our first Rust application using the environment we've just set up.

The setup is complete. The real journey begins now.

Glossary (Rust Terms)​

  • Linting: The process of running a program that analyzes code for potential errors, bugs, stylistic errors, and suspicious constructs.
  • Clippy: A popular and powerful linter for Rust.
  • Inlay Hints: Additional information about the code that is rendered by the editor but is not part of the code itself.
  • Debugger: A tool that allows you to run a program in a controlled manner, pausing execution to inspect the program's state.

Further Reading (Rust Resources)​