rust-analyzer: The Rust Language Server

20 min read

rust-analyzer is the official Language Server Protocol (LSP) implementation for Rust. It is the engine behind autocomplete, go-to-definition, inline type display, refactors, and red squiggles in your editor. If you used the TypeScript Language Service (the brains inside VS Code’s TypeScript support), rust-analyzer is its direct counterpart for Rust.

Quick Overview

When you edit .ts files, VS Code talks to tsserver — the TypeScript Language Service — which gives you completions, hovers, rename, and inline errors. Rust has the exact same architecture: your editor talks to rust-analyzer over the Language Server Protocol, and rust-analyzer continuously parses and type-checks your crate in the background.

Why it matters to a TypeScript/JavaScript developer: Rust’s compiler is strict, and a tight feedback loop is what makes that strictness pleasant instead of painful. rust-analyzer shows you the inferred type of every let binding, surfaces E0308 type mismatches as you type (not on save), and offers one-keystroke code actions to fill in match arms or implement a trait. The current stable toolchain is Rust 1.96.0 on the 2024 edition, and rust-analyzer ships as an official rustup component that tracks it.

TypeScript/JavaScript Example

In a TypeScript project, the language service is invisible but always running. You never install it directly — it ships with VS Code (or with the typescript package your editor points at). It powers everything that isn’t the type-checker on the command line:

1
// orders.ts — what tsserver does for you while you type
2
interface Order {
3
  id: string;
4
  total: number;
5
  items: string[];
6
}
7

8
function summarize(orders: Order[]) {
9
  // Hover over `expensive` → tsserver shows: const expensive: Order[]
10
  const expensive = orders.filter((o) => o.total > 100);
11

12
  // Type `.` after `expensive` → completion list of Array methods
13
  // Type `o.` inside the callback → completion list of Order fields
14
  const ids = expensive.map((o) => o.id);
15

16
  // Inlay hints (an opt-in editor setting) render the inferred types inline:
17
  //   const ids: string[]
18
  return ids;
19
}
20

21
// Red squiggle appears immediately, before you save or run `tsc`:
22
const broken: number = "not a number";
23
//    ^^^^^^ Type 'string' is not assignable to type 'number'. ts(2322)

You configure tsserver through .vscode/settings.json (and the typescript.* / javascript.* keys), e.g. turning inlay hints on:

1
// .vscode/settings.json (TypeScript side)
2
{
3
  "typescript.inlayHints.parameterNames.enabled": "all",
4
  "typescript.inlayHints.variableTypes.enabled": true
5
}

Rust Equivalent

rust-analyzer plays the identical role. You install it once as a rustup component (your editor extension usually does this for you), and configure it through the rust-analyzer.* keys:

1
// src/main.rs — what rust-analyzer does for you while you type
2
use std::collections::HashMap;
3

4
fn parse_port(raw: &str) -> Result<u16, std::num::ParseIntError> {
5
    raw.trim().parse()
6
}
7

8
fn main() {
9
    // Inlay hint renders `: i32` after `count` (i32 is the default integer).
10
    let count = 3;
11
    let names = vec!["alice", "bob", "carol"];
12

13
    // Chaining hints reveal the iterator's item type at each `.method()`:
14
    let upper: Vec<String> = names
15
        .iter()
16
        .filter(|n| n.len() > 3)
17
        .map(|n| n.to_uppercase())
18
        .collect();
19

20
    let mut scores = HashMap::new();
21
    scores.insert("alice", 10);
22
    scores.insert("bob", 7);
23

24
    // Inlay hint renders `: i32` after `total`.
25
    let total: i32 = scores.values().sum();
26

27
    match parse_port("8080") {
28
        Ok(port) => println!("port = {port}"),
29
        Err(e) => println!("bad port: {e}"),
30
    }
31

32
    println!("count={count}, upper={upper:?}, total={total}");
33
}

Running this prints:

