# User Manual

At its core, rust-analyzer is a library for semantic analysis of Rust code as it changes over time. This manual focuses on a specific usage of the library — running it as part of a server that implements the Language Server Protocol (LSP). 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.

| To improve this document, send a pull request: https://github.com/rust-analyzer/…​/manual.adoc The manual is written in 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.

If you have questions about using rust-analyzer, please ask them in the “IDEs and Editors” topic of Rust users forum.

## Installation

In theory, one should be able to just install the `rust-analyzer` binary and have it automatically work with any editor. We are not there yet, so some editor specific setup is required.

Additionally, rust-analyzer needs the sources of the standard library. If the source code is not present, rust-analyzer will attempt to install it automatically.

To add the sources manually, run the following command:

    $ rustup component add rust-src

### Toolchain

Only the latest stable standard library source is officially supported for use with rust-analyzer. If you are using an older toolchain or have an override set, rust-analyzer may fail to understand the Rust source. You will either need to update your toolchain or use an older version of rust-analyzer that is compatible with your toolchain.

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`. For example, with VS Code or coc-rust-analyzer:

    { "rust-analyzer.server.extraEnv": { "RUSTUP_TOOLCHAIN": "stable" } }

### VS Code

This is the best supported editor at the moment. The rust-analyzer plugin for VS Code is maintained in tree.

You can install the latest release of the plugin from the marketplace.

Note that the plugin may cause conflicts with the previous official Rust plugin. The latter is no longer maintained and should be uninstalled.

The server binary is stored in the extension install directory, which starts with `rust-lang.rust-analyzer-` and is located under:

- Linux: `~/.vscode/extensions`

- Linux (Remote, such as WSL): `~/.vscode-server/extensions`

- macOS: `~/.vscode/extensions`

- Windows: `%USERPROFILE%\.vscode\extensions`

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`.

Note that we only support the two most recent versions of VS Code.

#### Updates

The extension will be updated automatically as new versions become available. It will ask your permission to download the matching language server version binary if needed.

##### Nightly

We ship nightly releases for VS Code. To help us out by testing the newest code, you can enable pre-release versions in the Code extension page.

#### Manual installation

Alternatively, download a VSIX corresponding to your platform from the releases page.

Install the extension with the `Extensions: Install from VSIX` command within VS Code, or from the command line via:

    $ code --install-extension /path/to/rust-analyzer.vsix

If you are running an unsupported platform, you can install `rust-analyzer-no-server.vsix` and compile or obtain a server binary. Copy the server anywhere, then add the path to your settings.json, for example:

    { "rust-analyzer.server.path": "~/.local/bin/rust-analyzer-linux" }

#### Building From Source

Both the server and the Code plugin can be installed from source:

    $ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
    $ cargo xtask install

You’ll need Cargo, nodejs (matching a supported version of VS Code) and npm for this.

Note that installing via `xtask install` does not work for VS Code Remote, instead you’ll need to install the `.vsix` manually.

If you’re not using Code, you can compile and install only the LSP server:

    $ cargo xtask install --server

Make sure that `.cargo/bin` is in `$PATH` and precedes paths where `rust-analyzer` may also be installed. Specifically, `rustup` includes a proxy called `rust-analyzer`, which can cause problems if you’re planning to use a source build or even a downloaded binary.

### rust-analyzer Language Server Binary

