Ha még mindig az RLS-t (Rust Language Server) használod, vagy egyszerűen csak nem vetted a fáradságot, hogy rendesen beállítsd az IDE-integrációt, most itt az idő, hogy komolyan vedd a témát. A rust-analyzer nem egy "jobb alternatíva" az RLS-hez képest – egyszerűen ez a Rust nyelvi szerver, pont. Az RLS-t a Rust csapata már jó ideje deprecated-nek nyilvánította, és minden fejlesztői erőforrás a rust-analyzerbe megy.

Miért jobb a rust-analyzer a régi RLS-nél

Az RLS a cargo check-re épült, ami azt jelentette, hogy minden apró változás után újra kellett fordítani (vagy legalább type-check-elni) a teljes crate-et. Ez nagyobb projekteknél másodperceket, néha perceket vett igénybe – közben te csak egy pontosvesszőt akartál betenni.

A rust-analyzer teljesen más architektúrával dolgozik: saját, inkrementális elemzőt épített, ami nem a rustc-re, hanem egy külön, IDE-célokra optimalizált motorra épül. Ez azt jelenti, hogy:

  • gyorsabb a válaszidő gépelés közben,
  • pontosabb az autocomplete, mert valós időben követi a kód állapotát,
  • sokkal jobb a refaktoring-támogatás (rename, extract function, stb.),
  • natívan támogatja a modern Rust-feature-öket, mint a GAT-okat (Generic Associated Types) vagy a let-else szintaxist.
ℹ
Megjegyzés

A rust-analyzer önálló projekt, amit a Rust nyelvi csapat egyik alcsapata (a rust-analyzer working group) fejleszt, és mostanra be is olvasztották a hivatalos rust-lang GitHub org alá.

Telepítés és alapbeállítások VS Code-ban

VS Code alatt a legegyszerűbb út a hivatalos rust-analyzer extension telepítése a Marketplace-ről. Keresd rá rust-analyzer névre – ne keverd össze a régi, immár nem karbantartott Rust extension-nel, amit még az RLS-hez fejlesztettek.

Telepítés után az extension automatikusan letölti a legfrissebb rust-analyzer binárist, nincs szükség külön rustup component add-ra (ellentétben az RLS-szel, ami komponensként érkezett).

Egy tipikus .vscode/settings.json konfiguráció így nézhet ki:

{
  "rust-analyzer.check.command": "clippy",
  "rust-analyzer.cargo.features": "all",
  "rust-analyzer.inlayHints.parameterHints.enable": true,
  "rust-analyzer.inlayHints.typeHints.enable": true,
  "rust-analyzer.procMacro.enable": true
}

A check.command beállítás cseréje clippy-re nagyon hasznos: minden mentés után nem csak a type-checket kapod meg, hanem a clippy lint-jeit is közvetlenül az editorban, hullámos aláhúzással.

✦
Tipp

Ha proc-macro-kat használó crate-eket (pl. serde, tokio) fejlesztesz, győződj meg róla, hogy a rust-analyzer.procMacro.enable be van kapcsolva – nélküle a makrók által generált kód nem lesz látható az elemzés számára, és rengeteg hamis piros aláhúzást kapsz.

Neovim integráció LSP kliensekkel

Neovimban a beépített LSP klienst (vim.lsp) érdemes használni a nvim-lspconfig pluginnal párosítva – ez a legkevesebb boilerplate-et igénylő, legstabilabb megoldás.

Első lépésként telepítsd a rust-analyzer binárist. Ha rustup-ot használsz, a legegyszerűbb:

rustup component add rust-analyzer

Ez a rustup 1.67-es verziója óta elérhető komponensként, így nem kell külön letöltened GitHub release-ekből (bár az is működik, ha inkább azt preferálod).

A nvim-lspconfig-gal a beállítás Lua-ban valahogy így néz ki:

local lspconfig = require('lspconfig')

lspconfig.rust_analyzer.setup({
  settings = {
    ['rust-analyzer'] = {
      cargo = {
        allFeatures = true,
      },
      checkOnSave = {
        command = "clippy",
      },
      inlayHints = {
        typeHints = { enable = true },
        parameterHints = { enable = true },
      },
    },
  },
})

Az inlay hint-ek megjelenítéséhez Neovim 0.10 alatt már natív API is elérhető lenne, de 2023 közepén a stabil Neovim verziók (0.9 és korábbiak) esetén ehhez plugint kell használnod, mint a lvimuser/lsp-inlayhints.nvim. Ez a plugin a rust-analyzer által küldött hint-adatokat rendereli ki virtuális szövegként a sorok végén.

⚠
Figyelem

Ha a checkOnSave.command-ot clippy-re állítod, de a projektben nincs telepítve a clippy component, a mentés után folyamatosan hibaüzeneteket fogsz kapni. Ellenőrizd: rustup component add clippy.

Hasznos funkciók: inline hint-ek, kód-navigáció, refaktorálás

A rust-analyzer egyik legszerethetőbb funkciója az inlay hints rendszer. Ez a típusokat és paraméter-neveket jeleníti meg közvetlenül a kód mellett, halványabb színnel, anélkül hogy tényleges kódot írnál a fájlba.