1
port = 8080
2
count=3, upper=["ALICE", "CAROL"], total=17

And you enable the inline type display through rust-analyzer.* settings, the direct analog of the typescript.inlayHints.* keys:

1
// .vscode/settings.json (Rust side) — these are ON by default
2
{
3
  "rust-analyzer.inlayHints.typeHints.enable": true,
4
  "rust-analyzer.inlayHints.parameterHints.enable": true,
5
  "rust-analyzer.inlayHints.chainingHints.enable": true
6
}

Note: Installing rust-analyzer is a one-liner: rustup component add rust-analyzer. Most editor extensions (the VS Code “rust-analyzer” extension, the Zed/Neovim LSP clients) download and manage it for you, so you rarely run this by hand. See vscode-setup.md for the full editor walkthrough.

Detailed Explanation

What an LSP server actually is

The Language Server Protocol is a JSON-RPC contract Microsoft designed so that one language implementation can serve every editor. tsserver and rust-analyzer both speak it. Your editor (the client) sends requests like “what completions are valid at line 12, column 8?” and the server answers. This is why the same rust-analyzer binary powers VS Code, Neovim, Helix, Zed, and Emacs identically — the intelligence lives in the server, not the editor.

rust-analyzer is its own type-checker, not a `cargo check` wrapper

This is the single most important thing to understand, and it is subtler than the TypeScript case. tsserver and tsc share the same type-checking core. rust-analyzer, by contrast, contains its own parser, name resolver, and trait-solving type inference engine — separate from rustc. That is what lets it give you instant feedback on a half-typed expression that rustc would refuse to even parse.

You can see rust-analyzer’s independent analysis directly. Running its diagnostics engine over a project with a type error produces (real output, abbreviated):

1
processing crate: probe, module: .../src/main.rs
2
Error RustcHardError("E0308") from LineCol { line: 1, col: 20 } to LineCol { line: 1, col: 26 }: expected u16, found &'static str
3

4
diagnostic scan complete

That expected u16, found &'static str came from rust-analyzer’s own inference, before cargo ran. rust-analyzer also runs the real compiler in the background (cargo check by default) and merges those richer diagnostics in — see the next section.

`check` on save vs. live diagnostics

rust-analyzer shows you two tiers of diagnostics:

Live, in-memory diagnostics from its own engine — type mismatches, unresolved names, syntax errors — updated keystroke-by-keystroke.
Full compiler diagnostics from running cargo check (the rust-analyzer.check.command, default "check") when you save. These include borrow-checker errors and every Clippy lint if you point it at Clippy.

The settings that control tier 2 are rust-analyzer.checkOnSave (default true) and rust-analyzer.check.command (default "check"). A common upgrade is to run Clippy instead of plain check:

1
{
2
  "rust-analyzer.checkOnSave": true,
3
  "rust-analyzer.check.command": "clippy"
4
}

Warning: Use the modern rust-analyzer.check.command key. The older rust-analyzer.checkOnSave.command (a string command nested under checkOnSave) is deprecated. Today checkOnSave is a plain boolean and the command lives in check.command. The deprecated form is one of the most common stale-blog-post traps; vscode-setup.md covers it in detail. Wiring Clippy in is covered in linting.md and clippy-lints.md.

Inlay hints: Rust’s killer LSP feature

Because Rust infers most types, the inlay hints rust-analyzer draws are far more valuable than in TypeScript, where you usually wrote the types yourself. Hints are editor decorations — they are not part of your file, they never get saved, and they vanish if you open the file in cat. The ones enabled by default include:

