Rust in Visual Studio Code

Rust is a powerful programming language, often used for systems programming where performance and correctness are high priorities. If you are new to Rust and want to learn more,The Rust Programming Language online book is a great place to start. This topic goes into detail about setting up and using Rust within Visual Studio Code, with therust-analyzer extension.

Installation

1. Install Rust

First you will need to have the Rust toolset installed on your machine. Rust is installed via therustup installer, which supports installation on Windows, macOS, and Linux. Follow the rustup installation guidance for your platform, taking care to install any extra tools required to build and run Rust programs.

2. Install the rust-analyzer extension

You can find and install the rust-analyzer extension from within VS Code via the Extensions view (⇧⌘X (Windows, LinuxCtrl+Shift+X)) and searching for 'rust-analyzer'. You should install theRelease Version.

We'll discuss many of rust-analyzer features in this topic but you can also refer to the extension's documentation athttps://rust-analyzer.github.io.

Check your installation

After installing Rust, you can check that everything is installed correctly by opening a new terminal/Command Prompt, and typing:

rustc --version

which will output the version of the Rust compiler. If you want more details, you can add the--verbose argument. If you run into problems, you can consult the Rustinstallation guide.

You can keep your Rust installation up to date with the latest version by running:

rustup update

There are new stable versions of Rust published every 6 weeks so this is a good habit.

Local Rust documentation

When you install Rust, you also get the full Rust documentation set locally installed on your machine, which you can review by typingrustup doc. The Rust documentation, includingThe Rust Programming Language andThe Cargo Book, will open in your local browser so you can continue your Rust journey while offline.

Hello World

Cargo

When you install Rust with rustup, the toolset includes the rustc compiler, the rustfmt source code formatter, and the clippy Rust linter. You also getCargo, the Rust package manager, to help download Rust dependencies and build and run Rust programs. You'll find that you end up usingcargo for just about everything when working with Rust.

Cargo new

A good way to create your first Rust program is to use Cargo to scaffold a new project by typingcargo new. This will create a simple Hello World program along with a defaultCargo.toml dependency file. You passcargo new the folder where you'd like to create the project.

Let's create Hello World. Navigate to a folder where you'd like to create your project and type:

cargo new hello_world

To open your new project in VS Code, navigate into the new folder and launch VS Code viacode .:

cd hello_worldcode .

cargo new creates a simple Hello World project with amain.rs source code file andCargo.tomlCargo manifest file.

src\    main.rs.gitignoreCargo.toml

main.rs has the program's entry functionmain() and prints "Hello, world!" to the console usingprintln!.

fn main() {    println!("Hello, world!");}

This simple Hello World program doesn't have any dependencies but you would add Rust package (crate) references under[dependencies].

Cargo build

Cargo can be used to build your Rust project. Open a new VS Codeintegrated terminal (⌃⇧` (Windows, LinuxCtrl+Shift+`)) and typecargo build.

cargo build

You will now havetarget\debug folder with build output include an executable calledhello_world.exe.

Running Hello World

Cargo can also be used to run your Rust project viacargo run.

cargo run

You can also runhello_world.exe manually in the terminal by typing.\target\debug\hello_world.

IntelliSense

IntelliSense features are provided by the Rust language server,rust-analyzer, which provides detailed code information and smart suggestions.

When you first open a Rust project, you can watch rust-analyzer's progress in the lower left of the Status bar. You want to wait until rust-analyzer has completely reviewed your project to get the full power of the language server.

Inlay hints

One of the first things you may notice is rust-analyzer providinginlay hints to show inferred types, return values, named parameters in light text in the editor.

While inlay hints can be helpful for understanding your code, you can also configure the feature via theEditor > Inlay Hints: Enabled setting (editor.inlayHints.enabled).

Hover information

Hovering on any variable, function, type, or keyword will give you information on that item such as documentation, signature, etc. You can also jump to the type definition in your own code or the standard Rust libraries.

Auto completions

As you type in a Rust file, IntelliSense provides you with suggested completions and parameter hints.

Semantic syntax highlighting

rust-analyzer is able to usesemantic syntax highlighting and styling due to its rich understanding of a project source code. For example, you may have noticed that mutable variables are underlined in the editor.

Being able to quickly tell which Rust variables are mutable or not can help your understanding of source code, but you can also change the styling with VS Codeeditor.semanticTokenColorCustomizations setting in your usersettings.

Insettings.json, you would add:

