6 :source-highlighter: rouge
10 IMPORTANT: the master copy of this document lives in the https://github.com/rust-lang/rust-analyzer repository
13 At its core, rust-analyzer is a *library* for semantic analysis of Rust code as it changes over time.
14 This manual focuses on a specific usage of the library -- running it as part of a server that implements the
15 https://microsoft.github.io/language-server-protocol/[Language Server Protocol] (LSP).
16 The LSP allows various code editors, like VS Code, Emacs or Vim, to implement semantic features like completion or goto definition by talking to an external language server process.
21 To improve this document, send a pull request: +
22 https://github.com/rust-lang/rust-analyzer/blob/master/docs/user/manual.adoc[https://github.com/rust-analyzer/.../manual.adoc]
24 The manual is written in https://asciidoc.org[AsciiDoc] and includes some extra files which are generated from the source code. Run `cargo test` and `cargo test -p xtask` to create these and then `asciidoctor manual.adoc` to create an HTML copy.
27 If you have questions about using rust-analyzer, please ask them in the https://users.rust-lang.org/c/ide/14["`IDEs and Editors`"] topic of Rust users forum.
31 In theory, one should be able to just install the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>> and have it automatically work with any editor.
32 We are not there yet, so some editor specific setup is required.
34 Additionally, rust-analyzer needs the sources of the standard library.
35 If the source code is not present, rust-analyzer will attempt to install it automatically.
37 To add the sources manually, run the following command:
40 $ rustup component add rust-src
45 Only the latest stable standard library source is officially supported for use with rust-analyzer.
46 If you are using an older toolchain or have an override set, rust-analyzer may fail to understand the Rust source.
47 You will either need to update your toolchain or use an older version of rust-analyzer that is compatible with your toolchain.
49 If you are using an override in your project, you can still force rust-analyzer to use the stable toolchain via the environment variable `RUSTUP_TOOLCHAIN`.
50 For example, with VS Code or coc-rust-analyzer:
54 { "rust-analyzer.server.extraEnv": { "RUSTUP_TOOLCHAIN": "stable" } }
59 This is the best supported editor at the moment.
60 The rust-analyzer plugin for VS Code is maintained
61 https://github.com/rust-lang/rust-analyzer/tree/master/editors/code[in tree].
63 You can install the latest release of the plugin from
64 https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer[the marketplace].
66 Note that the plugin may cause conflicts with the
67 https://marketplace.visualstudio.com/items?itemName=rust-lang.rust[official Rust plugin].
68 It is recommended to disable the Rust plugin when using the rust-analyzer extension.
70 By default, the plugin will prompt you to download the matching version of the server as well:
72 image::https://user-images.githubusercontent.com/9021944/75067008-17502500-54ba-11ea-835a-f92aac50e866.png[]
76 To disable this notification put the following to `settings.json`
80 { "rust-analyzer.updates.askBeforeDownload": false }
84 The server binary is stored in the extension install directory, which starts with `rust-lang.rust-analyzer-` and is located under:
86 * Linux: `~/.vscode/extensions`
87 * Linux (Remote, such as WSL): `~/.vscode-server/extensions`
88 * macOS: `~/.vscode/extensions`
89 * Windows: `%USERPROFILE%\.vscode\extensions`
91 As an exception, on NixOS, the extension makes a copy of the server and stores it under `~/.config/Code/User/globalStorage/rust-lang.rust-analyzer`.
93 Note that we only support the two most recent versions of VS Code.
97 The extension will be updated automatically as new versions become available.
98 It will ask your permission to download the matching language server version binary if needed.
102 We ship nightly releases for VS Code.
103 To help us out by testing the newest code, you can enable pre-release versions in the Code extension page.
105 ==== Manual installation
107 Alternatively, download a VSIX corresponding to your platform from the
108 https://github.com/rust-lang/rust-analyzer/releases[releases] page.
110 Install the extension with the `Extensions: Install from VSIX` command within VS Code, or from the command line via:
113 $ code --install-extension /path/to/rust-analyzer.vsix
116 If you are running an unsupported platform, you can install `rust-analyzer-no-server.vsix` and compile or obtain a server binary.
117 Copy the server anywhere, then add the path to your settings.json, for example:
120 { "rust-analyzer.server.path": "~/.local/bin/rust-analyzer-linux" }
123 ==== Building From Source
125 Both the server and the Code plugin can be installed from source:
129 $ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
130 $ cargo xtask install
133 You'll need Cargo, nodejs (matching a supported version of VS Code) and npm for this.
135 Note that installing via `xtask install` does not work for VS Code Remote, instead you'll need to install the `.vsix` manually.
137 If you're not using Code, you can compile and install only the LSP server:
141 $ cargo xtask install --server
144 === rust-analyzer Language Server Binary
146 Other editors generally require the `rust-analyzer` binary to be in `$PATH`.
147 You can download pre-built binaries from the https://github.com/rust-lang/rust-analyzer/releases[releases] page.
148 You will need to uncompress and rename the binary for your platform, e.g. from `rust-analyzer-aarch64-apple-darwin.gz` on Mac OS to `rust-analyzer`, make it executable, then move it into a directory in your `$PATH`.
150 On Linux to install the `rust-analyzer` binary into `~/.local/bin`, these commands should work:
154 $ mkdir -p ~/.local/bin
155 $ curl -L https://github.com/rust-lang/rust-analyzer/releases/latest/download/rust-analyzer-x86_64-unknown-linux-gnu.gz | gunzip -c - > ~/.local/bin/rust-analyzer
156 $ chmod +x ~/.local/bin/rust-analyzer
159 Make sure that `~/.local/bin` is listed in the `$PATH` variable and use the appropriate URL if you're not on a `x86-64` system.
161 You don't have to use `~/.local/bin`, any other path like `~/.cargo/bin` or `/usr/local/bin` will work just as well.
163 Alternatively, you can install it from source using the command below.
164 You'll need the latest stable version of the Rust toolchain.
168 $ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
169 $ cargo xtask install --server
172 If your editor can't find the binary even though the binary is on your `$PATH`, the likely explanation is that it doesn't see the same `$PATH` as the shell, see https://github.com/rust-lang/rust-analyzer/issues/1811[this issue].
173 On Unix, running the editor from a shell or changing the `.desktop` file to set the environment should help.
177 `rust-analyzer` is available in `rustup`:
181 $ rustup component add rust-analyzer
184 However, in contrast to `component add clippy` or `component add rustfmt`, this does not actually place a `rust-analyzer` binary in `~/.cargo/bin`, see https://github.com/rust-lang/rustup/issues/2411[this issue]. You can find the path to the binary using:
187 $ rustup which --toolchain stable rust-analyzer
189 You can link to there from `~/.cargo/bin` or configure your editor to use the full path.
191 Alternatively you might be able to configure your editor to start `rust-analyzer` using the command:
194 $ rustup run stable rust-analyzer
199 The `rust-analyzer` binary can be installed from the repos or AUR (Arch User Repository):
201 - https://www.archlinux.org/packages/community/x86_64/rust-analyzer/[`rust-analyzer`] (built from latest tagged source)
202 - https://aur.archlinux.org/packages/rust-analyzer-git[`rust-analyzer-git`] (latest Git version)
204 Install it with pacman, for example:
208 $ pacman -S rust-analyzer
213 `rust-analyzer` is available in the GURU repository:
215 - https://gitweb.gentoo.org/repo/proj/guru.git/tree/dev-util/rust-analyzer?id=9895cea62602cfe599bd48e0fb02127411ca6e81[`dev-util/rust-analyzer`] builds from source
216 - https://gitweb.gentoo.org/repo/proj/guru.git/tree/dev-util/rust-analyzer-bin?id=9895cea62602cfe599bd48e0fb02127411ca6e81[`dev-util/rust-analyzer-bin`] installs an official binary release
218 If not already, GURU must be enabled (e.g. using `app-eselect/eselect-repository`) and sync'd before running `emerge`:
222 $ eselect repository enable guru && emaint sync -r guru
223 $ emerge rust-analyzer-bin
228 The `rust-analyzer` binary can be installed via https://brew.sh/[Homebrew].
232 $ brew install rust-analyzer
237 Note this excellent https://robert.kra.hn/posts/2021-02-07_rust-with-emacs/[guide] from https://github.com/rksm[@rksm].
239 Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
241 Emacs support is maintained as part of the https://github.com/emacs-lsp/lsp-mode[Emacs-LSP] package in https://github.com/emacs-lsp/lsp-mode/blob/master/lsp-rust.el[lsp-rust.el].
243 1. Install the most recent version of `emacs-lsp` package by following the https://github.com/emacs-lsp/lsp-mode[Emacs-LSP instructions].
244 2. Set `lsp-rust-server` to `'rust-analyzer`.
245 3. Run `lsp` in a Rust buffer.
246 4. (Optionally) bind commands like `lsp-rust-analyzer-join-lines`, `lsp-extend-selection` and `lsp-rust-analyzer-expand-macro` to keys.
250 Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
251 Not needed if the extension can install/update it on its own, coc-rust-analyzer is one example.
253 There are several LSP client implementations for vim or neovim:
255 ==== coc-rust-analyzer
257 1. Install coc.nvim by following the instructions at
258 https://github.com/neoclide/coc.nvim[coc.nvim]
260 2. Run `:CocInstall coc-rust-analyzer` to install
261 https://github.com/fannheyward/coc-rust-analyzer[coc-rust-analyzer],
262 this extension implements _most_ of the features supported in the VSCode extension:
263 * automatically install and upgrade stable/nightly releases
264 * same configurations as VSCode extension, `rust-analyzer.server.path`, `rust-analyzer.cargo.features` etc.
265 * same commands too, `rust-analyzer.analyzerStatus`, `rust-analyzer.ssr` etc.
266 * inlay hints for variables and method chaining, _Neovim Only_
268 Note: for code actions, use `coc-codeaction-cursor` and `coc-codeaction-selected`; `coc-codeaction` and `coc-codeaction-line` are unlikely to be useful.
270 ==== LanguageClient-neovim
272 1. Install LanguageClient-neovim by following the instructions
273 https://github.com/autozimu/LanguageClient-neovim[here]
274 * The GitHub project wiki has extra tips on configuration
276 2. Configure by adding this to your vim/neovim config file (replacing the existing Rust-specific line if it exists):
280 let g:LanguageClient_serverCommands = {
281 \ 'rust': ['rust-analyzer'],
287 Install YouCompleteMe by following the instructions
288 https://github.com/ycm-core/YouCompleteMe#installation[here].
290 rust-analyzer is the default in ycm, it should work out of the box.
294 To use the LSP server in https://github.com/dense-analysis/ale[ale]:
298 let g:ale_linters = {'rust': ['analyzer']}
303 NeoVim 0.5 has built-in language server support.
304 For a quick start configuration of rust-analyzer, use https://github.com/neovim/nvim-lspconfig#rust_analyzer[neovim/nvim-lspconfig].
305 Once `neovim/nvim-lspconfig` is installed, use `+lua require'lspconfig'.rust_analyzer.setup({})+` in your `init.vim`.
307 You can also pass LSP settings to the server:
312 local nvim_lsp = require'lspconfig'
314 local on_attach = function(client)
315 require'completion'.on_attach(client)
318 nvim_lsp.rust_analyzer.setup({
321 ["rust-analyzer"] = {
342 See https://sharksforarms.dev/posts/neovim-rust/ for more tips on getting started.
344 Check out https://github.com/simrat39/rust-tools.nvim for a batteries included rust-analyzer setup for neovim.
348 vim-lsp is installed by following https://github.com/prabirshrestha/vim-lsp[the plugin instructions].
349 It can be as simple as adding this line to your `.vimrc`:
353 Plug 'prabirshrestha/vim-lsp'
356 Next you need to register the `rust-analyzer` binary.
357 If it is available in `$PATH`, you may want to add this to your `.vimrc`:
361 if executable('rust-analyzer')
362 au User lsp_setup call lsp#register_server({
363 \ 'name': 'Rust Language Server',
364 \ 'cmd': {server_info->['rust-analyzer']},
365 \ 'whitelist': ['rust'],
370 There is no dedicated UI for the server configuration, so you would need to send any options as a value of the `initialization_options` field, as described in the <<configuration,Configuration>> section.
371 Here is an example of how to enable the proc-macro support:
375 if executable('rust-analyzer')
376 au User lsp_setup call lsp#register_server({
377 \ 'name': 'Rust Language Server',
378 \ 'cmd': {server_info->['rust-analyzer']},
379 \ 'whitelist': ['rust'],
380 \ 'initialization_options': {
397 * Follow the instructions in link:https://github.com/sublimelsp/LSP-rust-analyzer[LSP-rust-analyzer].
399 NOTE: Install link:https://packagecontrol.io/packages/LSP-file-watcher-chokidar[LSP-file-watcher-chokidar] to enable file watching (`workspace/didChangeWatchedFiles`).
402 * Install the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
403 * Install the link:https://packagecontrol.io/packages/LSP[LSP package].
404 * From the command palette, run `LSP: Enable Language Server Globally` and select `rust-analyzer`.
406 If it worked, you should see "rust-analyzer, Line X, Column Y" on the left side of the status bar, and after waiting a bit, functionalities like tooltips on hovering over variables should become available.
408 If you get an error saying `No such file or directory: 'rust-analyzer'`, see the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>> section on installing the language server binary.
412 GNOME Builder 3.37.1 and newer has native `rust-analyzer` support.
413 If the LSP binary is not available, GNOME Builder can install it when opening a Rust file.
418 Support for Rust development in the Eclipse IDE is provided by link:https://github.com/eclipse/corrosion[Eclipse Corrosion].
419 If available in PATH or in some standard location, `rust-analyzer` is detected and powers editing of Rust files without further configuration.
420 If `rust-analyzer` is not detected, Corrosion will prompt you for configuration of your Rust toolchain and language server with a link to the __Window > Preferences > Rust__ preference page; from here a button allows to download and configure `rust-analyzer`, but you can also reference another installation.
421 You'll need to close and reopen all .rs and Cargo files, or to restart the IDE, for this change to take effect.
425 Support for the language server protocol is built into Kate through the LSP plugin, which is included by default.
426 It is preconfigured to use rust-analyzer for Rust sources since Kate 21.12.
428 Earlier versions allow you to use rust-analyzer through a simple settings change.
429 In the LSP Client settings of Kate, copy the content of the third tab "default parameters" to the second tab "server configuration".
430 Then in the configuration replace:
435 "rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
436 "url": "https://github.com/rust-lang/rls",
437 "highlightingModeRegex": "^Rust$"
444 "command": ["rust-analyzer"],
445 "rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
446 "url": "https://github.com/rust-lang/rust-analyzer",
447 "highlightingModeRegex": "^Rust$"
450 Then click on apply, and restart the LSP server for your rust project.
454 https://gitlab.com/cppit/jucipp[juCi++] has built-in support for the language server protocol, and since version 1.7.0 offers installation of both Rust and rust-analyzer when opening a Rust file.
458 https://kakoune.org/[Kakoune] supports LSP with the help of https://github.com/kak-lsp/kak-lsp[`kak-lsp`].
459 Follow the https://github.com/kak-lsp/kak-lsp#installation[instructions] to install `kak-lsp`.
460 To configure `kak-lsp`, refer to the https://github.com/kak-lsp/kak-lsp#configuring-kak-lsp[configuration section] which is basically about copying the https://github.com/kak-lsp/kak-lsp/blob/master/kak-lsp.toml[configuration file] in the right place (latest versions should use `rust-analyzer` by default).
462 Finally, you need to configure Kakoune to talk to `kak-lsp` (see https://github.com/kak-lsp/kak-lsp#usage[Usage section]).
463 A basic configuration will only get you LSP but you can also activate inlay diagnostics and auto-formatting on save.
464 The following might help you get all of this.
468 eval %sh{kak-lsp --kakoune -s $kak_session} # Not needed if you load it with plug.kak.
469 hook global WinSetOption filetype=rust %{
473 # Auto-formatting on save
474 hook window BufWritePre .* lsp-formatting-sync
476 # Configure inlay hints (only on save)
477 hook window -group rust-inlay-hints BufWritePost .* rust-analyzer-inlay-hints
478 hook -once -always window WinSetOption filetype=.* %{
479 remove-hooks window rust-inlay-hints
486 https://docs.helix-editor.com/[Helix] supports LSP by default.
487 However, it won't install `rust-analyzer` automatically.
488 You can follow instructions for installing <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
492 There is a package named `ra_ap_rust_analyzer` available on https://crates.io/crates/ra_ap_rust-analyzer[crates.io], for someone who wants to use it programmatically.
494 For more details, see https://github.com/rust-lang/rust-analyzer/blob/master/.github/workflows/publish.yml[the publish workflow].
498 Start with looking at the rust-analyzer version.
499 Try **rust-analyzer: Show RA Version** in VS Code (using **Command Palette** feature typically activated by Ctrl+Shift+P) or `rust-analyzer --version` in the command line.
500 If the date is more than a week ago, it's better to update rust-analyzer version.
502 The next thing to check would be panic messages in rust-analyzer's log.
503 Log messages are printed to stderr, in VS Code you can see then in the `Output > Rust Analyzer Language Server` tab of the panel.
504 To see more logs, set the `RA_LOG=info` environment variable, this can be done either by setting the environment variable manually or by using `rust-analyzer.server.extraEnv`, note that both of these approaches require the server to be restarted.
506 To fully capture LSP messages between the editor and the server, set `"rust-analyzer.trace.server": "verbose"` config and check
507 `Output > Rust Analyzer Language Server Trace`.
509 The root cause for many "`nothing works`" problems is that rust-analyzer fails to understand the project structure.
510 To debug that, first note the `rust-analyzer` section in the status bar.
511 If it has an error icon and red, that's the problem (hover will have somewhat helpful error message).
512 **rust-analyzer: Status** prints dependency information for the current file.
513 Finally, `RA_LOG=project_model=debug` enables verbose logs during project loading.
515 If rust-analyzer outright crashes, try running `rust-analyzer analysis-stats /path/to/project/directory/` on the command line.
516 This command type checks the whole project in batch mode bypassing LSP machinery.
518 When filing issues, it is useful (but not necessary) to try to minimize examples.
519 An ideal bug reproduction looks like this:
522 $ git clone https://github.com/username/repo.git && cd repo && git switch --detach commit-hash
523 $ rust-analyzer --version
524 rust-analyzer dd12184e4 2021-05-08 dev
525 $ rust-analyzer analysis-stats .
529 It is especially useful when the `repo` doesn't use external crates or the standard library.
531 If you want to go as far as to modify the source code to debug the problem, be sure to take a look at the
532 https://github.com/rust-lang/rust-analyzer/tree/master/docs/dev[dev docs]!
536 **Source:** https://github.com/rust-lang/rust-analyzer/blob/master/crates/rust-analyzer/src/config.rs[config.rs]
538 The <<_installation,Installation>> section contains details on configuration for some of the editors.
539 In general `rust-analyzer` is configured via LSP messages, which means that it's up to the editor to decide on the exact format and location of configuration files.
541 Some clients, such as <<vs-code,VS Code>> or <<coc-rust-analyzer,COC plugin in Vim>> provide `rust-analyzer` specific configuration UIs. Others may require you to know a bit more about the interaction with `rust-analyzer`.
543 For the later category, it might help to know that the initial configuration is specified as a value of the `initializationOptions` field of the https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialize[`InitializeParams` message, in the LSP protocol].
544 The spec says that the field type is `any?`, but `rust-analyzer` is looking for a JSON object that is constructed using settings from the list below.
545 Name of the setting, ignoring the `rust-analyzer.` prefix, is used as a path, and value of the setting becomes the JSON property value.
547 For example, a very common configuration is to enable proc-macro support, can be achieved by sending this JSON:
563 Please consult your editor's documentation to learn more about how to configure https://microsoft.github.io/language-server-protocol/[LSP servers].
565 To verify which configuration is actually used by `rust-analyzer`, set `RA_LOG` environment variable to `rust_analyzer=info` and look for config-related messages.
566 Logs should show both the JSON that `rust-analyzer` sees as well as the updated config.
568 This is the list of config options `rust-analyzer` supports:
570 include::./generated_config.adoc[]
572 == Non-Cargo Based Projects
574 rust-analyzer does not require Cargo.
575 However, if you use some other build system, you'll have to describe the structure of your project for rust-analyzer in the `rust-project.json` format:
579 interface JsonProject {
580 /// Path to the directory with *source code* of
583 /// It should point to the directory where std,
584 /// core, and friends can be found:
586 /// https://github.com/rust-lang/rust/tree/master/library.
588 /// If provided, rust-analyzer automatically adds
589 /// dependencies on sysroot crates. Conversely,
590 /// if you omit this path, you can specify sysroot
591 /// dependencies yourself and, for example, have
592 /// several different "sysroots" in one graph of
594 sysroot_src?: string;
595 /// The set of crates comprising the current
596 /// project. Must include all transitive
597 /// dependencies as well as sysroot crate (libstd,
598 /// libcore and such).
603 /// Optional crate name used for display purposes,
604 /// without affecting semantics. See the `deps`
605 /// key for semantically-significant crate names.
606 display_name?: string;
607 /// Path to the root module of the crate.
609 /// Edition of the crate.
610 edition: "2015" | "2018" | "2021";
613 /// Should this crate be treated as a member of
614 /// current "workspace".
616 /// By default, inferred from the `root_module`
617 /// (members are the crates which reside inside
618 /// the directory opened in the editor).
620 /// Set this to `false` for things like standard
621 /// library and 3rd party crates to enable
622 /// performance optimizations (rust-analyzer
623 /// assumes that non-member crates don't change).
624 is_workspace_member?: boolean;
625 /// Optionally specify the (super)set of `.rs`
626 /// files comprising this crate.
628 /// By default, rust-analyzer assumes that only
629 /// files under `root_module.parent` can belong
630 /// to a crate. `include_dirs` are included
631 /// recursively, unless a subdirectory is in
634 /// Different crates can share the same `source`.
636 /// If two crates share an `.rs` file in common,
637 /// they *must* have the same `source`.
638 /// rust-analyzer assumes that files from one
639 /// source can't refer to files in another source.
641 include_dirs: string[],
642 exclude_dirs: string[],
644 /// The set of cfgs activated for a given crate, like
645 /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
647 /// Target triple for this Crate.
649 /// Used when running `rustc --print cfg`
650 /// to get target-specific cfgs.
652 /// Environment variables, used for
654 env: { [key: string]: string; },
656 /// Whether the crate is a proc-macro crate.
657 is_proc_macro: boolean;
658 /// For proc-macro crates, path to compiled
659 /// proc-macro (.so file).
660 proc_macro_dylib_path?: string;
664 /// Index of a crate in the `crates` array.
666 /// Name as should appear in the (implicit)
667 /// `extern crate name` declaration.
672 This format is provisional and subject to change.
673 Specifically, the `roots` setup will be different eventually.
675 There are three ways to feed `rust-project.json` to rust-analyzer:
677 * Place `rust-project.json` file at the root of the project, and rust-analyzer will discover it.
678 * Specify `"rust-analyzer.linkedProjects": [ "path/to/rust-project.json" ]` in the settings (and make sure that your LSP client sends settings as a part of initialize request).
679 * Specify `"rust-analyzer.linkedProjects": [ { "roots": [...], "crates": [...] }]` inline.
681 Relative paths are interpreted relative to `rust-project.json` file location or (for inline JSON) relative to `rootUri`.
683 See https://github.com/rust-analyzer/rust-project.json-example for a small example.
685 You can set the `RA_LOG` environment variable to `rust_analyzer=info` to inspect how rust-analyzer handles config and project loading.
687 Note that calls to `cargo check` are disabled when using `rust-project.json` by default, so compilation errors and warnings will no longer be sent to your LSP client. To enable these compilation errors you will need to specify explicitly what command rust-analyzer should run to perform the checks using the `checkOnSave.overrideCommand` configuration. As an example, the following configuration explicitly sets `cargo check` as the `checkOnSave` command.
691 { "rust-analyzer.checkOnSave.overrideCommand": ["cargo", "check", "--message-format=json"] }
694 The `checkOnSave.overrideCommand` requires the command specified to output json error messages for rust-analyzer to consume. The `--message-format=json` flag does this for `cargo check` so whichever command you use must also output errors in this format. See the <<Configuration>> section for more information.
698 At the moment, rust-analyzer assumes that all code is trusted.
699 Here is a **non-exhaustive** list of ways to make rust-analyzer execute arbitrary code:
701 * proc macros and build scripts are executed by default
702 * `.cargo/config` can override `rustc` with an arbitrary executable
703 * `rust-toolchain.toml` can override `rustc` with an arbitrary executable
704 * VS Code plugin reads configuration from project directory, and that can be used to override paths to various executables, like `rustfmt` or `rust-analyzer` itself.
705 * rust-analyzer's syntax trees library uses a lot of `unsafe` and hasn't been properly audited for memory safety.
709 The LSP server performs no network access in itself, but runs `cargo metadata` which will update or download the crate registry and the source code of the project dependencies.
710 If enabled (the default), build scripts and procedural macros can do anything.
712 The Code extension does not access the network.
714 Any other editor plugins are not under the control of the `rust-analyzer` developers. For any privacy concerns, you should check with their respective developers.
716 For `rust-analyzer` developers, `cargo xtask release` uses the GitHub API to put together the release notes.
720 include::./generated_features.adoc[]
722 == Assists (Code Actions)
724 Assists, or code actions, are small local refactorings, available in a particular context.
725 They are usually triggered by a shortcut or by clicking a light bulb icon in the editor.
726 Cursor position or selection is signified by `┃` character.
728 include::./generated_assists.adoc[]
732 While most errors and warnings provided by rust-analyzer come from the `cargo check` integration, there's a growing number of diagnostics implemented using rust-analyzer's own analysis.
733 Some of these diagnostics don't respect `\#[allow]` or `\#[deny]` attributes yet, but can be turned off using the `rust-analyzer.diagnostics.enable`, `rust-analyzer.diagnostics.experimental.enable` or `rust-analyzer.diagnostics.disabled` settings.
735 include::./generated_diagnostic.adoc[]
740 ==== Color configurations
742 It is possible to change the foreground/background color and font family/size of inlay hints.
743 Just add this to your `settings.json`:
748 "editor.inlayHints.fontFamily": "Courier New",
749 "editor.inlayHints.fontSize": 11,
751 "workbench.colorCustomizations": {
752 // Name of the theme you are currently using
754 "editorInlayHint.foreground": "#868686f0",
755 "editorInlayHint.background": "#3d3d3d48",
757 // Overrides for specific kinds of inlay hints
758 "editorInlayHint.typeForeground": "#fdb6fdf0",
759 "editorInlayHint.parameterForeground": "#fdb6fdf0",
765 ==== Semantic style customizations
767 You can customize the look of different semantic elements in the source code.
768 For example, mutable bindings are underlined by default and you can override this behavior by adding the following section to your `settings.json`:
773 "editor.semanticTokenColorCustomizations": {
776 "fontStyle": "", // underline is the default
783 Most themes doesn't support styling unsafe operations differently yet. You can fix this by adding overrides for the rules `operator.unsafe`, `function.unsafe`, and `method.unsafe`:
788 "editor.semanticTokenColorCustomizations": {
790 "operator.unsafe": "#ff6600",
791 "function.unsafe": "#ff6600",
792 "method.unsafe": "#ff6600"
798 In addition to the top-level rules you can specify overrides for specific themes. For example, if you wanted to use a darker text color on a specific light theme, you might write:
803 "editor.semanticTokenColorCustomizations": {
805 "operator.unsafe": "#ff6600"
809 "operator.unsafe": "#572300"
816 Make sure you include the brackets around the theme name. For example, use `"[Ayu Light]"` to customize the theme Ayu Light.
818 ==== Special `when` clause context for keybindings.
819 You may use `inRustProject` context to configure keybindings for rust projects only.
826 "command": "rust-analyzer.openDocs",
827 "when": "inRustProject"
830 More about `when` clause contexts https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts[here].
832 ==== Setting runnable environment variables
833 You can use "rust-analyzer.runnableEnv" setting to define runnable environment-specific substitution variables.
834 The simplest way for all runnables in a bunch:
836 "rust-analyzer.runnableEnv": {
837 "RUN_SLOW_TESTS": "1"
841 Or it is possible to specify vars more granularly:
843 "rust-analyzer.runnableEnv": [
845 // "mask": null, // null mask means that this rule will be applied for all runnables
854 "APP_ID": "2", // overwrites only APP_ID
860 You can use any valid regular expression as a mask.
861 Also note that a full runnable name is something like *run bin_or_example_name*, *test some::mod::test_name* or *test-mod some::mod*, so it is possible to distinguish binaries, single tests, and test modules with this masks: `"^run"`, `"^test "` (the trailing space matters!), and `"^test-mod"` respectively.
863 ==== Compiler feedback from external commands
865 Instead of relying on the built-in `cargo check`, you can configure Code to run a command in the background and use the `$rustc-watch` problem matcher to generate inline error markers from its output.
867 To do this you need to create a new https://code.visualstudio.com/docs/editor/tasks[VS Code Task] and set `rust-analyzer.checkOnSave.enable: false` in preferences.
869 For example, if you want to run https://crates.io/crates/cargo-watch[`cargo watch`] instead, you might add the following to `.vscode/tasks.json`:
876 "command": "cargo watch",
877 "problemMatcher": "$rustc-watch",
884 VS Code Live Share has partial support for rust-analyzer.
886 Live Share _requires_ the official Microsoft build of VS Code, OSS builds will not work correctly.
888 The host's rust-analyzer instance will be shared with all guests joining the session.
889 The guests do not have to have the rust-analyzer extension installed for this to work.
891 If you are joining a Live Share session and _do_ have rust-analyzer installed locally, commands from the command palette will not work correctly since they will attempt to communicate with the local server.