As there is no specific editor for Rust development on Fuchsia, vim
and VS Code
are the most popular options. However, documentation for setting up any editor is welcome in this document.
rust-analyzer is a Language Server Protocol implementation for Rust. This is the recommended workflow and will work with minimal editor setup.
rust-analyzer
uses a file in the out/
directory called rust-project.json
that is generated based on the build graph at gn gen
time. A symlink to the rust-project.json
is located in the root directory of the Fuchsia tree.
Cargo.toml
filesThis is a volunteer-maintained workflow that exists because many tools in the Rust ecosystem assume cargo integration. GN and Cargo have some design mismatches that may result in manual tweaks being needed for the generated Cargo.toml
s.
Cargo.toml
files for use by editorsIn order to generate the cargo files based on the build graph of GN, add --cargo-toml-gen
to the fx set
and fx args
commands. This adds a few seconds at gn gen
time. For example:
fx set --cargo-toml-gen <normal fx args>
Most editors require the Cargo.toml
file to be in a location that is adjacent to the src/
directory. Symlinks to these files can be generated using the following commands, where //garnet/foo/path/to/target:label
is the GN target that you want to work on:
fx gen-cargo garnet/foo/path/to/target:some_label
Note that this label must point to a rustc_...
GN template (not a Fuchsia package or other GN target). For example:
rustc_binary("some_label") { ... }
Some plugins require a .cargo/config
file to allow cargo to operate correctly for Fuchsia (e.g. to run cargo check
). To easily generate this file, use the fargo
tool.
Configure rustup
to use the Fuchsia Rust toolchain by running:
rustup toolchain link fuchsia $($FUCHSIA_DIR/scripts/youcompleteme/paths.py VSCODE_RUST_TOOLCHAIN) rustup default fuchsia
Clone and install the fargo
tool within your $FUCHSIA_DIR
by following the getting started instructions for fargo.
Create your config:
cd $FUCHSIA_DIR && fargo write-config # Note the caveats about changing architecture in the fargo readme # https://fuchsia.googlesource.com/fargo/#creating-a-cargo_config
See instructions on the Intellij Rust site. Finally, follow the steps above to generate a Cargo.toml
file for use by Intellij.
See instructions on rust-lang/rust.vim
.
If you use Tagbar, see this post for instructions on making it work better with Rust.
To install the rust-analyzer plugin for VSCode, see VS Code.
Once you have installed the rust-analyzer plugin, add the following configurations to your settings.json
file:
Note: To access the VS Code settings, click the Code menu, then Preferences, then Settings. Scroll and click on Edit in settings.json.
{ // disable cargo-watch "rust-analyzer.cargo-watch.enable": false, // disable cargo check on save "rust-analyzer.cargo-watch.allTargets": false, }
install rustup. Next, install this VS Code plugin. You need to configure rustup
to use the Fuchsia Rust toolchain. Run this command from your Fuchsia source code root directory.
rustup toolchain link fuchsia $(scripts/youcompleteme/paths.py VSCODE_RUST_TOOLCHAIN) rustup default fuchsia
Follow the steps above to generate a Cargo.toml
file for use by VS Code.
Open VS Code and ensure that the directory where the generated Cargo.toml
file resides is added as a directory in your workspace (even though you probably have its ancestor fuchsia
directory already in your workspace). For example:
you@computer:/path/to/fuchsia $ fx build src/rusty/component:bin you@computer:/path/to/fuchsia $ fx gen-cargo src/rusty/component:bin
In a new VS Code workspace, in this example, add both /path/to/fuchsia
and /path/to/fuchsia/src/rusty/component
to the workspace. Saving the workspace would yield something like:
fuchsia_rusty_component.code-workspace
{ "folders": [ { "path": "/path/to/fuchsia" }, { "path": "/path/to/fuchsia/src/rusty/component" } ] }
Next, take note of the paths output by the following:
you@computer:/path/to/fuchsia $ ./scripts/youcompleteme/paths.py FUCHSIA_ROOT you@computer:/path/to/fuchsia $ ./scripts/youcompleteme/paths.py VSCODE_RUST_TOOLCHAIN
Open VS Code settings
Note there are different settings defined for each environment (for example, user vs remote development server). In the upper right corner, click an icon whose mouse-over balloon tip says “Open Settings (JSON)”. Add the following settings:
{ // General rust and RLS configuration. "rust.target": "x86_64-fuchsia", "rust.target_dir": "<FUCHSIA_ROOT>/out/cargo_target", "rust.unstable_features": true, "rust-client.rlsPath": "<VS_CODE_TOOLCHAIN>/bin/rls", "rust-client.disableRustup": true, "rust.mode": "rls", // Read `Cargo.toml` from innermost root workspace directory. "rust-client.nestedMultiRootConfigInOutermost": false, // Optional extras: // Log RLS info/warning/error messages to a VSCode Output Panel. "rust-client.revealOutputChannelOn": "info", // Create `rls[numeric-id].log` in your project directory. Errors from RLS // will be logged there. "rust-client.logToFile": true, }
You will be using flycheck to compile your Rust files when you save them. flycheck will parse those outputs and highlight errors. You'll also use flycheck-rust so that it will compile with cargo and not with rustc. Both are available from melpa.
If you don't yet have melpa, follow the instructions here.
Install flycheck
and flycheck-rust
in M-x list-packages
. Type i
to queue for installation what you are missing and then x
to execute.
Next, make sure that flycheck-rust is run at startup. Put this in your .emacs
files:
(with-eval-after-load 'rust-mode (add-hook 'flycheck-mode-hook #'flycheck-rust-setup))
You'll want cargo to run “check” and not “test” so set flycheck-rust-check-tests
to nil
. You can do this by typing C-h v flycheck-rust-check-tests<RET>
and then customizing the variable in the normal way.
Now, you'll want to make sure that the default cargo
and rustc
that you are using are Fuchsia versions of those. From your fuchsia root, type:
rustup toolchain link fuchsia $PWD/prebuilt/third_party/rust/linux-x64 && rustup default fuchsia
Finally, follow the steps at the top of this page to generate a Cargo.toml
for the GN target that you want to work on.
You can read about adjusting flycheck to display your errors as you like. Type C-h v flycheck-highlighting-mode<RET>
and customize it. Also customize C-h v flycheck-indiation-mode<RET>
.
Now restart emacs and try it out.
To test that it works, you can run M-x flycheck-compile
and see the command-line that flycheck is using to check syntax. It ought to look like one of these depending on whether you are in a lib or bin:
cargo check --lib --message-format\=json cargo check --bin recovery_netstack --message-format\=json
If it runs rustc
instead of cargo
, that‘s because you didn’t fx gen-cargo
.
Note that it might report errors on the first line of the current file. Those are actually errors from a different file. The error's comment will name the problematic file.
Follow the steps above to generate a Cargo.toml
file and also the steps to generate a cargo/config
file, which will also setup cargo
to use the Fuchsia Rust toolchain.
Then, install the Rust Enhanced plugin. Now, you should have syntax checking on save and be able to run cargo check
from the context menu / command palette. Thanks to fargo
, some tests also appear to run OK, but this hasn't been thoroughly tested.
First, install the LSP package for Sublime. Then, you have two choices for the language server, pick one:
rls
in the LSP: Enable Language Server
options from the Sublime command palette.In order for the language server to work, you need to open a folder that contains a Cargo.toml
as the root of your Sublime project. There are two ways you can do this:
Cargo.toml
(e.g. garnet/foo/path/to/target
)fuchsia
folder also open.You may need to restart Sublime after these steps.