Nézzünk egy egyszerű példát, ahol az inlay hint-ek nélkül nem lenne azonnal nyilvánvaló, mi történik:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let doubled: Vec<i32> = numbers.iter().map(|n| n * 2).collect();

    let Some(first) = doubled.first() else {
        println!("üres a vektor");
        return;
    };

    println!("Az első duplázott érték: {first}");
}

Ennél a kódnál a rust-analyzer inline megjeleníti, hogy a map closure n paramétere i32 típusú, illetve hogy a let-else mintaillesztés eredménye &i32. Ez különösen hasznos, ha generikus vagy trait-alapú kódot olvasol, ahol a típusinferencia nem mindig triviális első pillantásra.

A kód-navigáció terén a "Go to Definition", "Find All References" és a "Go to Implementation" parancsok villámgyorsan működnek, akár nagy, több crate-es workspace-ekben is. Ez azért fontos, mert a Rust ökoszisztémában gyakran találkozol trait-alapú absztrakciókkal, ahol egy metódus tényleges implementációja több lépésen keresztül vezet.

A refaktorálási eszközök közül kiemelném az extract function, inline variable és rename symbol funkciókat – ezek mind a teljes projektre kiterjedő, típus-tudatos átalakítást végeznek, nem csak szöveges keresés-cserét.

Íme egy példa, ahol egy OnceCell-t használó statikus inicializáláson demonstrálhatod a navigációt:

use std::cell::OnceCell;

struct Config {
    value: OnceCell<String>,
}

impl Config {
    fn new() -> Self {
        Config { value: OnceCell::new() }
    }

    fn get_or_init(&self) -> &String {
        self.value.get_or_init(|| String::from("alapérték"))
    }
}

fn main() {
    let config = Config::new();
    println!("{}", config.get_or_init());
}

Ha a get_or_init metódus fölé viszed a kurzort és lenyomod a "Go to Definition"-t, a rust-analyzer közvetlenül a standard könyvtár forráskódjához navigál (ha a rust-src component telepítve van), így akár a OnceCell implementációját is megnézheted anélkül, hogy külön böngészőt kellene nyitnod.

✦
Tipp

A rustup component add rust-src parancs telepíti a standard könyvtár forráskódját lokálisan – ez elengedhetetlen ahhoz, hogy a rust-analyzer be tudjon navigálni a std belsejébe.

Teljesítménybeli tippek nagyobb projektekhez

Ahogy a projekt nő, a rust-analyzer is egyre több memóriát és CPU-t fogyaszt. Néhány beállítással jelentősen javíthatod a válaszidőt:

  1. Korlátozd a feature-flageket. Ha nincs rá szükséged, ne használd az "all" értéket a cargo.features-nél – helyette add meg explicit módon, mely feature-öket akarod elemezni. Ez csökkenti az elemzendő kódmennyiséget.

  2. Kapcsold ki a proc-macro elemzést azokon a crate-eken, ahol nem szükséges. A rust-analyzer.procMacro.ignored beállítással finomhangolhatod, mely makrókat ne bontsa ki.

  3. Növeld a memóriakorlátot, ha szükséges. Nagyon nagy workspace-eknél (több tucat crate) a rust-analyzer.cargo.buildScripts.enable kikapcsolása is segíthet, ha nem függesz erősen build.rs szkriptek generált kódjától az elemzés szempontjából.

  4. Használj SSD-t és elegendő RAM-ot. Ez talán triviálisnak hangzik, de a rust-analyzer az egész workspace-t memóriában tartja indexelve, és egy 50+ crate-es monorepo könnyen felhasználhat 4-8 GB RAM-ot is.

# .cargo/config.toml – gyorsabb inkrementális build a háttérben
[build]
incremental = true

[profile.dev]
debug = 1  # kevesebb debug info = gyorsabb linkelés

Ez a Cargo.toml/config.toml kombináció nem közvetlenül a rust-analyzert gyorsítja, de mivel a cargo check háttérfolyamatok is lefutnak, a gyorsabb build pipeline közvetve javítja az általános IDE-válaszidőt is.

✓
Jó tudni

Ha a rust-analyzer láthatóan "beragad" vagy nagyon lassú lesz, először mindig próbáld ki a rust-analyzer: Restart server parancsot (VS Code-ban a Command Palette-ből), mielőtt bármilyen mélyebb konfigurációs változtatásba kezdenél.

Összefoglalás

A rust-analyzer 2023-ra elérte azt a szintet, ahol a Rust fejlesztés élménye tényleg versenyképes más, jóval régebbi ökoszisztémák IDE-támogatásával. Legyen szó VS Code-ról vagy Neovimról, a beállítás ma már néhány perc, és a megtérülés – gyorsabb navigáció, pontosabb refaktorálás, valós idejű lint-visszajelzés – hatalmas. Ha eddig halogattad a rendes setup összeállítását, ez a cikk remélhetőleg meggyőzött arról, hogy megérje az időt beleölni – utólag hálás leszel magadnak minden alkalommal, amikor egy nagy projektben egy kattintással navigálsz oda, ahová kell.