Other editors generally require the `rust-analyzer` binary to be in `$PATH`. You can download pre-built binaries from the releases page. 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`.

On Linux to install the `rust-analyzer` binary into `~/.local/bin`, these commands should work:

    $ mkdir -p ~/.local/bin
    $ 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
    $ chmod +x ~/.local/bin/rust-analyzer

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.

You don’t have to use `~/.local/bin`, any other path like `~/.cargo/bin` or `/usr/local/bin` will work just as well.

Alternatively, you can install it from source using the command below. You’ll need the latest stable version of the Rust toolchain.

    $ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
    $ cargo xtask install --server

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 this issue. On Unix, running the editor from a shell or changing the `.desktop` file to set the environment should help.

#### rustup

`rust-analyzer` is available in `rustup`:

    $ rustup component add rust-analyzer

#### Arch Linux

The `rust-analyzer` binary can be installed from the repos or AUR (Arch User Repository):

- `rust-analyzer` (built from latest tagged source)

- `rust-analyzer-git` (latest Git version)

Install it with pacman, for example:

    $ pacman -S rust-analyzer

#### Gentoo Linux

There are two ways to install `rust-analyzer` under Gentoo:

- when installing `dev-lang/rust` or `dev-lang/rust-bin`, enable the `rust-analyzer` and `rust-src` USE flags

- use the `rust-analyzer` component in `rustup` (see instructions above)

Note that in both cases, the version installed lags for a couple of months behind the official releases on GitHub. To obtain a newer one, you can download a binary from GitHub Releases or building from source.

#### macOS

The `rust-analyzer` binary can be installed via Homebrew.

    $ brew install rust-analyzer

### VS Code or VSCodium in Flatpak

Setting up `rust-analyzer` with a Flatpak version of Code is not trivial because of the Flatpak sandbox. While the sandbox can be disabled for some directories, `/usr/bin` will always be mounted under `/run/host/usr/bin`. This prevents access to the system’s C compiler, a system-wide installation of Rust, or any other libraries you might want to link to. Some compilers and libraries can be acquired as Flatpak SDKs, such as `org.freedesktop.Sdk.Extension.rust-stable` or `org.freedesktop.Sdk.Extension.llvm15`.

If you use a Flatpak SDK for Rust, there should be no extra steps necessary.

If you want to use Flatpak in combination with `rustup`, the following steps might help:

- both Rust and `rustup` have to be installed using https://rustup.rs. Distro packages will not work.

- you need to launch Code, open a terminal and run `echo $PATH`

- using Flatseal, you must add an environment variable called `PATH`. Set its value to the output from above, appending `:~/.cargo/bin`, where `~` is the path to your home directory. You must replace `~`, as it won’t be expanded otherwise.

- while Flatseal is open, you must enable access to "All user files"

A C compiler should already be available via `org.freedesktop.Sdk`. Any other tools or libraries you will need to acquire from Flatpak.

### Emacs

Prerequisites: You have installed the `rust-analyzer` binary.

To use `rust-analyzer`, you need to install and enable one of the two popular LSP client implementations for Emacs, Eglot or LSP Mode. Both enable `rust-analyzer` by default in rust buffers if it is available.

#### Eglot

Eglot is the more minimalistic and lightweight LSP client for Emacs, integrates well with existing Emacs functionality and is built into Emacs starting from release 29.

After installing Eglot, e.g. via `M-x package-install` (not needed from Emacs 29), you can enable it via the `M-x eglot` command or load it automatically in `rust-mode` via

    (add-hook 'rust-mode-hook 'eglot-ensure)

To enable clippy, you will need to configure the initialization options to pass the `check.command` setting.

    (add-to-list 'eglot-server-programs
                 '((rust-ts-mode rust-mode) .
                   ("rust-analyzer" :initializationOptions (:check (:command "clippy")))))

For more detailed instructions and options see the Eglot manual (also available from Emacs via `M-x info`) and the Eglot readme.

Eglot does not support the rust-analyzer extensions to the language-server protocol and does not aim to do so in the future. The eglot-x package adds experimental support for those LSP extensions.

#### LSP Mode

LSP-mode is the original LSP-client for emacs. Compared to Eglot it has a larger codebase and supports more features, like LSP protocol extensions. With extension packages like LSP UI it offers a lot of visual eyecandy. Further it integrates well with DAP mode for support of the Debug Adapter Protocol.

You can install LSP-mode via `M-x package-install` and then run it via the `M-x lsp` command or load it automatically in rust buffers with

    (add-hook 'rust-mode-hook 'lsp-deferred)

For more information on how to set up LSP mode and its extension package see the instructions in the LSP mode manual. Also see the rust-analyzer section for `rust-analyzer` specific options and commands, which you can optionally bind to keys.

Note the excellent guide from @rksm on how to set-up Emacs for Rust development with LSP mode and several other packages.

### Vim/Neovim

Prerequisites: You have installed the `rust-analyzer` binary. Not needed if the extension can install/update it on its own, coc-rust-analyzer is one example.

There are several LSP client implementations for Vim or Neovim:

#### coc-rust-analyzer

1. Install coc.nvim by following the instructions at coc.nvim (Node.js required)

2. Run `:CocInstall coc-rust-analyzer` to install coc-rust-analyzer, this extension implements most of the features supported in the VSCode extension:

   - automatically install and upgrade stable/nightly releases

   - same configurations as VSCode extension, `rust-analyzer.server.path`, `rust-analyzer.cargo.features` etc.

   - same commands too, `rust-analyzer.analyzerStatus`, `rust-analyzer.ssr` etc.

   - inlay hints for variables and method chaining, Neovim Only

Note: for code actions, use `coc-codeaction-cursor` and `coc-codeaction-selected`; `coc-codeaction` and `coc-codeaction-line` are unlikely to be useful.

#### LanguageClient-neovim

1. Install LanguageClient-neovim by following the instructions here

   - The GitHub project wiki has extra tips on configuration

2. Configure by adding this to your Vim/Neovim config file (replacing the existing Rust-specific line if it exists):

       let g:LanguageClient_serverCommands = {
       \ 'rust': ['rust-analyzer'],
       \ }

#### YouCompleteMe

Install YouCompleteMe by following the instructions here.

rust-analyzer is the default in ycm, it should work out of the box.

#### ALE

To use the LSP server in ale:

    let g:ale_linters = {'rust': ['analyzer']}

#### nvim-lsp

Neovim 0.5 has built-in language server support. For a quick start configuration of rust-analyzer, use neovim/nvim-lspconfig. Once `neovim/nvim-lspconfig` is installed, use `lua require'lspconfig'.rust_analyzer.setup({})` in your `init.vim`.

You can also pass LSP settings to the server:

    lua << EOF
    local lspconfig = require'lspconfig'

    local on_attach = function(client)
        require'completion'.on_attach(client)
    end

    lspconfig.rust_analyzer.setup({
        on_attach = on_attach,
        settings = {
            ["rust-analyzer"] = {
                imports = {
                    granularity = {
                        group = "module",
                    },
                    prefix = "self",
                },
                cargo = {
                    buildScripts = {
                        enable = true,
                    },
                },
                procMacro = {
                    enable = true
                },
            }
        }
    })
    EOF

If you’re running Neovim 0.10 or later, you can enable inlay hints via `on_attach`:

    lspconfig.rust_analyzer.setup({
        on_attach = function(client, bufnr)
            vim.lsp.inlay_hint.enable(bufnr)
        end
    })

Note that the hints are only visible after `rust-analyzer` has finished loading and you have to edit the file to trigger a re-render.

See https://sharksforarms.dev/posts/neovim-rust/ for more tips on getting started.

Check out https://github.com/mrcjkb/rustaceanvim for a batteries included rust-analyzer setup for Neovim.

#### vim-lsp

vim-lsp is installed by following the plugin instructions. It can be as simple as adding this line to your `.vimrc`:

    Plug 'prabirshrestha/vim-lsp'

Next you need to register the `rust-analyzer` binary. If it is available in `$PATH`, you may want to add this to your `.vimrc`:

    if executable('rust-analyzer')
      au User lsp_setup call lsp#register_server({
            \   'name': 'Rust Language Server',
            \   'cmd': {server_info->['rust-analyzer']},
            \   'whitelist': ['rust'],
            \ })
    endif

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 section. Here is an example of how to enable the proc-macro support:

    if executable('rust-analyzer')
      au User lsp_setup call lsp#register_server({
            \   'name': 'Rust Language Server',
            \   'cmd': {server_info->['rust-analyzer']},
            \   'whitelist': ['rust'],
            \   'initialization_options': {
            \     'cargo': {
            \       'buildScripts': {
            \         'enable': v:true,
            \       },
            \     },
            \     'procMacro': {
            \       'enable': v:true,
            \     },
            \   },
            \ })
    endif

### Sublime Text

#### Sublime Text 4:

- Follow the instructions in LSP-rust-analyzer.

| Install LSP-file-watcher-chokidar to enable file watching (`workspace/didChangeWatchedFiles`).

#### Sublime Text 3:

- Install the `rust-analyzer` binary.

- Install the LSP package.

- From the command palette, run `LSP: Enable Language Server Globally` and select `rust-analyzer`.

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.

If you get an error saying `No such file or directory: 'rust-analyzer'`, see the `rust-analyzer` binary section on installing the language server binary.

### GNOME Builder

GNOME Builder 3.37.1 and newer has native `rust-analyzer` support. If the LSP binary is not available, GNOME Builder can install it when opening a Rust file.

### Eclipse IDE

Support for Rust development in the Eclipse IDE is provided by Eclipse Corrosion. If available in PATH or in some standard location, `rust-analyzer` is detected and powers editing of Rust files without further configuration. 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. You’ll need to close and reopen all .rs and Cargo files, or to restart the IDE, for this change to take effect.

### Kate Text Editor

Support for the language server protocol is built into Kate through the LSP plugin, which is included by default. It is preconfigured to use rust-analyzer for Rust sources since Kate 21.12.

To change rust-analyzer config options, start from the following example and put it into Kate’s "User Server Settings" tab (located under the LSP Client settings):

    {
        "servers": {
            "rust": {
                "initializationOptions": {
                    "cachePriming": {
                        "enable": false
                    },
                    "check": {
                        "allTargets": false
                    },
                    "checkOnSave": false
                }
            }
        }
    }

Then click on apply, and restart the LSP server for your rust project.

### juCi++

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.

### Kakoune

Kakoune supports LSP with the help of `kak-lsp`. Follow the instructions to install `kak-lsp`. To configure `kak-lsp`, refer to the configuration section which is basically about copying the configuration file in the right place (latest versions should use `rust-analyzer` by default).

Finally, you need to configure Kakoune to talk to `kak-lsp` (see Usage section). A basic configuration will only get you LSP but you can also activate inlay diagnostics and auto-formatting on save. The following might help you get all of this.

    eval %sh{kak-lsp --kakoune -s $kak_session}  # Not needed if you load it with plug.kak.
    hook global WinSetOption filetype=rust %{
        # Enable LSP
        lsp-enable-window

        # Auto-formatting on save
        hook window BufWritePre .* lsp-formatting-sync

        # Configure inlay hints (only on save)
        hook window -group rust-inlay-hints BufWritePost .* rust-analyzer-inlay-hints
        hook -once -always window WinSetOption filetype=.* %{
            remove-hooks window rust-inlay-hints
        }
    }

### Helix

Helix supports LSP by default. However, it won’t install `rust-analyzer` automatically. You can follow instructions for installing `rust-analyzer` binary.

### Visual Studio 2022

There are multiple rust-analyzer extensions for Visual Studio 2022 on Windows:

#### rust-analyzer.vs

(License: Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International)

Visual Studio Marketplace

GitHub

Support for Rust development in the Visual Studio IDE is enabled by the rust-analyzer package. Either click on the download link or install from IDE’s extension manager. For now Visual Studio 2022 is required. All editions are supported viz. Community, Professional & Enterprise. The package aims to provide 0-friction installation and therefore comes loaded with most things required including rust-analyzer binary. If anything it needs is missing, appropriate errors / warnings will guide the user. E.g. cargo.exe needs to be in path and the package will tell you as much. This package is under rapid active development. So if you encounter any issues please file it at rust-analyzer.vs.

#### VS_RustAnalyzer

(License: GPL)

Visual Studio Marketplace

GitHub

#### SourceGear Rust

(License: closed source)

Visual Studio Marketplace

GitHub (docs, issues, discussions)

- Free (no-cost)

- Supports all editions of Visual Studio 2022 on Windows: Community, Professional, or Enterprise

### Lapce

Lapce has a Rust plugin which you can install directly. Unfortunately, it downloads an old version of `rust-analyzer`, but you can set the server path under Settings.

### Crates

There is a package named `ra_ap_rust_analyzer` available on crates.io, for someone who wants to use it programmatically.

For more details, see the publish workflow.

### Zed

Zed has native `rust-analyzer` support. If the LSP binary is not available, Zed can install it when opening a Rust file.

## Troubleshooting

Start with looking at the rust-analyzer version. 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. If the date is more than a week ago, it’s better to update rust-analyzer version.

The next thing to check would be panic messages in rust-analyzer’s log. Log messages are printed to stderr, in VS Code you can see them in the `Output > Rust Analyzer Language Server` tab of the panel. 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.

To fully capture LSP messages between the editor and the server, set `"rust-analyzer.trace.server": "verbose"` config and check `Output > Rust Analyzer Language Server Trace`.

The root cause for many “nothing works” problems is that rust-analyzer fails to understand the project structure. To debug that, first note the `rust-analyzer` section in the status bar. If it has an error icon and red, that’s the problem (hover will have somewhat helpful error message). rust-analyzer: Status prints dependency information for the current file. Finally, `RA_LOG=project_model=debug` enables verbose logs during project loading.

If rust-analyzer outright crashes, try running `rust-analyzer analysis-stats /path/to/project/directory/` on the command line. This command type checks the whole project in batch mode bypassing LSP machinery.

When filing issues, it is useful (but not necessary) to try to minimize examples. An ideal bug reproduction looks like this:

    $ git clone https://github.com/username/repo.git && cd repo && git switch --detach commit-hash
    $ rust-analyzer --version
    rust-analyzer dd12184e4 2021-05-08 dev
    $ rust-analyzer analysis-stats .
    💀 💀 💀

It is especially useful when the `repo` doesn’t use external crates or the standard library.

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 dev docs!

## Configuration

Source: config.rs

The Installation section contains details on configuration for some of the editors. 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.

Some clients, such as VS Code or 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`.

