docs/dev/README.md

   1 # Contributing Quick Start
   2
   3 Rust Analyzer is an ordinary Rust project, which is organized as a Cargo workspace, builds on stable and doesn't depend on C libraries.
   4 So, just
   5
   6 ```
   7 $ cargo test
   8 ```
   9
  10 should be enough to get you started!
  11
  12 To learn more about how rust-analyzer works, see [./architecture.md](./architecture.md) document.
  13 It also explains the high-level layout of the source code.
  14 Do skim through that document.
  15
  16 We also publish rustdoc docs to pages: https://rust-analyzer.github.io/rust-analyzer/ide/.
  17 Note though, that internal documentation is very incomplete.
  18
  19 Various organizational and process issues are discussed in this document.
  20
  21 # Getting in Touch
  22
  23 Rust Analyzer is a part of [RLS-2.0 working
  24 group](https://github.com/rust-lang/compiler-team/tree/6a769c13656c0a6959ebc09e7b1f7c09b86fb9c0/working-groups/rls-2.0).
  25 Discussion happens in this Zulip stream:
  26
  27 https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Frust-analyzer
  28
  29 # Issue Labels
  30
  31 * [good-first-issue](https://github.com/rust-analyzer/rust-analyzer/labels/good%20first%20issue)
  32   are good issues to get into the project.
  33 * [E-has-instructions](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AE-has-instructions)
  34   issues have links to the code in question and tests.
  35 * [Broken Window](https://github.com/rust-analyzer/rust-analyzer/issues?q=is:issue+is:open+label:%22Broken+Window%22)
  36   are issues which are not critical by themselves, but which should be fixed ASAP regardless, to avoid accumulation of technical debt.
  37 * [E-easy](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy),
  38   [E-medium](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AE-medium),
  39   [E-hard](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AE-hard),
  40   [E-unknown](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AE-unknown),
  41   labels are *estimates* for how hard would be to write a fix. Each triaged issue should have one of these labels.
  42 * [S-actionable](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AS-actionable) and
  43   [S-unactionable](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3AS-unactionable)
  44   specify if there are concrete steps to resolve or advance an issue. Roughly, actionable issues need only work to be fixed,
  45   while unactionable ones are effectively wont-fix. Each triaged issue should have one of these labels.
  46 * [fun](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%3Afun)
  47   is for cool, but probably hard stuff.
  48 * [Design](https://github.com/rust-analyzer/rust-analyzer/issues?q=is%3Aopen+is%3Aissue+label%Design)
  49   is for moderate/large scale architecture discussion.
  50   Also a kind of fun.
  51   These issues should generally include a link to a Zulip discussion thread.
  52
  53 # Code Style & Review Process
  54
  55 Do see [./style.md](./style.md).
  56
  57 # Cookbook
  58
  59 ## CI
  60
  61 We use GitHub Actions for CI.
  62 Most of the things, including formatting, are checked by `cargo test`.
  63 If `cargo test` passes locally, that's a good sign that CI will be green as well.
  64 The only exception is that some long-running tests are skipped locally by default.
  65 Use `env RUN_SLOW_TESTS=1 cargo test` to run the full suite.
  66
  67 We use bors-ng to enforce the [not rocket science](https://graydon2.dreamwidth.org/1597.html) rule.
  68
  69 ## Launching rust-analyzer
  70
  71 Debugging the language server can be tricky.
  72 LSP is rather chatty, so driving it from the command line is not really feasible, driving it via VS Code requires interacting with two processes.
  73
  74 For this reason, the best way to see how rust-analyzer works is to **find a relevant test and execute it**.
  75 VS Code & Emacs include an action for running a single test.
  76
  77 Launching a VS Code instance with a locally built language server is also possible.
  78 There's **"Run Extension (Debug Build)"** launch configuration for this in VS Code.
  79
  80 In general, I use one of the following workflows for fixing bugs and implementing features:
  81
  82 If the problem concerns only internal parts of rust-analyzer (i.e. I don't need to touch the `rust-analyzer` crate or TypeScript code), there is a unit-test for it.
  83 So, I use **Rust Analyzer: Run** action in VS Code to run this single test, and then just do printf-driven development/debugging.
  84 As a sanity check after I'm done, I use `cargo xtask install --server` and **Reload Window** action in VS Code to verify that the thing works as I expect.
  85
  86 If the problem concerns only the VS Code extension, I use **Run Installed Extension** launch configuration from `launch.json`.
  87 Notably, this uses the usual `rust-analyzer` binary from `PATH`.
  88 For this, it is important to have the following in your `settings.json` file:
  89 ```json
  90 {
  91     "rust-analyzer.server.path": "rust-analyzer"
  92 }
  93 ```
  94 After I am done with the fix, I use `cargo xtask install --client` to try the new extension for real.
  95
  96 If I need to fix something in the `rust-analyzer` crate, I feel sad because it's on the boundary between the two processes, and working there is slow.
  97 I usually just `cargo xtask install --server` and poke changes from my live environment.
  98 Note that this uses `--release`, which is usually faster overall, because loading stdlib into debug version of rust-analyzer takes a lot of time.
  99 To speed things up, sometimes I open a temporary hello-world project which has `"rust-analyzer.withSysroot": false` in `.code/settings.json`.
 100 This flag causes rust-analyzer to skip loading the sysroot, which greatly reduces the amount of things rust-analyzer needs to do, and makes printf's more useful.
 101 Note that you should only use the `eprint!` family of macros for debugging: stdout is used for LSP communication, and `print!` would break it.
 102
 103 If I need to fix something simultaneously in the server and in the client, I feel even more sad.
 104 I don't have a specific workflow for this case.
 105
 106 Additionally, I use `cargo run --release -p rust-analyzer -- analysis-stats path/to/some/rust/crate` to run a batch analysis.
 107 This is primarily useful for performance optimizations, or for bug minimization.
 108
 109 ## TypeScript Tests
 110
 111 If you change files under `editors/code` and would like to run the tests and linter, install npm and run:
 112
 113 ```bash
 114 cd editors/code
 115 npm ci
 116 npm run lint
 117 ```
 118 ## How to ...
 119
 120 * ... add an assist? [#7535](https://github.com/rust-analyzer/rust-analyzer/pull/7535)
 121 * ... add a new protocol extension? [#4569](https://github.com/rust-analyzer/rust-analyzer/pull/4569)
 122 * ... add a new configuration option? [#7451](https://github.com/rust-analyzer/rust-analyzer/pull/7451)
 123 * ... add a new completion? [#6964](https://github.com/rust-analyzer/rust-analyzer/pull/6964)
 124 * ... allow new syntax in the parser? [#7338](https://github.com/rust-analyzer/rust-analyzer/pull/7338)
 125
 126 ## Logging
 127
 128 Logging is done by both rust-analyzer and VS Code, so it might be tricky to figure out where logs go.
 129
 130 Inside rust-analyzer, we use the standard `log` crate for logging, and `env_logger` for logging frontend.
 131 By default, log goes to stderr, but the stderr itself is processed by VS Code.
 132 `--log-file <PATH>` CLI argument allows logging to file.
 133
 134 To see stderr in the running VS Code instance, go to the "Output" tab of the panel and select `rust-analyzer`.
 135 This shows `eprintln!` as well.
 136 Note that `stdout` is used for the actual protocol, so `println!` will break things.
 137
 138 To log all communication between the server and the client, there are two choices:
 139
 140 * You can log on the server side, by running something like
 141   ```
 142   env RA_LOG=lsp_server=debug code .
 143   ```
 144 * You can log on the client side, by enabling `"rust-analyzer.trace.server": "verbose"` workspace setting.
 145   These logs are shown in a separate tab in the output and could be used with LSP inspector.
 146   Kudos to [@DJMcNab](https://github.com/DJMcNab) for setting this awesome infra up!
 147
 148
 149 There are also several VS Code commands which might be of interest:
 150
 151 * `Rust Analyzer: Status` shows some memory-usage statistics.
 152
 153 * `Rust Analyzer: Syntax Tree` shows syntax tree of the current file/selection.
 154
 155 * `Rust Analyzer: View Hir` shows the HIR expressions within the function containing the cursor.
 156
 157   You can hover over syntax nodes in the opened text file to see the appropriate
 158   rust code that it refers to and the rust editor will also highlight the proper
 159   text range.
 160
 161   If you trigger Go to Definition in the inspected Rust source file,
 162   the syntax tree read-only editor should scroll to and select the
 163   appropriate syntax node token.
 164
 165   ![demo](https://user-images.githubusercontent.com/36276403/78225773-6636a480-74d3-11ea-9d9f-1c9d42da03b0.png)
 166
 167 ## Profiling
 168
 169 We have a built-in hierarchical profiler, you can enable it by using `RA_PROFILE` env-var:
 170
 171 ```
 172 RA_PROFILE=*             // dump everything
 173 RA_PROFILE=foo|bar|baz   // enabled only selected entries
 174 RA_PROFILE=*@3>10        // dump everything, up to depth 3, if it takes more than 10 ms
 175 ```
 176
 177 In particular, I have `export RA_PROFILE='*>10'` in my shell profile.
 178
 179 We also have a "counting" profiler which counts number of instances of popular structs.
 180 It is enabled by `RA_COUNT=1`.
 181
 182 To measure time for from-scratch analysis, use something like this:
 183
 184 ```
 185 $ cargo run --release -p rust-analyzer -- analysis-stats ../chalk/
 186 ```
 187
 188 For measuring time of incremental analysis, use either of these:
 189
 190 ```
 191 $ cargo run --release -p rust-analyzer -- analysis-bench ../chalk/ --highlight ../chalk/chalk-engine/src/logic.rs
 192 $ cargo run --release -p rust-analyzer -- analysis-bench ../chalk/ --complete ../chalk/chalk-engine/src/logic.rs:94:0
 193 ```
 194
 195 Look for `fn benchmark_xxx` tests for a quick way to reproduce performance problems.
 196
 197 ## Release Process
 198
 199 Release process is handled by `release`, `dist` and `promote` xtasks, `release` being the main one.
 200
 201 `release` assumes that you have checkouts of `rust-analyzer`, `rust-analyzer.github.io`, and `rust-lang/rust` in the same directory:
 202
 203 ```
 204 ./rust-analyzer
 205 ./rust-analyzer.github.io
 206 ./rust-rust-analyzer  # Note the name!
 207 ```
 208
 209 Additionally, it assumes that remote for `rust-analyzer` is called `upstream` (I use `origin` to point to my fork).
 210
 211 Release steps:
 212
 213 1. Inside rust-analyzer, run `cargo xtask release`. This will:
 214    * checkout the `release` branch
 215    * reset it to `upstream/nightly`
 216    * push it to `upstream`. This triggers GitHub Actions which:
 217      * runs `cargo xtask dist` to package binaries and VS Code extension
 218      * makes a GitHub release
 219      * pushes VS Code extension to the marketplace
 220    * create new changelog in `rust-analyzer.github.io`
 221 2. While the release is in progress, fill in the changelog
 222 3. Commit & push the changelog
 223 4. Tweet
 224 5. Inside `rust-analyzer`, run `cargo xtask promote` -- this will create a PR to rust-lang/rust updating rust-analyzer's submodule.
 225    Self-approve the PR.
 226
 227 If the GitHub Actions release fails because of a transient problem like a timeout, you can re-run the job from the Actions console.
 228 If it fails because of something that needs to be fixed, remove the release tag (if needed), fix the problem, then start over.
 229 Make sure to remove the new changelog post created when running `cargo xtask release` a second time.
 230
 231 We release "nightly" every night automatically and promote the latest nightly to "stable" manually, every week.
 232 We don't do "patch" releases, unless something truly egregious comes up.
 233
 234 ## Permissions
 235
 236 There are three sets of people with extra permissions:
 237
 238 * rust-analyzer GitHub organization **admins** (which include current t-compiler leads).
 239   Admins have full access to the org.
 240 * **review** team in the organization.
 241   Reviewers have `r+` access to all of organization's repositories and publish rights on crates.io.
 242   They also have direct commit access, but all changes should via bors queue.
 243   It's ok to self-approve if you think you know what you are doing!
 244   bors should automatically sync the permissions.
 245 * **triage** team in the organization.
 246   This team can label and close issues.