rust-analyzer

https://rust-analyzer.github.io/book
Admin
rust-analyzer is a language server that provides IDE functionality for Rust programs, including...
Tokens:96,205
Snippets:1,483
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example installation output

Source: https://rust-analyzer.github.io/book/print.html

The expected output format after running the installation command.

```text
Installing <path-to-rust-analyzer-binary>
Installed package `rust-analyzer v0.0.0 (<path-to-rust-analyzer-binary>)` (executable `rust-analyzer.exe`)
```

--------------------------------

### Minimal Bug Reproduction Setup

Source: https://rust-analyzer.github.io/book/troubleshooting.html

Steps to create a minimal, reproducible example for bug reporting. This involves cloning a specific commit and running version and analysis commands.

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

--------------------------------

### Generate Doc Example

Source: https://rust-analyzer.github.io/book/assists.html

Generates a rustdoc example template.

```rust
__
/// Adds two numbers.┃
pub fn add(a: i32, b: i32) -> i32 { a + b }
```

```rust
__
/// Adds two numbers.
///
/// # Examples
///
/// ```
/// use ra_test_fixture::add;
///
/// assert_eq!(add(a, b), );
/// ```
pub fn add(a: i32, b: i32) -> i32 { a + b }
```

--------------------------------

### Install rust-analyzer on Linux

Source: https://rust-analyzer.github.io/book/rust_analyzer_binary.html

Installs the rust-analyzer binary to ~/.local/bin on Linux. Ensure ~/.local/bin is in your PATH.

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

--------------------------------

### Install rustc-josh-sync Tool

Source: https://rust-analyzer.github.io/book/contributing/index.html

Installs the rustc-josh-sync tool from its Git repository. Ensure you have Cargo installed.

```bash
cargo install --locked --git https://github.com/rust-lang/josh-sync
```

--------------------------------

### Install the rust-analyzer language server

Source: https://rust-analyzer.github.io/book/print.html

Use this command to build and install the language server binary for a specific editor.

```bash
cargo xtask install --server \
    --code-bin code-insiders \
    --dev-rel
```

--------------------------------

### Install rust-analyzer Server Only from Source

Source: https://rust-analyzer.github.io/book/vs_code.html

Compile and install only the LSP server from source if not using VS Code.

```bash
cargo xtask install --server
```

--------------------------------

### Install rust-analyzer from Source

Source: https://rust-analyzer.github.io/book/vs_code.html

Clone the rust-analyzer repository and install the extension and language server from source using cargo xtask.

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

--------------------------------

### Install rust-analyzer via Homebrew

Source: https://rust-analyzer.github.io/book/rust_analyzer_binary.html

Installs the rust-analyzer binary using the Homebrew package manager.

```bash
brew install rust-analyzer
```

--------------------------------

### Install VSIX extension via command line

Source: https://rust-analyzer.github.io/book/print.html

Use the code CLI to install a downloaded VSIX file.

```bash
code --install-extension /path/to/rust-analyzer.vsix
```

--------------------------------

### Parent Module Navigation Example

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

Demonstrates the file structure context for the experimental/parentModule request.

```rust
// src/main.rs
mod foo;
// src/foo.rs

/* cursor here*/
```

--------------------------------

### Install rust-analyzer Extension from VSIX

Source: https://rust-analyzer.github.io/book/vs_code.html

Use this command to install the rust-analyzer extension from a downloaded VSIX file.

```bash
code --install-extension /path/to/rust-analyzer.vsix
```

--------------------------------

### Install rust-analyzer using rustup

Source: https://rust-analyzer.github.io/book/rust_analyzer_binary.html

Adds the rust-analyzer component to your rustup installation.

```bash
rustup component add rust-analyzer
```

--------------------------------

### Configure workspace discovery

Source: https://rust-analyzer.github.io/book/configuration.html

Example configuration for the rust-analyzer.workspace.discoverConfig setting.

```json
"rust-analyzer.workspace.discoverConfig": {
    "command": [
        "rust-project",
        "develop-json",
        "{arg}"
    ],
    "progressLabel": "buck2/rust-project",
    "filesToWatch": [
        "BUCK"
    ]
}
```

--------------------------------

### Install rust-analyzer from Source

Source: https://rust-analyzer.github.io/book/rust_analyzer_binary.html

Installs rust-analyzer from source using cargo xtask. Requires the latest stable Rust toolchain.

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

--------------------------------

### Matching Brace Example

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

Example Rust code demonstrating a cursor position for matching brace logic.

```rust
fn main() {
    let x: Vec<()>/*cursor here*/ = vec![];
}
```

--------------------------------

### Install rust-analyzer Language Server Locally

Source: https://rust-analyzer.github.io/book/contributing/setup.html

Installs the rust-analyzer language server, targeting a specific editor and building in release mode with debug info. Use this to set up your local development environment.

```bash
cargo xtask install --server \
    --code-bin code-insiders \
    --dev-rel