For the later category, it might help to know that the initial configuration is specified as a value of the `initializationOptions` field of the `InitializeParams` message, in the LSP protocol. 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. Name of the setting, ignoring the `rust-analyzer.` prefix, is used as a path, and value of the setting becomes the JSON property value.

For example, a very common configuration is to enable proc-macro support, can be achieved by sending this JSON:

    {
      "cargo": {
        "buildScripts": {
          "enable": true,
        },
      },
      "procMacro": {
        "enable": true,
      }
    }

Please consult your editor’s documentation to learn more about how to configure LSP servers.

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. Logs should show both the JSON that `rust-analyzer` sees as well as the updated config.

This is the list of config options `rust-analyzer` supports:

rust-analyzer.assist.emitMustUse (default: `false`)

  Whether to insert #[must_use] when generating `as_` methods for enum variants.

rust-analyzer.assist.expressionFillDefault (default: `"todo"`)

  Placeholder expression to use for missing expressions in assists.

rust-analyzer.cachePriming.enable (default: `true`)

  Warm up caches on project load.

rust-analyzer.cachePriming.numThreads (default: `0`)

  How many worker threads to handle priming caches. The default `0` means to pick automatically.

rust-analyzer.cargo.autoreload (default: `true`)

  Automatically refresh project info via `cargo metadata` on `Cargo.toml` or `.cargo/config.toml` changes.

rust-analyzer.cargo.buildScripts.enable (default: `true`)

  Run build scripts (`build.rs`) for more precise code analysis.

rust-analyzer.cargo.buildScripts.invocationLocation (default: `"workspace"`)

  Specifies the working directory for running build scripts. - "workspace": run build scripts for a workspace in the workspace’s root directory. This is incompatible with `rust-analyzer.cargo.buildScripts.invocationStrategy` set to `once`. - "root": run build scripts in the project’s root directory. This config only has an effect when `rust-analyzer.cargo.buildScripts.overrideCommand` is set.

rust-analyzer.cargo.buildScripts.invocationStrategy (default: `"per_workspace"`)

  Specifies the invocation strategy to use when running the build scripts command. If `per_workspace` is set, the command will be executed for each workspace. If `once` is set, the command will be executed once. This config only has an effect when `rust-analyzer.cargo.buildScripts.overrideCommand` is set.

