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
setuprust-analyzer is a Language Server Protocol (LSP) 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.
The rust-project.json
file format is currently unstable. Sometimes this can cause an unexpected version mismatch where GN produces a rust-project.json
that rust-analyzer
is not expecting, causing rust-analyzer
to not work correctly.
Currently, use the latest version of rust-analyzer
.
To setup rust-analyzer
on VS Code, see the VS Code guide Installing extensions.
Install rust-lang/rust.vim
, which also integrates with:
Tagbar: universal-ctags is strongly recommended, but other ctags implementations are also supported.
Syntastic: rust.vim
automatically registers cargo
as a syntax checker for Rust. Yet it will fail unless you set up cargo. If you want to disable the integration (or use rust-analyzer
to check the code, e.g. via YouCompleteMe), add the following to your ~/.vimrc
:
let g:syntastic_rust_checkers = []
Auto formatting: to run rustfmt
on save (disabled by default), add the following to ~./vimrc
:
let g:rustfmt_command = '{{ "<var>" }}FUCHSIA_DIR{{ "</var>" }}/prebuilt/third_party/rust/{{ "<var>" }}HOST_OS{{ "</var>" }}/bin/rustfmt' let g:rustfmt_autosave = 1
For IDE support, see the vim section of the rust-analyzer manual. For YouCompleteMe, add --rust-completer
(or --all
) if you are installing from source, and it should work out of the box. You can also specify the path to a standalone rust-analyzer
in your ~/.vimrc
(this is not guaranteed to work due to version compatibility); here is an example assuming it is installed to ~/.local/bin/rust-analyzer
(note the intentional absence of /bin
in the path):
let g:ycm_rust_toolchain_root = $HOME . '/.local'
See the rust-analyzer manual for instructions.
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.
Note that this workflow is based on cargo, which is more likely to break than rust-analyzer based workflows.
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. If you haven’t already, install rustup. Then, from your Fuchsia root, type:
rustup toolchain link fuchsia {{ '<var>' }}FUCHSIA_DIR{{ '</var>' }}/prebuilt/third_party/rust/{{ '<var>' }}HOST_OS{{ '</var>' }} rustup default fuchsia
Finally, follow the steps 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 instructions to generate Cargo.toml
and .cargo/config
, 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, follow the rust-analyzer setup instructions for Sublime.
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.
See instructions on the Intellij Rust site. Finally, follow these steps to generate a Cargo.toml
file for use by Intellij. Note that cargo-based workflows are more likely to break than rust-analyzer based ones.