Hint kind	Setting	Default	Renders
Variable types	`inlayHints.typeHints.enable`	`true`	`let x` → `let x: i32`
Parameter names	`inlayHints.parameterHints.enable`	`true`	`f(width, height)` → `f(width: w, height: h)`
Method chains	`inlayHints.chainingHints.enable`	`true`	type after each `.method()` in a chain
Closing braces	`inlayHints.closingBraceHints.enable`	`true`	`} // fn main` on long blocks
Lifetime elision	`inlayHints.lifetimeElisionHints.enable`	`"never"`	the elided `'a` lifetimes
Binding modes	`inlayHints.bindingModeHints.enable`	`false`	`ref`/`&` inserted by pattern matching
Adjustments	`inlayHints.expressionAdjustmentHints.enable`	`"never"`	auto-deref/`.borrow()` the compiler inserts

The hints that are off by default (lifetime elision, binding modes, expression adjustments) are deeper learning aids. Turning them on for a few weeks is one of the fastest ways to internalize ownership and borrowing — concepts covered in Section 05: Ownership. For example:

1
// .vscode/settings.json — extra hints that teach you the borrow rules
2
{
3
  "rust-analyzer.inlayHints.lifetimeElisionHints.enable": "always",
4
  "rust-analyzer.inlayHints.bindingModeHints.enable": true,
5
  "rust-analyzer.inlayHints.expressionAdjustmentHints.enable": "always"
6
}

Code actions (quick fixes / “assists”)

Code actions are the lightbulb menu (Ctrl+. / Cmd+. in VS Code). They are TypeScript’s “Quick Fix” and “Refactor” menus by another name. rust-analyzer ships hundreds; the ones you will reach for daily:

Add missing match arms — turns a non-exhaustive match into a complete one, generating Variant => todo!() for each missing case.
Implement missing members — after impl SomeTrait for MyType {, fills in every required method signature.
Add use (auto-import) — when you reference HashMap with no import, offers to insert use std::collections::HashMap;.
Extract into function / variable — select an expression and hoist it.
Wrap return type in Result / Convert to ? — restructure error handling (see Section 08: Error Handling).
Fill struct fields — expand Config { .. } to list every field.

The “fill” actions use rust-analyzer.assist.expressionFillDefault (default "todo") to decide whether placeholders are todo!() or Default::default().

Auto-import and import organization

Auto-import (rust-analyzer.completion.autoimport.enable, default true) is like TypeScript’s “auto-import on completion”: pick Duration from the completion list and rust-analyzer adds use std::time::Duration; for you. How it groups those imports is governed by rust-analyzer.imports.granularity.group (default "crate"), which merges imports from the same crate into one use block — the rust-analyzer equivalent of an import-sorting ESLint rule.

Key Differences

Concern	TypeScript (tsserver)	Rust (rust-analyzer)
Protocol	Language Server Protocol	Language Server Protocol (identical)
Shares core with CLI checker?	Yes — tsserver and `tsc` share internals	No — rust-analyzer has its own engine, separate from `rustc`
Where you get the binary	Bundled with editor / `typescript` package	`rustup component add rust-analyzer` (editor manages it)
Inline type display	Nice-to-have (you usually wrote the types)	Essential (most types are inferred)
Background compile	Type errors only	Type errors plus borrow-check via `cargo check`/`clippy`
Config namespace	`typescript.` / `javascript.`	`rust-analyzer.*`
Macro support	N/A	Expands declarative + procedural macros to resolve names
Project model	`tsconfig.json`	`Cargo.toml` (+ `cargo metadata`)

The trait-solving difference

tsserver resolves structural types: if two objects have the same shape, they are compatible. rust-analyzer must solve trait obligations — “does Vec<String> implement Iterator?”, “is there a From<Celsius> impl in scope?”. This is why rust-analyzer occasionally pauses on a freshly opened large project: it is priming a cache of trait resolutions (rust-analyzer.cachePriming.enable, default true). Once primed, completion and hover are instant.

Macros are part of the language model

Rust macros generate code, so rust-analyzer must expand them to know what names exist. rust-analyzer.procMacro.enable (default true) lets it compile and run your procedural macros (like #[derive(Serialize)] from Section 15: Serialization). This has no TypeScript analog — TypeScript has no macro system — and it is why a derive can give you working completions on generated methods. The “Expand macro recursively” command shows you the generated code; macros themselves are covered in Section 14: Macros.

Common Pitfalls

Pitfall 1: Expecting borrow errors to appear instantly

rust-analyzer’s live engine catches type errors keystroke-by-keystroke, but full borrow-checker errors only arrive after the background cargo check finishes (on save by default). New users sometimes write borrow-violating code, see no red squiggle for a second or two, and assume it compiles. It does not — wait for the save-triggered check, or run cargo check yourself.

For example, this real type mismatch does show up live, courtesy of rust-analyzer’s own inference:

1
fn main() {
2
    let port: u16 = "8080"; // does not compile (error[E0308]: mismatched types)
3
    println!("{port}");
4
}

The real compiler message rust-analyzer surfaces:

1
error[E0308]: mismatched types
2
 --> src/main.rs:2:21
3
  |
4
2 |     let port: u16 = "8080";
5
  |               ---   ^^^^^^ expected `u16`, found `&str`
6
  |               |
7
  |               expected due to this
8

9
For more information about this error, try `rustc --explain E0308`.

Pitfall 2: Trusting inlay hints as if they were source code

Inlay hints are rendered decorations, not text in your file. A reader who pastes a screenshot of hinted code into a .rs file will get a syntax error, because let x: i32 = 3 was actually let x = 3 with a fake : i32. VS Code lets you “accept” a hint to materialize it into real code, but until you do, it is purely visual. (TypeScript inlay hints behave the same way — they just matter less there.)

Pitfall 3: “Add missing match arms” is a fix for a real error

When you write a non-exhaustive match, the code action is offered because the code does not compile. The underlying error is real:

1
enum Status {
2
    Ok,
3
    NotFound,
4
    ServerError,
5
}
6

7
fn label(s: Status) -> &'static str {
8
    // does not compile (error[E0004]: non-exhaustive patterns)
9
    match s {
10
        Status::Ok => "ok",
11
        Status::NotFound => "not found",
12
    }
13
}
14

15
fn main() {
16
    println!("{}", label(Status::Ok));
17
}

Real compiler output:

1
error[E0004]: non-exhaustive patterns: `Status::ServerError` not covered
2
 --> src/main.rs:8:11
3
  |
4
8 |     match s {
5
  |           ^ pattern `Status::ServerError` not covered
6
...
7
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
8
  |
9
10~         Status::NotFound => "not found",
10
11~         Status::ServerError => todo!(),
11
  |

The “Add missing match arms” assist inserts exactly that Status::ServerError => todo!() arm for you.

Pitfall 4: Stale analysis after editing `Cargo.toml`

If completions for a freshly added dependency don’t appear, rust-analyzer may not have reloaded the workspace. rust-analyzer.cargo.autoreload (default true) usually handles it, but after editing Cargo.toml by hand you can force it with the “rust-analyzer: Restart server” command (or “Reload Workspace”). This is the analog of restarting tsserver when tsconfig.json changes don’t take effect.

Pitfall 5: Missing `rust-src` breaks standard-library navigation

Go-to-definition into std (e.g. jumping into Vec::push) needs the standard library source, which ships in the rust-src component. rustup installs it for you in most setups, but if std hovers show “no definition found,” run rustup component add rust-src.

Best Practices

Let your editor extension manage the binary. The VS Code “rust-analyzer” extension (and the Neovim/Zed/Helix LSP integrations) keep rust-analyzer in lockstep with your toolchain. Only run rustup component add rust-analyzer manually if you are wiring up a bare-bones editor. See vscode-setup.md.
Point on-save checks at Clippy once you are comfortable: "rust-analyzer.check.command": "clippy" gives you lints inline without a separate run. Details in linting.md.
Use the extra inlay hints as a learning curriculum. Turn on lifetimeElisionHints, bindingModeHints, and expressionAdjustmentHints while learning ownership; turn them off once the rules are second nature.
Commit a .vscode/settings.json (or a checked-in editor config) so the whole team gets identical analysis behavior — the equivalent of committing your tsconfig and ESLint setup.
Learn three keybindings: Go to Definition (F12), Quick Fix / code actions (Ctrl+. / Cmd+.), and Rename Symbol (F2). They cover 80% of daily LSP value.
Prefer per-project config for monorepos. A checked-in rust-analyzer.toml (or .vscode/settings.json) lets a workspace declare its own features and check command, instead of relying on each developer’s global settings.
Don’t fight cache priming. The brief startup pause on big projects is rust-analyzer building its trait-resolution cache. Leave cachePriming.enable on; it makes everything after startup snappy.

Real-World Example

Here is the kind of code where rust-analyzer earns its keep: a small status-code module with a trait impl and an exhaustive match. As you write it, rust-analyzer’s “Implement missing members” fills the Display skeleton, “Add missing match arms” completes the match, and inlay hints confirm the inferred types throughout.

1
use std::fmt;
2

3
/// A subset of HTTP statuses for a tiny router.
4
#[derive(Debug, Clone, Copy, PartialEq)]
5
enum Status {
6
    Ok,
7
    NotFound,
8
    ServerError,
9
}
10

11
impl fmt::Display for Status {
12
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13
        // rust-analyzer's "Add missing match arms" generated this skeleton,
14
        // then warned (live) until every arm was covered.
15
        let text = match self {
16
            Status::Ok => "200 OK",
17
            Status::NotFound => "404 Not Found",
18
            Status::ServerError => "500 Internal Server Error",
19
        };
20
        write!(f, "{text}")
21
    }
22
}
23

24
fn classify(code: u16) -> Status {
25
    match code {
26
        200..=299 => Status::Ok,
27
        404 => Status::NotFound,
28
        _ => Status::ServerError,
29
    }
30
}
31

32
fn main() {
33
    for code in [200, 404, 503] {
34
        // Inlay hints show `code: u16` and the `Status` returned by classify.
35
        println!("{code} -> {}", classify(code));
36
    }
37
}

Compiling and running prints:

1
200 -> 200 OK
2
404 -> 404 Not Found
3
503 -> 500 Internal Server Error

The workflow that produced it: you typed impl fmt::Display for Status {, pressed Ctrl+., and chose “Implement missing members” to generate the fn fmt stub. Inside it you wrote match self {, and the live diagnostic flagged the non-exhaustive match (E0004) until “Add missing match arms” filled in Status::ServerError. Throughout, chaining and type hints confirmed you were holding a Status, not a &Status or an Option<Status>.

A team-wide configuration

A production repo typically checks in editor settings so analysis is consistent across the team. For VS Code:

1
{
2
  // Run Clippy on save instead of plain `cargo check`.
3
  "rust-analyzer.checkOnSave": true,
4
  "rust-analyzer.check.command": "clippy",
5

6
  // Analyze every target (bins, examples, tests, benches), not just the default.
7
  "rust-analyzer.cargo.allTargets": true,
8

9
  // Build with the feature flags the team uses day to day.
10
  "rust-analyzer.cargo.features": ["postgres", "tracing"],
11

12
  // Group auto-imports per crate (one `use` block per crate).
13
  "rust-analyzer.imports.granularity.group": "crate"
14
}

Editor-independent settings can instead live in a rust-analyzer.toml at the workspace root, which the server reads regardless of which editor each developer uses:

1
[cargo]
2
allTargets = true
3
features = ["postgres", "tracing"]
4

5
[check]
6
command = "clippy"

Tip: rust-analyzer.cargo.allTargets = true (the default) means completions and diagnostics also cover your #[cfg(test)] modules and examples/, so you get full IDE support inside tests — see Section 13: Testing.

Exercises

Exercise 1: Turn on the teaching hints

Difficulty: Beginner

Objective: Build a feel for what rust-analyzer infers by enabling the hints that are off by default.

Instructions:

Create a project: cargo new ra_hints && cd ra_hints.
Open it in an editor with rust-analyzer installed.
Add a .vscode/settings.json (or your editor’s LSP config) enabling inlayHints.expressionAdjustmentHints.enable = "always" and inlayHints.bindingModeHints.enable = true.
Write the conversion code below. Observe the type hint that appears after converted and the adjustment hints around the From/into calls.

1
#[derive(Debug)]
2
struct Celsius(f64);
3

4
#[derive(Debug)]
5
struct Fahrenheit(f64);
6

7
impl From<Celsius> for Fahrenheit {
8
    fn from(c: Celsius) -> Self {
9
        /* ??? convert and return a Fahrenheit */
10
    }
11
}
12

13
fn main() {
14
    let body = Celsius(37.0);
15
    let converted = Fahrenheit::from(body);
16
    let freezing: Fahrenheit = Celsius(0.0).into();
17
    println!("body -> {:.1} F", converted.0);
18
    println!("freezing -> {:.1} F", freezing.0);
19
}

Solution

1
#[derive(Debug)]
2
struct Celsius(f64);
3

4
#[derive(Debug)]
5
struct Fahrenheit(f64);
6

7
// rust-analyzer's "Implement missing members" generates the `fn from` stub
8
// after you type `impl From<Celsius> for Fahrenheit {`.
9
impl From<Celsius> for Fahrenheit {
10
    fn from(c: Celsius) -> Self {
11
        Fahrenheit(c.0 * 9.0 / 5.0 + 32.0)
12
    }
13
}
14

15
fn main() {
16
    let body = Celsius(37.0);
17
    // Inlay hint renders `: Fahrenheit` after `converted`.
18
    let converted = Fahrenheit::from(body);
19
    // `.into()` works because `From` implies `Into`; the hint shows the target type.
20
    let freezing: Fahrenheit = Celsius(0.0).into();
21
    println!("body -> {:.1} F", converted.0);
22
    println!("freezing -> {:.1} F", freezing.0);
23
}

Running prints:

1
body -> 98.6 F
2
freezing -> 32.0 F

The settings to add:

1
{
2
  "rust-analyzer.inlayHints.expressionAdjustmentHints.enable": "always",
3
  "rust-analyzer.inlayHints.bindingModeHints.enable": true
4
}

Exercise 2: Trigger and read a real code action

Difficulty: Intermediate

Objective: Use the “Add missing match arms” assist on code that genuinely does not compile, and confirm the resulting error went away.

Instructions:

In a new or existing project, paste the non-exhaustive match below into src/main.rs.
Run cargo build and read the real E0004 error.
Place your cursor on the match, open the code-action menu (Ctrl+. / Cmd+.), and apply “Add missing match arms.”
Fill in the generated todo!() arm with a sensible string and confirm cargo build now succeeds.

1
enum Status {
2
    Ok,
3
    NotFound,
4
    ServerError,
5
}
6

7
fn label(s: Status) -> &'static str {
8
    match s {
9
        Status::Ok => "ok",
10
        Status::NotFound => "not found",
11
    }
12
}
13

14
fn main() {
15
    println!("{}", label(Status::Ok));
16
}

Solution

Before the fix, cargo build reports (real output):

1
error[E0004]: non-exhaustive patterns: `Status::ServerError` not covered
2
 --> src/main.rs:8:11
3
  |
4
8 |     match s {
5
  |           ^ pattern `Status::ServerError` not covered

After applying the assist and filling the arm:

1
enum Status {
2
    Ok,
3
    NotFound,
4
    ServerError,
5
}
6

7
fn label(s: Status) -> &'static str {
8
    match s {
9
        Status::Ok => "ok",
10
        Status::NotFound => "not found",
11
        Status::ServerError => "server error",
12
    }
13
}
14

15
fn main() {
16
    println!("{}", label(Status::Ok));
17
}

Now cargo build succeeds and cargo run prints ok. The lesson: the lightbulb appeared because the code was broken — code actions are fixes for real diagnostics, not cosmetic helpers.

Exercise 3: Switch on-save checks from `check` to `clippy`

Difficulty: Intermediate

Objective: Get Clippy lints inline by reconfiguring rust-analyzer’s background check command, using the modern key.

Instructions:

Write the word-counting program below — it compiles and runs cleanly.
Set rust-analyzer.check.command to "clippy" and ensure rust-analyzer.checkOnSave is true.
Introduce a small lint-able pattern (for instance, write counts.len() == 0 somewhere instead of counts.is_empty()), save, and watch Clippy’s hint appear inline — without running Clippy in a terminal.
Confirm you used rust-analyzer.check.command, not the deprecated rust-analyzer.checkOnSave.command.

1
use std::collections::BTreeMap;
2

3
fn word_counts(text: &str) -> BTreeMap<String, usize> {
4
    // TODO: count each lowercased word
5
    /* ??? */
6
}
7

8
fn main() {
9
    let counts = word_counts("the cat the hat THE end");
10
    for (word, n) in &counts {
11
        println!("{word}: {n}");
12
    }
13
}

Solution

1
use std::collections::BTreeMap;
2

3
fn word_counts(text: &str) -> BTreeMap<String, usize> {
4
    let mut counts = BTreeMap::new();
5
    for word in text.split_whitespace() {
6
        let key = word.to_lowercase();
7
        *counts.entry(key).or_insert(0) += 1;
8
    }
9
    counts
10
}
11

12
fn main() {
13
    let counts = word_counts("the cat the hat THE end");
14
    for (word, n) in &counts {
15
        println!("{word}: {n}");
16
    }
17
}

Running prints (a BTreeMap iterates in sorted key order):

1
cat: 1
2
end: 1
3
hat: 1
4
the: 3

The configuration that makes Clippy run on save:

1
// .vscode/settings.json — the modern, correct keys
2
{
3
  "rust-analyzer.checkOnSave": true,
4
  "rust-analyzer.check.command": "clippy"
5
}

The deprecated form to avoid:

1
// Deprecated: `checkOnSave.command` is no longer the place for the command.
2
{
3
  "rust-analyzer.checkOnSave": { "command": "clippy" }
4
}

With Clippy wired in, writing counts.len() == 0 triggers the clippy::len_zero lint inline, suggesting counts.is_empty(). See clippy-lints.md for that and other common lints.

rust-analyzer: The Rust Language Server

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

What an LSP server actually is

rust-analyzer is its own type-checker, not a cargo check wrapper

check on save vs. live diagnostics

Inlay hints: Rust’s killer LSP feature

Code actions (quick fixes / “assists”)

Auto-import and import organization

Key Differences

The trait-solving difference

Macros are part of the language model

Common Pitfalls

Pitfall 1: Expecting borrow errors to appear instantly

Pitfall 2: Trusting inlay hints as if they were source code

Pitfall 3: “Add missing match arms” is a fix for a real error

Pitfall 4: Stale analysis after editing Cargo.toml

Pitfall 5: Missing rust-src breaks standard-library navigation

Best Practices

Real-World Example

A team-wide configuration

Further Reading

Exercises

Exercise 1: Turn on the teaching hints

Exercise 2: Trigger and read a real code action

Exercise 3: Switch on-save checks from check to clippy

rust-analyzer is its own type-checker, not a `cargo check` wrapper

`check` on save vs. live diagnostics

Pitfall 4: Stale analysis after editing `Cargo.toml`

Pitfall 5: Missing `rust-src` breaks standard-library navigation

Exercise 3: Switch on-save checks from `check` to `clippy`