rust-analyzer.cargo.buildScripts.overrideCommand (default: `null`)

  Override the command rust-analyzer uses to run build scripts and build procedural macros. The command is required to output json and should therefore include `--message-format=json` or a similar option.

  If there are multiple linked projects/workspaces, this command is invoked for each of them, with the working directory being the workspace root (i.e., the folder containing the `Cargo.toml`). This can be overwritten by changing `rust-analyzer.cargo.buildScripts.invocationStrategy` and `rust-analyzer.cargo.buildScripts.invocationLocation`.

  By default, a cargo invocation will be constructed for the configured targets and features, with the following base command line:

      cargo check --quiet --workspace --message-format=json --all-targets

  .

rust-analyzer.cargo.buildScripts.rebuildOnSave (default: `true`)

  Rerun proc-macros building/build-scripts running when proc-macro or build-script sources change and are saved.

rust-analyzer.cargo.buildScripts.useRustcWrapper (default: `true`)

  Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to avoid checking unnecessary things.

rust-analyzer.cargo.cfgs (default: `{}`)

  List of cfg options to enable with the given values.

rust-analyzer.cargo.extraArgs (default: `[]`)

  Extra arguments that are passed to every cargo invocation.

rust-analyzer.cargo.extraEnv (default: `{}`)

  Extra environment variables that will be set when running cargo, rustc or other commands within the workspace. Useful for setting RUSTFLAGS.

rust-analyzer.cargo.features (default: `[]`)

  List of features to activate.

  Set this to `"all"` to pass `--all-features` to cargo.

rust-analyzer.cargo.noDefaultFeatures (default: `false`)

  Whether to pass `--no-default-features` to cargo.

rust-analyzer.cargo.sysroot (default: `"discover"`)

  Relative path to the sysroot, or "discover" to try to automatically find it via "rustc --print sysroot".

  Unsetting this disables sysroot loading.

  This option does not take effect until rust-analyzer is restarted.

rust-analyzer.cargo.sysrootQueryMetadata (default: `false`)

  Whether to run cargo metadata on the sysroot library allowing rust-analyzer to analyze third-party dependencies of the standard libraries.

  This will cause `cargo` to create a lockfile in your sysroot directory. rust-analyzer will attempt to clean up afterwards, but nevertheless requires the location to be writable to.

rust-analyzer.cargo.sysrootSrc (default: `null`)

  Relative path to the sysroot library sources. If left unset, this will default to `{cargo.sysroot}/lib/rustlib/src/rust/library`.

  This option does not take effect until rust-analyzer is restarted.

rust-analyzer.cargo.target (default: `null`)

  Compilation target override (target triple).

rust-analyzer.cargo.targetDir (default: `null`)

  Optional path to a rust-analyzer specific target directory. This prevents rust-analyzer’s `cargo check` and initial build-script and proc-macro building from locking the `Cargo.lock` at the expense of duplicating build artifacts.

  Set to `true` to use a subdirectory of the existing target directory or set to a path relative to the workspace to use that path.

rust-analyzer.cargo.unsetTest (default: `["core"]`)

  Unsets the implicit `#[cfg(test)]` for the specified crates.

rust-analyzer.checkOnSave (default: `true`)

  Run the check command for diagnostics on save.

rust-analyzer.check.allTargets (default: `true`)

  Check all targets and tests (`--all-targets`).

rust-analyzer.check.command (default: `"check"`)

  Cargo command to use for `cargo check`.

rust-analyzer.check.extraArgs (default: `[]`)

  Extra arguments for `cargo check`.

rust-analyzer.check.extraEnv (default: `{}`)

  Extra environment variables that will be set when running `cargo check`. Extends `rust-analyzer.cargo.extraEnv`.

rust-analyzer.check.features (default: `null`)

  List of features to activate. Defaults to `rust-analyzer.cargo.features`.

  Set to `"all"` to pass `--all-features` to Cargo.

rust-analyzer.check.ignore (default: `[]`)

  List of `cargo check` (or other command specified in `check.command`) diagnostics to ignore.

  For example for `cargo check`: `dead_code`, `unused_imports`, `unused_variables`,…​

rust-analyzer.check.invocationLocation (default: `"workspace"`)

  Specifies the working directory for running checks. - "workspace": run checks for workspaces in the corresponding workspaces' root directories. This falls back to "root" if `rust-analyzer.check.invocationStrategy` is set to `once`. - "root": run checks in the project’s root directory. This config only has an effect when `rust-analyzer.check.overrideCommand` is set.

rust-analyzer.check.invocationStrategy (default: `"per_workspace"`)

  Specifies the invocation strategy to use when running the check command. If `per_workspace` is set, the command will be executed for each workspace. If `once` is set, the command will be executed once. This config only has an effect when `rust-analyzer.check.overrideCommand` is set.

rust-analyzer.check.noDefaultFeatures (default: `null`)

  Whether to pass `--no-default-features` to Cargo. Defaults to `rust-analyzer.cargo.noDefaultFeatures`.

rust-analyzer.check.overrideCommand (default: `null`)

  Override the command rust-analyzer uses instead of `cargo check` for diagnostics on save. The command is required to output json and should therefore include `--message-format=json` or a similar option (if your client supports the `colorDiagnosticOutput` experimental capability, you can use `--message-format=json-diagnostic-rendered-ansi`).

  If you’re changing this because you’re using some tool wrapping Cargo, you might also want to change `rust-analyzer.cargo.buildScripts.overrideCommand`.

  If there are multiple linked projects/workspaces, this command is invoked for each of them, with the working directory being the workspace root (i.e., the folder containing the `Cargo.toml`). This can be overwritten by changing `rust-analyzer.check.invocationStrategy` and `rust-analyzer.check.invocationLocation`.

  If `$saved_file` is part of the command, rust-analyzer will pass the absolute path of the saved file to the provided command. This is intended to be used with non-Cargo build systems. Note that `$saved_file` is experimental and may be removed in the futureg.

  An example command would be:

      cargo check --workspace --message-format=json --all-targets

  .

rust-analyzer.check.targets (default: `null`)

  Check for specific targets. Defaults to `rust-analyzer.cargo.target` if empty.

  Can be a single target, e.g. `"x86_64-unknown-linux-gnu"` or a list of targets, e.g. `["aarch64-apple-darwin", "x86_64-apple-darwin"]`.

  Aliased as `"checkOnSave.targets"`.

rust-analyzer.check.workspace (default: `true`)

  Whether `--workspace` should be passed to `cargo check`. If false, `-p <package>` will be passed instead.

rust-analyzer.completion.autoimport.enable (default: `true`)

  Toggles the additional completions that automatically add imports when completed. Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.