{  "editor.semanticTokenColorCustomizations": {    "rules": {      "*.mutable": {        "fontStyle":"",// set to empty string to disable underline, which is the default      },    }  },}

You can learn more about rust-analyzer's semantic syntax customizations in theEditor features section of the rust-analyzer documentation.

Code navigation

Code navigation features are available in the context menu in the editor.

• Go to DefinitionF12 - Go to the source code of the type definition.
• Peek Definition⌥F12 (WindowsAlt+F12, LinuxCtrl+Shift+F10) - Bring up a Peek window with the type definition.
• Go to References⇧F12 (Windows, LinuxShift+F12) - Show all references for the type.
• Show Call Hierarchy⇧⌥H (Windows, LinuxShift+Alt+H) - Show all calls from or to a function.

You can navigate via symbol search using theGo to Symbol commands from theCommand Palette (⇧⌘P (Windows, LinuxCtrl+Shift+P)).

• Go to Symbol in File -⇧⌘O (Windows, LinuxCtrl+Shift+O)
• Go to Symbol in Workspace -⌘T (Windows, LinuxCtrl+T)

Linting

The Rust toolset includes linting, provided by rustc and clippy, to detect issues with your source code.

The rustc linter, enabled by default, detects basic Rust errors, but you can useclippy to get more lints. To enable clippy integration in rust-analyzer, change theRust-analyzer > Check: Command (rust-analyzer.check.command) setting toclippy instead of the defaultcheck. The rust-analyzer extension will now runcargo clippy when you save a file and display clippy warnings and errors directly in the editor and Problems view.

Quick Fixes

When the linter finds errors and warnings in your source code, rust-analyzer can often provide suggested Quick Fixes (also called Code Actions), which are available via a light bulb hover in the editor. You can quickly open available Quick Fixes via the⌘. (Windows, LinuxCtrl+.).

Additionally,Code Action Widget: Include Nearby Quick Fixes (editor.codeActionWidget.includeNearbyQuickFixes) is a setting that is enabled on default, which will activate the nearest Quick Fix in a line from⌘. (Windows, LinuxCtrl+.) (command IDeditor.action.quickFix), no matter where your cursor is in that line.

The command highlights the source code that will be refactored or fixed with Quick Fixes. Normal Code Actions and non-fix refactorings can still be activated at the cursor location.

Refactoring

Due to rust-analyzer's semantic understanding of your source code, it can also provide smart renames, across your Rust files. With your cursor on a variable, selectRename Symbol from the context menu, Command Palette, or viaF2.

The rust-analyzer extension also supports other code refactorings and code generation, which the extension callsAssists.

Here are just a few of the refactorings available:

• Convert if statement to guarded return
• Inline variable
• Extract function
• Add return type
• Add import

Formatting

The Rust toolset includes a formatter,rustfmt, which can format your source code to conform to Rust conventions. You can format your Rust file using⇧⌥F (WindowsShift+Alt+F, LinuxCtrl+Shift+I) or by running theFormat Document command from theCommand Palette or the context menu in the editor.

You also have the option to run the formatter on each save (Editor: Format On Save) or paste (Format On Paste) to keep your Rust code properly formatted automatically while you are working.

Debugging

The rust-analyzer extension supports debugging Rust from within VS Code.

Install debugging support

To start debugging, you will first need to install one of two language extension with debugging support:

• Microsoft C++ (ms-vscode.cpptools) –on Windows
• CodeLLDB (vadimcn.vscode-lldb) –on macOS/Linux

If you forget to install one of these extensions, rust-analyzer will provide a notification with links to the VS Code Marketplace when you try to start a debug session.

Using Rust Analyzer: Debug

The rust-analyzer extension has basic debugging support via theRust Analyzer: Debug command available in the Command Palette (⇧⌘P (Windows, LinuxCtrl+Shift+P)) and theRun|Debug CodeLens in the editor.

Let's debug the Hello World program, we created earlier. First we will set a breakpoint inmain.rs.

1. You'll need to enable the settingDebug: Allow Breakpoints Everywhere, which you can find in the Settings editor (⌘, (Windows, LinuxCtrl+,)) by searching on 'everywhere`.

   

2. Openmain.rs and click the left gutter in the editor to set a break point on theprintln! line. It should display as a red dot.

   

3. To start debugging, use either theRust Analyzer: Debug command or select theDebug CodeLens aboutmain().

   

Next steps

This has been a brief overview showing the rust-analyzer extension features within VS Code. For more information, see the details provided in the Rust Analyzer extensionUser Manual, including how to tune specificVS Code editor configurations.

To stay up to date on the latest features/bug fixes for the rust-analyzer extension, see theCHANGELOG. You can also try out new features and fixes by installing the rust-analyzerPre-Release Version available in the Extensions viewInstall dropdown.

If you have any issues or feature requests, feel free to log them in the rust-analyzer extensionGitHub repo.

If you'd like to learn more about VS Code, try these topics:

• Basic Editing - A quick introduction to the basics of the VS Code editor.
• Install an Extension - Learn about other extensions are available in theMarketplace.
• Code Navigation - Move quickly through your source code.

Common questions

Linker errors

If you see linker errors such as"error: linkerlink.exe not found" when you try to build your Rust program, you may be missing the necessary C/C++ toolset. Depending on your platform, you will need to install a toolset with a C/C++ linker to combine the Rust compiler output.

Windows

On Windows, you will need to also installMicrosoft C++ Build Tools in order to get the C/C++ linkerlink.exe. Be sure to select theDesktop Development with C++ when running the Visual Studio installer.

macOS

You may need to install the XCode toolset by runningxcode-select --install in a terminal.

Linux

You may need to install the GCC toolset via thebuild-essential package by runningsudo apt-get install build-essential in a terminal.

For further troubleshooting advice, refer to theRust installation guide.