```

--------------------------------

### Example Progress Event

Source: https://rust-analyzer.github.io/book/configuration.html

A sample JSONL progress event output.

```json
{"kind":"progress","message":"generating rust-project.json"}
```

--------------------------------

### Install Rust Standard Library Source

Source: https://rust-analyzer.github.io/book/installation.html

Manually install the Rust standard library source code using rustup. This is required for rust-analyzer to understand the Rust source.

```bash
rustup component add rust-src
```

--------------------------------

### Install rust-analyzer on Arch Linux

Source: https://rust-analyzer.github.io/book/rust_analyzer_binary.html

Installs rust-analyzer using pacman on Arch Linux. Choose between the latest tagged source or latest Git version.

```bash
pacman -S rust-analyzer
```

--------------------------------

### Join Lines Transformation Example

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

Shows the input and output states for the experimental/joinLines operation.

```rust
fn main() {
    /*cursor here*/let x = {
        92
    };
}
```

```rust
fn main() {
    let x = 92;
}
```

--------------------------------

### Example Finished Event

Source: https://rust-analyzer.github.io/book/configuration.html

A sample JSONL finished event output.

```json
{
    // the internally-tagged representation of the enum.
    "kind": "finished",
    // the file used by a non-Cargo build system to define
    // a package or target.
    "buildfile": "rust-analyzer/BUCK",
    // the contents of a rust-project.json, elided for brevity
    "project": {
        "sysroot": "foo",
        "crates": []
    }
}
```

--------------------------------

### Install vim-lsp

Source: https://rust-analyzer.github.io/book/other_editors.html

Add the vim-lsp plugin to your .vimrc using vim-plug.

```vim
Plug 'prabirshrestha/vim-lsp'
```

--------------------------------

### Invoke rust-project for path discovery

Source: https://rust-analyzer.github.io/book/configuration.html

Example command invocation for path-based workspace generation.

```bash
rust-project develop-json '{ "path": "myproject/src/main.rs" }'
```

--------------------------------

### Install TypeScript Dependencies

Source: https://rust-analyzer.github.io/book/contributing/debugging.html

Run this command in the `editors/code` directory to install all necessary TypeScript dependencies for the VS Code extension.

```bash
cd editors/code
npm ci
```

--------------------------------

### Rebuild and reinstall the server

Source: https://rust-analyzer.github.io/book/print.html

Run these commands after making changes to the source code to update the installed language server.

```bash
cargo check  
cargo xtask install --server --code-bin code-insiders --dev-rel
```

--------------------------------

### Enable proc-macro and build scripts via JSON

Source: https://rust-analyzer.github.io/book/configuration.html

Example JSON object used in initializationOptions to enable proc-macro support and cargo build scripts.

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

--------------------------------

### Comment Handling Example

Source: https://rust-analyzer.github.io/book/print.html

Example of code containing comments that are processed by the TreeSink layer.

```rust
__
// non doc comment
fn foo() {}
```

--------------------------------

### Example Cargo.toml File Structure

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

Shows the target file structure for the openCargoToml experimental request.

```toml
// Cargo.toml
[package]
// src/main.rs

/* cursor here*/
```

--------------------------------

### Auto-import grouping example

Source: https://rust-analyzer.github.io/book/features.html

Demonstrates the structured ordering of imports applied by the auto-import assist.

```rust

__
use std::fs::File;

use itertools::Itertools;
use syntax::ast;

use crate::utils::insert_use;

use self::auto_import;