rust-analyzer.completion.autoself.enable (default: `true`)

  Toggles the additional completions that automatically show method calls and field accesses with `self` prefixed to them when inside a method.

rust-analyzer.completion.callable.snippets (default: `"fill_arguments"`)

  Whether to add parenthesis and argument snippets when completing function.

rust-analyzer.completion.fullFunctionSignatures.enable (default: `false`)

  Whether to show full function/method signatures in completion docs.

rust-analyzer.completion.limit (default: `null`)

  Maximum number of completions to return. If `None`, the limit is infinite.

rust-analyzer.completion.postfix.enable (default: `true`)

  Whether to show postfix snippets like `dbg`, `if`, `not`, etc.

rust-analyzer.completion.privateEditable.enable (default: `false`)

  Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.

rust-analyzer.completion.snippets.custom

  Default:

      {
                  "Arc::new": {
                      "postfix": "arc",
                      "body": "Arc::new(${receiver})",
                      "requires": "std::sync::Arc",
                      "description": "Put the expression into an `Arc`",
                      "scope": "expr"
                  },
                  "Rc::new": {
                      "postfix": "rc",
                      "body": "Rc::new(${receiver})",
                      "requires": "std::rc::Rc",
                      "description": "Put the expression into an `Rc`",
                      "scope": "expr"
                  },
                  "Box::pin": {
                      "postfix": "pinbox",
                      "body": "Box::pin(${receiver})",
                      "requires": "std::boxed::Box",
                      "description": "Put the expression into a pinned `Box`",
                      "scope": "expr"
                  },
                  "Ok": {
                      "postfix": "ok",
                      "body": "Ok(${receiver})",
                      "description": "Wrap the expression in a `Result::Ok`",
                      "scope": "expr"
                  },
                  "Err": {
                      "postfix": "err",
                      "body": "Err(${receiver})",
                      "description": "Wrap the expression in a `Result::Err`",
                      "scope": "expr"
                  },
                  "Some": {
                      "postfix": "some",
                      "body": "Some(${receiver})",
                      "description": "Wrap the expression in an `Option::Some`",
                      "scope": "expr"
                  }
              }

  Custom completion snippets.

rust-analyzer.completion.termSearch.enable (default: `false`)

  Whether to enable term search based snippets like `Some(foo.bar().baz())`.

rust-analyzer.diagnostics.disabled (default: `[]`)

  List of rust-analyzer diagnostics to disable.

rust-analyzer.diagnostics.enable (default: `true`)

  Whether to show native rust-analyzer diagnostics.

rust-analyzer.diagnostics.experimental.enable (default: `false`)

  Whether to show experimental rust-analyzer diagnostics that might have more false positives than usual.

rust-analyzer.diagnostics.remapPrefix (default: `{}`)

  Map of prefixes to be substituted when parsing diagnostic file paths. This should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.

rust-analyzer.diagnostics.styleLints.enable (default: `false`)

  Whether to run additional style lints.

rust-analyzer.diagnostics.warningsAsHint (default: `[]`)

  List of warnings that should be displayed with hint severity.

  The warnings will be indicated by faded text or three dots in code and will not show up in the `Problems Panel`.

rust-analyzer.diagnostics.warningsAsInfo (default: `[]`)

  List of warnings that should be displayed with info severity.

  The warnings will be indicated by a blue squiggly underline in code and a blue icon in the `Problems Panel`.

rust-analyzer.files.excludeDirs (default: `[]`)

  These directories will be ignored by rust-analyzer. They are relative to the workspace root, and globs are not supported. You may also need to add the folders to Code’s `files.watcherExclude`.

rust-analyzer.files.watcher (default: `"client"`)

  Controls file watching implementation.

rust-analyzer.highlightRelated.breakPoints.enable (default: `true`)

  Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.

rust-analyzer.highlightRelated.closureCaptures.enable (default: `true`)

  Enables highlighting of all captures of a closure while the cursor is on the `|` or move keyword of a closure.

rust-analyzer.highlightRelated.exitPoints.enable (default: `true`)

  Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`→`).

rust-analyzer.highlightRelated.references.enable (default: `true`)

  Enables highlighting of related references while the cursor is on any identifier.

rust-analyzer.highlightRelated.yieldPoints.enable (default: `true`)

  Enables highlighting of all break points for a loop or block context while the cursor is on any `async` or `await` keywords.

rust-analyzer.hover.actions.debug.enable (default: `true`)

  Whether to show `Debug` action. Only applies when `rust-analyzer.hover.actions.enable` is set.

rust-analyzer.hover.actions.enable (default: `true`)

  Whether to show HoverActions in Rust files.

rust-analyzer.hover.actions.gotoTypeDef.enable (default: `true`)

  Whether to show `Go to Type Definition` action. Only applies when `rust-analyzer.hover.actions.enable` is set.

rust-analyzer.hover.actions.implementations.enable (default: `true`)

  Whether to show `Implementations` action. Only applies when `rust-analyzer.hover.actions.enable` is set.

rust-analyzer.hover.actions.references.enable (default: `false`)

  Whether to show `References` action. Only applies when `rust-analyzer.hover.actions.enable` is set.

rust-analyzer.hover.actions.run.enable (default: `true`)

  Whether to show `Run` action. Only applies when `rust-analyzer.hover.actions.enable` is set.

rust-analyzer.hover.documentation.enable (default: `true`)

  Whether to show documentation on hover.

rust-analyzer.hover.documentation.keywords.enable (default: `true`)

  Whether to show keyword hover popups. Only applies when `rust-analyzer.hover.documentation.enable` is set.

rust-analyzer.hover.links.enable (default: `true`)

  Use markdown syntax for links on hover.

rust-analyzer.hover.memoryLayout.alignment (default: `"hexadecimal"`)

  How to render the align information in a memory layout hover.

rust-analyzer.hover.memoryLayout.enable (default: `true`)

  Whether to show memory layout data on hover.

rust-analyzer.hover.memoryLayout.niches (default: `false`)

  How to render the niche information in a memory layout hover.

rust-analyzer.hover.memoryLayout.offset (default: `"hexadecimal"`)

  How to render the offset information in a memory layout hover.

rust-analyzer.hover.memoryLayout.size (default: `"both"`)

  How to render the size information in a memory layout hover.

rust-analyzer.hover.show.traitAssocItems (default: `null`)

  How many associated items of a trait to display when hovering a trait.

rust-analyzer.imports.granularity.enforce (default: `false`)

  Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.

rust-analyzer.imports.granularity.group (default: `"crate"`)

  How imports should be grouped into use statements.

rust-analyzer.imports.group.enable (default: `true`)

  Group inserted imports by the following order. Groups are separated by newlines.

rust-analyzer.imports.merge.glob (default: `true`)

  Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.

