rust-analyzer: The Rust Language Server

20 min readupdated by

Ahmet Zeybek· Jul 10, 2026

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 repository’s pinned verification toolchain uses 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 Setting Up VS Code for Rust 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; Setting Up VS Code for Rust covers it in detail. Wiring Clippy in is covered in Linting with Clippy and Common Clippy Lints, Explained.

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 Setting Up VS Code for Rust.
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 with Clippy.
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 Common Clippy Lints, Explained 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`