use super::AssistContext;
```

--------------------------------

### Override check command example

Source: https://rust-analyzer.github.io/book/configuration.html

Example of a command line configuration for overriding the default cargo check behavior.

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

--------------------------------

### Run Linter and Tests in Code Editor

Source: https://rust-analyzer.github.io/book/contributing/index.html

Install npm dependencies and run the linter for changes in the `editors/code` directory.

```bash
cd editors/code
npm ci
npm run lint
```

--------------------------------

### Example Input and Output for onEnter

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

Demonstrates the transformation of code snippets when the onEnter request is triggered.

```rust
fn main() {
    // Some /*cursor here*/ docs
    let x = 92;
}
```

```rust
fn main() {
    // Some
    // $0 docs
    let x = 92;
}
```

--------------------------------

### Example of grouped code actions

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

Demonstrates a scenario where multiple import options are grouped under a single entry.

```rust
fn main() {
    let x: Entry/*cursor here*/ = todo!();
}
```

--------------------------------

### Example input for SyntaxNode

Source: https://rust-analyzer.github.io/book/print.html

A sample Rust code snippet used to demonstrate how GreenNodes represent identical expressions.

```rust
fn main() {
    let x = 90i8;
    let x = x + 2;
    let x = 90i64;
    let x = x + 2;
}
```

--------------------------------

### Invoke rust-project for build file update

Source: https://rust-analyzer.github.io/book/configuration.html

Example command invocation for updating an existing workspace using a build file.

```bash
rust-project develop-json '{ "buildfile": "myproject/BUCK" }'
```

--------------------------------

### Run tests and linting for VS Code extension

Source: https://rust-analyzer.github.io/book/print.html

Commands to install dependencies and execute the linter for the rust-analyzer VS Code extension.

```bash
cd editors/code
npm ci
npm run lint
```

--------------------------------

### Initialize server debug wait loop

Source: https://rust-analyzer.github.io/book/print.html

Code snippet to insert for pausing execution at the start of the server process.

```rust
let mut d = 4;
while d == 4 { // set a breakpoint here and change the value
    d = 4;
}
```

--------------------------------

### Hierarchical Profiler Output Example

Source: https://rust-analyzer.github.io/book/contributing/architecture.html

An example of the output generated by the hierarchical profiler (`hprof`), enabled via the `RA_PROFILE` environment variable. It shows time spent in various functions, aiding in performance analysis.

```text
85ms - handle_completion
    68ms - import_on_the_fly
        67ms - import_assets::search_for_relative_paths
             0ms - crate_def_map:wait (804 calls)
             0ms - find_path (16 calls)
             2ms - find_similar_imports (1 calls)
             0ms - generic_params_query (334 calls)
            59ms - trait_solve_query (186 calls)
         0ms - Semantics::analyze_impl (1 calls)
         1ms - render_resolution (8 calls)
     0ms - Semantics::analyze_impl (5 calls)
```

--------------------------------

### Check rust-analyzer Version

Source: https://rust-analyzer.github.io/book/troubleshooting.html

Verify the installed version of rust-analyzer. Update if the version is older than a week.

```bash
rust-analyzer --version
```

--------------------------------

### VS Code Settings for rust-analyzer Path

Source: https://rust-analyzer.github.io/book/contributing/index.html

Configure VS Code to use the rust-analyzer binary from your PATH. This is necessary when running the 'Run Installed Extension' launch configuration.

```json
{
    "rust-analyzer.server.path": "rust-analyzer"
}
```

--------------------------------

### Example expression for hover range

Source: https://rust-analyzer.github.io/book/contributing/lsp-extensions.html

A sample Rust expression used to demonstrate triggering a hover on a selection.

```rust
fn main() {
    let expression = $01 + 2 * 3$0;
}
```

--------------------------------

### Implement a concrete AST node

Source: https://rust-analyzer.github.io/book/print.html

Example of a concrete node implementation, showing the struct definition, AstNode trait implementation, and accessor methods.

```rust
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FnDef {
    syntax: SyntaxNode,
}