rust-analyzer.imports.preferNoStd (default: `false`)

  Prefer to unconditionally use imports of the core and alloc crate, over the std crate.

rust-analyzer.imports.preferPrelude (default: `false`)

  Whether to prefer import paths containing a `prelude` module.

rust-analyzer.imports.prefix (default: `"plain"`)

  The path structure for newly inserted paths to use.

rust-analyzer.inlayHints.bindingModeHints.enable (default: `false`)

  Whether to show inlay type hints for binding modes.

rust-analyzer.inlayHints.chainingHints.enable (default: `true`)

  Whether to show inlay type hints for method chains.

rust-analyzer.inlayHints.closingBraceHints.enable (default: `true`)

  Whether to show inlay hints after a closing `}` to indicate what item it belongs to.

rust-analyzer.inlayHints.closingBraceHints.minLines (default: `25`)

  Minimum number of lines required before the `}` until the hint is shown (set to 0 or 1 to always show them).

rust-analyzer.inlayHints.closureCaptureHints.enable (default: `false`)

  Whether to show inlay hints for closure captures.

rust-analyzer.inlayHints.closureReturnTypeHints.enable (default: `"never"`)

  Whether to show inlay type hints for return types of closures.

rust-analyzer.inlayHints.closureStyle (default: `"impl_fn"`)

  Closure notation in type and chaining inlay hints.

rust-analyzer.inlayHints.discriminantHints.enable (default: `"never"`)

  Whether to show enum variant discriminant hints.

rust-analyzer.inlayHints.expressionAdjustmentHints.enable (default: `"never"`)

  Whether to show inlay hints for type adjustments.

rust-analyzer.inlayHints.expressionAdjustmentHints.hideOutsideUnsafe (default: `false`)

  Whether to hide inlay hints for type adjustments outside of `unsafe` blocks.

rust-analyzer.inlayHints.expressionAdjustmentHints.mode (default: `"prefix"`)

  Whether to show inlay hints as postfix ops (`.` instead of ``, etc).

rust-analyzer.inlayHints.implicitDrops.enable (default: `false`)

  Whether to show implicit drop hints.

rust-analyzer.inlayHints.lifetimeElisionHints.enable (default: `"never"`)

  Whether to show inlay type hints for elided lifetimes in function signatures.

rust-analyzer.inlayHints.lifetimeElisionHints.useParameterNames (default: `false`)

  Whether to prefer using parameter names as the name for elided lifetime hints if possible.

rust-analyzer.inlayHints.maxLength (default: `25`)

  Maximum length for inlay hints. Set to null to have an unlimited length.

rust-analyzer.inlayHints.parameterHints.enable (default: `true`)

  Whether to show function parameter name inlay hints at the call site.

rust-analyzer.inlayHints.rangeExclusiveHints.enable (default: `false`)

  Whether to show exclusive range inlay hints.

rust-analyzer.inlayHints.reborrowHints.enable (default: `"never"`)

  Whether to show inlay hints for compiler inserted reborrows. This setting is deprecated in favor of rust-analyzer.inlayHints.expressionAdjustmentHints.enable.

rust-analyzer.inlayHints.renderColons (default: `true`)

  Whether to render leading colons for type hints, and trailing colons for parameter hints.

rust-analyzer.inlayHints.typeHints.enable (default: `true`)

  Whether to show inlay type hints for variables.

rust-analyzer.inlayHints.typeHints.hideClosureInitialization (default: `false`)

  Whether to hide inlay type hints for `let` statements that initialize to a closure. Only applies to closures with blocks, same as `rust-analyzer.inlayHints.closureReturnTypeHints.enable`.

rust-analyzer.inlayHints.typeHints.hideNamedConstructor (default: `false`)

  Whether to hide inlay type hints for constructors.

rust-analyzer.interpret.tests (default: `false`)

  Enables the experimental support for interpreting tests.

rust-analyzer.joinLines.joinAssignments (default: `true`)

  Join lines merges consecutive declaration and initialization of an assignment.

rust-analyzer.joinLines.joinElseIf (default: `true`)

  Join lines inserts else between consecutive ifs.

rust-analyzer.joinLines.removeTrailingComma (default: `true`)

  Join lines removes trailing commas.

rust-analyzer.joinLines.unwrapTrivialBlock (default: `true`)

  Join lines unwraps trivial blocks.

rust-analyzer.lens.debug.enable (default: `true`)

  Whether to show `Debug` lens. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.lens.enable (default: `true`)

  Whether to show CodeLens in Rust files.

rust-analyzer.lens.forceCustomCommands (default: `true`)

  Internal config: use custom client-side commands even when the client doesn’t set the corresponding capability.

rust-analyzer.lens.implementations.enable (default: `true`)

  Whether to show `Implementations` lens. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.lens.location (default: `"above_name"`)

  Where to render annotations.

rust-analyzer.lens.references.adt.enable (default: `false`)

  Whether to show `References` lens for Struct, Enum, and Union. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.lens.references.enumVariant.enable (default: `false`)

  Whether to show `References` lens for Enum Variants. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.lens.references.method.enable (default: `false`)

  Whether to show `Method References` lens. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.lens.references.trait.enable (default: `false`)

  Whether to show `References` lens for Trait. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.lens.run.enable (default: `true`)

  Whether to show `Run` lens. Only applies when `rust-analyzer.lens.enable` is set.

rust-analyzer.linkedProjects (default: `[]`)

  Disable project auto-discovery in favor of explicitly specified set of projects.

  Elements must be paths pointing to `Cargo.toml`, `rust-project.json`, or JSON objects in `rust-project.json` format.

rust-analyzer.lru.capacity (default: `null`)

  Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.

rust-analyzer.lru.query.capacities (default: `{}`)

  Sets the LRU capacity of the specified queries.

rust-analyzer.notifications.cargoTomlNotFound (default: `true`)

  Whether to show `can’t find Cargo.toml` error message.

rust-analyzer.notifications.unindexedProject (default: `false`)

  Whether to send an UnindexedProject notification to the client.

rust-analyzer.numThreads (default: `null`)

  How many worker threads in the main loop. The default `null` means to pick automatically.

rust-analyzer.procMacro.attributes.enable (default: `true`)

  Expand attribute macros. Requires `rust-analyzer.procMacro.enable` to be set.

rust-analyzer.procMacro.enable (default: `true`)

  Enable support for procedural macros, implies `rust-analyzer.cargo.buildScripts.enable`.

rust-analyzer.procMacro.ignored (default: `{}`)

  These proc-macros will be ignored when trying to expand them.

  This config takes a map of crate names with the exported proc-macro names to ignore as values.

rust-analyzer.procMacro.server (default: `null`)

  Internal config, path to proc-macro server executable.

rust-analyzer.references.excludeImports (default: `false`)

  Exclude imports from find-all-references.

rust-analyzer.references.excludeTests (default: `false`)

  Exclude tests from find-all-references.

rust-analyzer.runnables.command (default: `null`)

  Command to be executed instead of 'cargo' for runnables.

rust-analyzer.runnables.extraArgs (default: `[]`)

  Additional arguments to be passed to cargo for runnables such as tests or binaries. For example, it may be `--release`.

rust-analyzer.rustc.source (default: `null`)

  Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private projects, or "discover" to try to automatically find it if the `rustc-dev` component is installed.

  Any project which uses rust-analyzer with the rustcPrivate crates must set `[package.metadata.rust-analyzer] rustc_private=true` to use it.

  This option does not take effect until rust-analyzer is restarted.

rust-analyzer.rustfmt.extraArgs (default: `[]`)

  Additional arguments to `rustfmt`.

rust-analyzer.rustfmt.overrideCommand (default: `null`)

  Advanced option, fully override the command rust-analyzer uses for formatting. This should be the equivalent of `rustfmt` here, and not that of `cargo fmt`. The file contents will be passed on the standard input and the formatted result will be read from the standard output.

rust-analyzer.rustfmt.rangeFormatting.enable (default: `false`)

  Enables the use of rustfmt’s unstable range formatting command for the `textDocument/rangeFormatting` request. The rustfmt option is unstable and only available on a nightly build.

rust-analyzer.semanticHighlighting.doc.comment.inject.enable (default: `true`)

  Inject additional highlighting into doc comments.

  When enabled, rust-analyzer will highlight rust source in doc comments as well as intra doc links.

rust-analyzer.semanticHighlighting.nonStandardTokens (default: `true`)

  Whether the server is allowed to emit non-standard tokens and modifiers.

rust-analyzer.semanticHighlighting.operator.enable (default: `true`)

  Use semantic tokens for operators.

  When disabled, rust-analyzer will emit semantic tokens only for operator tokens when they are tagged with modifiers.

rust-analyzer.semanticHighlighting.operator.specialization.enable (default: `false`)

  Use specialized semantic tokens for operators.

  When enabled, rust-analyzer will emit special token types for operator tokens instead of the generic `operator` token type.

rust-analyzer.semanticHighlighting.punctuation.enable (default: `false`)

  Use semantic tokens for punctuation.

  When disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when they are tagged with modifiers or have a special role.

rust-analyzer.semanticHighlighting.punctuation.separate.macro.bang (default: `false`)

  When enabled, rust-analyzer will emit a punctuation semantic token for the `!` of macro calls.

rust-analyzer.semanticHighlighting.punctuation.specialization.enable (default: `false`)

  Use specialized semantic tokens for punctuation.

  When enabled, rust-analyzer will emit special token types for punctuation tokens instead of the generic `punctuation` token type.

rust-analyzer.semanticHighlighting.strings.enable (default: `true`)

  Use semantic tokens for strings.

  In some editors (e.g. vscode) semantic tokens override other highlighting grammars. By disabling semantic tokens for strings, other grammars can be used to highlight their contents.

rust-analyzer.signatureInfo.detail (default: `"full"`)

  Show full signature of the callable. Only shows parameters if disabled.

rust-analyzer.signatureInfo.documentation.enable (default: `true`)

  Show documentation.

rust-analyzer.typing.autoClosingAngleBrackets.enable (default: `false`)

  Whether to insert closing angle brackets when typing an opening angle bracket of a generic argument list.

rust-analyzer.workspace.symbol.search.kind (default: `"only_types"`)

  Workspace symbol search kind.

rust-analyzer.workspace.symbol.search.limit (default: `128`)

  Limits the number of items returned from a workspace symbol search (Defaults to 128). Some clients like vs-code issue new searches on result filtering and don’t require all results to be returned in the initial search. Other clients requires all results upfront and might require a higher limit.

rust-analyzer.workspace.symbol.search.scope (default: `"workspace"`)

  Workspace symbol search scope.

## Non-Cargo Based Projects

rust-analyzer does not require Cargo. 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:

    interface JsonProject {
        /// Path to the sysroot directory.
        ///
        /// The sysroot is where rustc looks for the
        /// crates that are built-in to rust, such as
        /// std.
        ///
        /// https://doc.rust-lang.org/rustc/command-line-arguments.html#--sysroot-override-the-system-root
        ///
        /// To see the current value of sysroot, you
        /// can query rustc:
        ///
        /// ```
        /// $ rustc --print sysroot
        /// /Users/yourname/.rustup/toolchains/stable-x86_64-apple-darwin
        /// ```
        sysroot?: string;
        /// Path to the directory with *source code* of
        /// sysroot crates.
        ///
        /// By default, this is `lib/rustlib/src/rust/library`
        /// relative to the sysroot.
        ///
        /// It should point to the directory where std,
        /// core, and friends can be found:
        ///
        /// https://github.com/rust-lang/rust/tree/master/library.
        ///
        /// If provided, rust-analyzer automatically adds
        /// dependencies on sysroot crates. Conversely,
        /// if you omit this path, you can specify sysroot
        /// dependencies yourself and, for example, have
        /// several different "sysroots" in one graph of
        /// crates.
        sysroot_src?: string;
        /// The set of crates comprising the current
        /// project. Must include all transitive
        /// dependencies as well as sysroot crate (libstd,
        /// libcore and such).
        crates: Crate[];
    }

    interface Crate {
        /// Optional crate name used for display purposes,
        /// without affecting semantics. See the `deps`
        /// key for semantically-significant crate names.
        display_name?: string;
        /// Path to the root module of the crate.
        root_module: string;
        /// Edition of the crate.
        edition: "2015" | "2018" | "2021";
        /// Dependencies
        deps: Dep[];
        /// Should this crate be treated as a member of
        /// current "workspace".
        ///
        /// By default, inferred from the `root_module`
        /// (members are the crates which reside inside
        /// the directory opened in the editor).
        ///
        /// Set this to `false` for things like standard
        /// library and 3rd party crates to enable
        /// performance optimizations (rust-analyzer
        /// assumes that non-member crates don't change).
        is_workspace_member?: boolean;
        /// Optionally specify the (super)set of `.rs`
        /// files comprising this crate.
        ///
        /// By default, rust-analyzer assumes that only
        /// files under `root_module.parent` can belong
        /// to a crate. `include_dirs` are included
        /// recursively, unless a subdirectory is in
        /// `exclude_dirs`.
        ///
        /// Different crates can share the same `source`.
        ///
        /// If two crates share an `.rs` file in common,
        /// they *must* have the same `source`.
        /// rust-analyzer assumes that files from one
        /// source can't refer to files in another source.
        source?: {
            include_dirs: string[],
            exclude_dirs: string[],
        },
        /// The set of cfgs activated for a given crate, like
        /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
        cfg: string[];
        /// Target triple for this Crate.
        ///
        /// Used when running `rustc --print cfg`
        /// to get target-specific cfgs.
        target?: string;
        /// Environment variables, used for
        /// the `env!` macro
        env: { [key: string]: string; },

        /// Whether the crate is a proc-macro crate.
        is_proc_macro: boolean;
        /// For proc-macro crates, path to compiled
        /// proc-macro (.so file).
        proc_macro_dylib_path?: string;
    }

    interface Dep {
        /// Index of a crate in the `crates` array.
        crate: number,
        /// Name as should appear in the (implicit)
        /// `extern crate name` declaration.
        name: string,
    }