impl AstNode for FnDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match kind {
            FN => Some(FnDef { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

impl FnDef {
    pub fn param_list(&self) -> Option<ParamList> {
        self.syntax.children().find_map(ParamList::cast)
    }
    pub fn ret_type(&self) -> Option<RetType> {
        self.syntax.children().find_map(RetType::cast)
    }
    pub fn body(&self) -> Option<BlockExpr> {
        self.syntax.children().find_map(BlockExpr::cast)
    }
    // ...
}
```

--------------------------------

### Defining a test runnable in rust-project.json

Source: https://rust-analyzer.github.io/book/non_cargo_based_projects.html

Example configuration for a test runnable within the runnables array of the ProjectJson interface.

```json
{
    "program": "buck",
    "args": [
        "test",
         "{label}",
         "--",
         "{test_id}",
         "--print-passing-details"
    ],
    "cwd": "/home/user/repo-root/",
    "kind": "testOne"
}
```

--------------------------------

### Define Multi-Crate Test Fixture

Source: https://rust-analyzer.github.io/book/print.html

Example of a test fixture defining two crates, 'foo' and 'main', with cross-crate dependencies and module structure.

```rust
//- minicore: sized, fn
// /lib.rs crate:foo
pub mod bar;
// /bar.rs
pub struct Bar;
// /main.rs crate:main deps:foo
use foo::Bar;
```

--------------------------------

### Example Parsed Syntax Tree

Source: https://rust-analyzer.github.io/book/contributing/syntax.html

Illustrates the hierarchical structure of a parsed code snippet 'fn f() { 90 + 2 }' as a syntax tree.

```text
FN@0..17
  FN_KW@0..2 "fn"
  WHITESPACE@2..3 " "
  NAME@3..4
    IDENT@3..4 "f"
  PARAM_LIST@4..6
    L_PAREN@4..5 "("
    R_PAREN@5..6 ")"
  WHITESPACE@6..7 " "
  BLOCK_EXPR@7..17
    L_CURLY@7..8 "{"
    WHITESPACE@8..9 " "
    BIN_EXPR@9..15
      LITERAL@9..11
        INT_NUMBER@9..11 "90"
      WHITESPACE@11..12 " "
      PLUS@12..13 "+"
      WHITESPACE@13..14 " "
      LITERAL@14..15
        INT_NUMBER@14..15 "2"
    WHITESPACE@15..16 " "
    R_CURLY@16..17 "}
```

--------------------------------

### Set Up Project Directories for Release

Source: https://rust-analyzer.github.io/book/contributing/index.html

Ensure rust-analyzer, rust-analyzer.github.io, and rust-lang/rust repositories are checked out in the same directory for the release process.

```shell
./rust-analyzer
./rust-analyzer.github.io
./rust-rust-analyzer  # Note the name!
```

--------------------------------

### Example Rust Code with Shadowing

Source: https://rust-analyzer.github.io/book/contributing/syntax.html

Demonstrates variable shadowing in Rust, where a new variable with the same name redefines the previous one.

```rust
fn main() {
    let x = 90i8;
    let x = x + 2;
    let x = 90i64;
    let x = x + 2;
}
```

--------------------------------

### Pull Request Title Formatting

Source: https://rust-analyzer.github.io/book/print.html

Examples of preferred and discouraged pull request title styles for better changelog generation.

```text
# GOOD
Make goto definition work inside macros

# BAD
Use original span for FileId
```

--------------------------------

### Analyze Performance with analysis-stats

Source: https://rust-analyzer.github.io/book/contributing/index.html

Measure time for from-scratch analysis by running the analysis-stats command with a specific path.

```shell
cargo run --release -p rust-analyzer -- analysis-stats ../chalk/
```

--------------------------------

### VS Code Insiders User Settings for Local Server

Source: https://rust-analyzer.github.io/book/contributing/setup.html

Configures Visual Studio Code Insiders to use a locally installed rust-analyzer binary. Ensure the `rust-analyzer.server.path` is set to the correct path provided after installation.

```json
{
    "rust-analyzer.server.path": "<path-to-rust-analyzer-binary>"
}
```

--------------------------------

### Check Project and Reinstall Server

Source: https://rust-analyzer.github.io/book/contributing/setup.html

Runs a project check and then reinstalls the rust-analyzer server after adding debugging statements. This ensures the changes are reflected and the server is ready for testing.

```bash
cargo check

cargo xtask install --server --code-bin code-insiders --dev-rel
```

--------------------------------

### Configure nvim-lspconfig for Neovim 0.11+

Source: https://rust-analyzer.github.io/book/other_editors.html

Use the built-in LSP support with nvim-lspconfig to configure rust-analyzer settings and features like inlay hints.

```lua
lua << EOF
-- You can pass LSP settings to the server:
vim.lsp.config("rust_analyzer", {
    settings = {
        ["rust-analyzer"] = {
            imports = {
                granularity = {
                    group = "module",
                },
                prefix = "self",
            },
            cargo = {
                buildScripts = {
                    enable = true,
                },
            },
            procMacro = {
                enable = true
            },
        },
    },
})

-- You can enable different LSP features
vim.api.nvim_create_autocmd("LspAttach", {
    callback = function(ev)
        local client = assert(vim.lsp.get_client_by_id(ev.data.client_id))
        -- Inlay hints display inferred types, etc.
        if client:supports_method("inlayHint/resolve") then
            vim.lsp.inlay_hint.enable(true, { bufnr = ev.buf })
        end
        -- Completion can be invoked via ctrl+x ctrl+o. It displays a list of
        -- names inferred from the context (e.g. method names, variables, etc.)
        if client:supports_method("textDocument/completion") then
            vim.lsp.completion.enable(true, client.id, ev.buf, {})
        end
    end,
})
EOF
```

--------------------------------

### Configure server path in settings.json

Source: https://rust-analyzer.github.io/book/print.html

Specify a custom path for the rust-analyzer server binary when using the no-server VSIX.

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

--------------------------------

### Configure rust-analyzer Server Path

Source: https://rust-analyzer.github.io/book/vs_code.html

Manually set the path to the rust-analyzer server binary in VS Code's settings.json for unsupported platforms.

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

--------------------------------

### Trigger Structural Search Replace Assist

Source: https://rust-analyzer.github.io/book/features.html

Example of using a comment to trigger the structural search replace assist.

```rust
// Place the cursor on the line below to see the assist 💡.
// foo($a, $b) ==>> ($a).foo($b)
```

--------------------------------

### Perform Structural Search Replace

Source: https://rust-analyzer.github.io/book/features.html

Example of transforming code using the structural search replace command syntax.

```rust
// Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]

// BEFORE
String::from(foo(y + 5, z))

// AFTER
String::from((y + 5).foo(z))
```

--------------------------------

### Run Tests

Source: https://rust-analyzer.github.io/book/contributing/index.html

Build and test the rust-analyzer project using Cargo. This is the primary command for verifying your changes.

```bash
cargo test

```

--------------------------------

### Run Analysis Statistics

Source: https://rust-analyzer.github.io/book/print.html

Execute analysis-stats to measure performance from scratch.

```bash
cargo run --release -p rust-analyzer -- analysis-stats ../chalk/
```

--------------------------------

### Configure Eglot for Clippy

Source: https://rust-analyzer.github.io/book/other_editors.html

Set initialization options to use clippy as the check command for rust-analyzer.

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

--------------------------------

### Build with debug assertions

Source: https://rust-analyzer.github.io/book/print.html

Command to build the release binary with debug assertions enabled.

```bash
RUSTFLAGS='--cfg debug_assertions' cargo build --release
```

--------------------------------

### Create a bug reproduction

Source: https://rust-analyzer.github.io/book/print.html

A template for cloning a repository and running diagnostic commands to isolate issues for bug reports.

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

--------------------------------

### Delete Type Bounds in Mutable Tree

Source: https://rust-analyzer.github.io/book/print.html

Example of an edit operation on a mutable syntax tree, specifically removing type bounds.

```rust
 for typeBound in typeBounds {
     typeBound.typeParamBounds?.delete()
}
```

--------------------------------

### Configure LanguageClient-neovim for rust-analyzer

Source: https://rust-analyzer.github.io/book/other_editors.html

Add this configuration to your Vim or Neovim config file to register the rust-analyzer server.

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

--------------------------------

### Debug Server Initialization with --wait-dbg

Source: https://rust-analyzer.github.io/book/contributing/debugging.html

To debug the server from its initialization, use the `--wait-dbg` command line argument or the `RA_WAIT_DBG` environment variable. This causes the server to pause at the beginning of the `try_main` function.

```rust
let mut d = 4;
while d == 4 { // set a breakpoint here and change the value
    d = 4;
}
```

--------------------------------

### Register rust-analyzer with vim-lsp

Source: https://rust-analyzer.github.io/book/other_editors.html

Register the rust-analyzer binary with vim-lsp in your .vimrc.

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

--------------------------------

### Register rust-analyzer with initialization options in vim-lsp

Source: https://rust-analyzer.github.io/book/other_editors.html

Register rust-analyzer with custom initialization options, such as enabling proc-macro support.

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

--------------------------------

### GreenNodeBuilder for Syntax Tree Construction

Source: https://rust-analyzer.github.io/book/contributing/syntax.html

Used to construct the green tree via a DFS traversal. It provides methods to add tokens, start and finish nodes.

```rust
pub struct GreenNodeBuilder { ... }

impl GreenNodeBuilder {
    pub fn new() -> GreenNodeBuilder { ... }

    pub fn token(&mut self, kind: SyntaxKind, text: &str) { ... }

    pub fn start_node(&mut self, kind: SyntaxKind) { ... }
    pub fn finish_node(&mut self) { ... }

    pub fn finish(self) -> GreenNode { ... }
}
```

--------------------------------

### Configure additional rustfmt arguments

Source: https://rust-analyzer.github.io/book/configuration.html

Provides extra command line arguments to the rustfmt tool.

```json
[]
```

--------------------------------

### Rust Code for Deleting Type Bounds

Source: https://rust-analyzer.github.io/book/contributing/syntax.html

Demonstrates how to iterate through type bounds and delete associated type parameter bounds. This snippet is part of an example for editing syntax trees.

```rust
for typeBound in typeBounds {
    typeBound.typeParamBounds?.delete()
}
```

--------------------------------

### Enable format on type

Source: https://rust-analyzer.github.io/book/features.html

Enable automatic formatting when typing specific characters by updating settings.json.

```json
"editor.formatOnType": true,
```

--------------------------------

### Configure Keybindings for Rust Projects Only

Source: https://rust-analyzer.github.io/book/editor_features.html

Use the 'inRustProject' context to apply keybindings exclusively to Rust projects.

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

--------------------------------

### Format Inline Code Comments as Sentences

Source: https://rust-analyzer.github.io/book/contributing/style.html

Write inline code comments as complete sentences, starting with a capital letter and ending with a period. This encourages writing more contextual information.

```Rust
// GOOD

// Only simple single segment paths are allowed.
MergeBehavior::Last => {
    tree.use_tree_list().is_none() && tree.path().map(path_len) <= Some(1)
}

// BAD

// only simple single segment paths are allowed
MergeBehavior::Last => {
    tree.use_tree_list().is_none() && tree.path().map(path_len) <= Some(1)
}
```

--------------------------------

### Enable procedural macros

Source: https://rust-analyzer.github.io/book/configuration.html

Sets whether to enable support for procedural macros, which implies enabling cargo build scripts.

```json
true
```

--------------------------------

### Avoid Excessive Type Parametricity

Source: https://rust-analyzer.github.io/book/contributing/style.html

Limit type parametricity, especially at crate boundaries, to manage compile times. This example shows using a concrete type with a trait object for implementation.

```Rust
// GOOD
fn frobnicate(mut f: impl FnMut()) {
    frobnicate_impl(&mut f)
}
fn frobnicate_impl(f: &mut dyn FnMut()) {
    // lots of code
}

// BAD
fn frobnicate(mut f: impl FnMut()) {
    // lots of code
}
```

--------------------------------

### Configure Kakoune for rust-analyzer

Source: https://rust-analyzer.github.io/book/other_editors.html

Enables LSP, auto-formatting on save, and inlay hints for Rust files in Kakoune using kak-lsp.

```kakoune
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
    }
}
```

--------------------------------

### HasVisibility Trait Implementation for FnDef

Source: https://rust-analyzer.github.io/book/contributing/syntax.html

Shows how shared AST substructures are modeled using traits. This example implements the HasVisibility trait for FnDef, providing a method to access the visibility of a function definition.

```rust
trait HasVisibility: AstNode {
    fn visibility(&self) -> Option<Visibility>;
}

impl HasVisibility for FnDef {
    fn visibility(&self) -> Option<Visibility> {
        self.syntax.children().find_map(Visibility::cast)
    }
}
```

--------------------------------

### FnDef Struct and AstNode Implementation

Source: https://rust-analyzer.github.io/book/contributing/syntax.html

Example of a concrete AST node for a function definition (FnDef). It includes a cast implementation based on node kind and methods to access child nodes like parameter list, return type, and body.

```rust
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FnDef {
    syntax: SyntaxNode,
}

impl AstNode for FnDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        match kind {
            FN => Some(FnDef { syntax }),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

impl FnDef {
    pub fn param_list(&self) -> Option<ParamList> {
        self.syntax.children().find_map(ParamList::cast)
    }
    pub fn ret_type(&self) -> Option<RetType> {
        self.syntax.children().find_map(RetType::cast)
    }
    pub fn body(&self) -> Option<BlockExpr> {
        self.syntax.children().find_map(BlockExpr::cast)
    }
    // ...
```
Tokens:
Raw