This format is provisional and subject to change. Specifically, the `roots` setup will be different eventually.

There are three ways to feed `rust-project.json` to rust-analyzer:

- Place `rust-project.json` file at the root of the project, and rust-analyzer will discover it.

- 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).

- Specify `"rust-analyzer.linkedProjects": [ { "roots": […​], "crates": […​] }]` inline.

Relative paths are interpreted relative to `rust-project.json` file location or (for inline JSON) relative to `rootUri`.

See https://github.com/rust-analyzer/rust-project.json-example for a small example.

You can set the `RA_LOG` environment variable to `rust_analyzer=info` to inspect how rust-analyzer handles config and project loading.

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 `rust-analyzer.check.overrideCommand` configuration. As an example, the following configuration explicitly sets `cargo check` as the `check` command.

    { "rust-analyzer.check.overrideCommand": ["cargo", "check", "--message-format=json"] }

`check.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.

## Security

At the moment, rust-analyzer assumes that all code is trusted. Here is a non-exhaustive list of ways to make rust-analyzer execute arbitrary code:

- proc macros and build scripts are executed by default

- `.cargo/config` can override `rustc` with an arbitrary executable

- `rust-toolchain.toml` can override `rustc` with an arbitrary executable

- 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.

- rust-analyzer’s syntax trees library uses a lot of `unsafe` and hasn’t been properly audited for memory safety.

## Privacy

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. If enabled (the default), build scripts and procedural macros can do anything.

The Code extension does not access the network.

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.

For `rust-analyzer` developers, `cargo xtask release` uses the GitHub API to put together the release notes.

## Features

Unresolved directive in manual.adoc - include::./generated_features.adoc[]

## Assists (Code Actions)

Assists, or code actions, are small local refactorings, available in a particular context. They are usually triggered by a shortcut or by clicking a light bulb icon in the editor. Cursor position or selection is signified by `┃` character.

Unresolved directive in manual.adoc - include::./generated_assists.adoc[]

## Diagnostics

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. 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.

### Clippy

To run `cargo clippy` instead of `cargo check`, you can set `"rust-analyzer.check.command": "clippy"`.

Unresolved directive in manual.adoc - include::./generated_diagnostic.adoc[]

## Editor Features

### VS Code

#### Color configurations

It is possible to change the foreground/background color and font family/size of inlay hints. Just add this to your `settings.json`:

    {
      "editor.inlayHints.fontFamily": "Courier New",
      "editor.inlayHints.fontSize": 11,

      "workbench.colorCustomizations": {
        // Name of the theme you are currently using
        "[Default Dark+]": {
          "editorInlayHint.foreground": "#868686f0",
          "editorInlayHint.background": "#3d3d3d48",

          // Overrides for specific kinds of inlay hints
          "editorInlayHint.typeForeground": "#fdb6fdf0",
          "editorInlayHint.parameterForeground": "#fdb6fdf0",
        }
      }
    }

#### Semantic style customizations

You can customize the look of different semantic elements in the source code. For example, mutable bindings are underlined by default and you can override this behavior by adding the following section to your `settings.json`:

    {
      "editor.semanticTokenColorCustomizations": {
        "rules": {
          "*.mutable": {
            "fontStyle": "", // underline is the default
          },
        }
      },
    }

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`:

    {
       "editor.semanticTokenColorCustomizations": {
             "rules": {
                 "operator.unsafe": "#ff6600",
                 "function.unsafe": "#ff6600",
                 "method.unsafe": "#ff6600"
             }
        },
    }

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:

    {
       "editor.semanticTokenColorCustomizations": {
             "rules": {
                 "operator.unsafe": "#ff6600"
             },
             "[Ayu Light]": {
                "rules": {
                   "operator.unsafe": "#572300"
                }
             }
        },
    }

Make sure you include the brackets around the theme name. For example, use `"[Ayu Light]"` to customize the theme Ayu Light.

#### Special `when` clause context for keybindings.

You may use `inRustProject` context to configure keybindings for rust projects only. For example:

    {
      "key": "ctrl+alt+d",
      "command": "rust-analyzer.openDocs",
      "when": "inRustProject"
    }

More about `when` clause contexts here.

#### Setting runnable environment variables

You can use "rust-analyzer.runnables.extraEnv" setting to define runnable environment-specific substitution variables. The simplest way for all runnables in a bunch:

    "rust-analyzer.runnables.extraEnv": {
        "RUN_SLOW_TESTS": "1"
    }

Or it is possible to specify vars more granularly:

    "rust-analyzer.runnables.extraEnv": [
        {
            // "mask": null, // null mask means that this rule will be applied for all runnables
            "env": {
                 "APP_ID": "1",
                 "APP_DATA": "asdf"
            }
        },
        {
            "mask": "test_name",
            "env": {
                 "APP_ID": "2", // overwrites only APP_ID
            }
        }
    ]

You can use any valid regular expression as a mask. 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.

If needed, you can set different values for different platforms:

    "rust-analyzer.runnables.extraEnv": [
        {
            "platform": "win32", // windows only
            "env": {
                 "APP_DATA": "windows specific data"
            }
        },
        {
            "platform": ["linux"],
            "env": {
                 "APP_DATA": "linux data",
            }
        },
        { // for all platforms
            "env": {
                 "APP_COMMON_DATA": "xxx",
            }
        }
    ]

#### Compiler feedback from external commands

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.

To do this you need to create a new VS Code Task and set `"rust-analyzer.checkOnSave": false` in preferences.

For example, if you want to run `cargo watch` instead, you might add the following to `.vscode/tasks.json`:

    {
        "label": "Watch",
        "group": "build",
        "type": "shell",
        "command": "cargo watch",
        "problemMatcher": "$rustc-watch",
        "isBackground": true
    }

#### Live Share

VS Code Live Share has partial support for rust-analyzer.

Live Share requires the official Microsoft build of VS Code, OSS builds will not work correctly.

The host’s rust-analyzer instance will be shared with all guests joining the session. The guests do not have to have the rust-analyzer extension installed for this to work.

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.