3 files changed, 102 insertions, 21 deletions

diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 43a69d6ce..780f5cb91 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -392,7 +392,10 @@ rust-analyzer supports only one `kind`, `"cargo"`. The `args` for `"cargo"` look
 {
     workspaceRoot?: string;
     cargoArgs: string[];
+    cargoExtraArgs: string[];
     executableArgs: string[];
+    expectTest?: boolean;
+    overrideCargo?: string;
 }
 ```
 
diff --git a/docs/dev/style.md b/docs/dev/style.md
index 59067d234..7a64a0d22 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -186,6 +186,31 @@ impl Person {
 }
 ```
 
+## Constructors
+
+Prefer `Default` to zero-argument `new` function
+
+```rust
+// Good
+#[derive(Default)]
+struct Foo {
+    bar: Option<Bar>
+}
+
+// Not as good
+struct Foo {
+    bar: Option<Bar>
+}
+
+impl Foo {
+    fn new() -> Foo {
+        Foo { bar: None }
+    }
+}
+```
+
+Prefer `Default` even it has to be implemented manually.
+
 ## Avoid Monomorphization
 
 Rust uses monomorphization to compile generic code, meaning that for each instantiation of a generic functions with concrete types, the function is compiled afresh, *per crate*.
@@ -223,6 +248,8 @@ fn frbonicate(f: impl AsRef<Path>) {
 
 # Premature Pessimization
 
+## Avoid Allocations
+
 Avoid writing code which is slower than it needs to be.
 Don't allocate a `Vec` where an iterator would do, don't allocate strings needlessly.
 
@@ -242,6 +269,8 @@ if words.len() != 2 {
 }
 ```
 
+## Push Allocations to the Call Site
+
 If allocation is inevitable, let the caller allocate the resource:
 
 ```rust
@@ -257,6 +286,9 @@ fn frobnicate(s: &str) {
 }
 ```
 
+This is better because it reveals the costs.
+It is also more efficient when the caller already owns the allocation.
+
 ## Collection types
 
 Prefer `rustc_hash::FxHashMap` and `rustc_hash::FxHashSet` instead of the ones in `std::collections`.
@@ -334,27 +366,66 @@ People read things from top to bottom, so place most important things first.
 
 Specifically, if all items except one are private, always put the non-private item on top.
 
-Put `struct`s and `enum`s first, functions and impls last.
-
-Do
-
 ```rust
 // Good
-struct Foo {
-    bars: Vec<Bar>
+pub(crate) fn frobnicate() {
+    Helper::act()
 }
 
-struct Bar;
+#[derive(Default)]
+struct Helper { stuff: i32 }
+
+impl Helper {
+    fn act(&self) {
+
+    }
+}
+
+// Not as good
+#[derive(Default)]
+struct Helper { stuff: i32 }
+
+pub(crate) fn frobnicate() {
+    Helper::act()
+}
+
+impl Helper {
+    fn act(&self) {
+
+    }
+}
 ```
 
-rather than
+If there's a mixture of private and public items, put public items first.
+If function bodies are folded in the editor, the source code should read as documentation for the public API.
+
+Put `struct`s and `enum`s first, functions and impls last. Order types declarations in top-down manner.
 
 ```rust
+// Good
+struct Parent {
+    children: Vec<Child>
+}
+
+struct Child;
+
+impl Parent {
+}
+
+impl Child {
+}
+
 // Not as good
-struct Bar;
+struct Child;
 
-struct Foo {
-    bars: Vec<Bar>
+impl Child {
+}
+
+struct Parent {
+    children: Vec<Child>
+}
+
+impl Parent {
 }
 ```
 
@@ -371,6 +442,18 @@ Default names:
 * `n_foo` -- number of foos
 * `foo_idx` -- index of `foo`
 
+Many names in rust-analyzer conflict with keywords.
+We use mangled names instead of `r#ident` syntax:
+
+```
+struct -> strukt
+crate  -> krate
+impl   -> imp
+trait  -> trait_
+fn     -> func
+enum   -> enum_
+mod    -> module
+```
 
 ## Early Returns
 
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 46e7bd091..7e8adcdb7 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -116,6 +116,7 @@ Here are some useful self-diagnostic commands:
 * **Rust Analyzer: Show RA Version** shows the version of `rust-analyzer` binary.
 * **Rust Analyzer: Status** prints some statistics about the server, and dependency information for the current file.
 * To enable server-side logging, run with `env RA_LOG=info` and see `Output > Rust Analyzer Language Server` in VS Code's panel.
+* To log project loading (sysroot & `cargo metadata`), set `RA_LOG=project_model=debug`.
 * To log all LSP requests, add `"rust-analyzer.trace.server": "verbose"` to the settings and look for `Rust Analyzer Language Server Trace` in the panel.
 * To enable client-side logging, add `"rust-analyzer.trace.extension": true` to the settings and open `Output > Rust Analyzer Client` in the panel.
 
@@ -260,16 +261,7 @@ If you get an error saying `No such file or directory: 'rust-analyzer'`, see the
 
 === GNOME Builder
 
-Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
-
-Gnome Builder currently has support for RLS, and there's no way to configure the language server executable. A future version might support `rust-analyzer` out of the box.
-
-1. Rename, symlink or copy the `rust-analyzer` binary to `rls` and place it somewhere Builder can find (in `PATH`, or under `~/.cargo/bin`).
-2. Enable the Rust Builder plugin.
-
-==== GNOME Builder (Nightly)
-
-https://nightly.gnome.org/repo/appstream/org.gnome.Builder.flatpakref[GNOME Builder (Nightly)] has now native support for `rust-analyzer` out of the box. If the `rust-analyzer` binary is not available, GNOME Builder can install it when opening a Rust source file.
+GNOME Builder 3.37.1 and newer has native `rust-analyzer` support. If the LSP binary is not available, GNOME Builder can install it when opening a Rust file.
 
 == Non-Cargo Based Projects
 
@@ -295,6 +287,9 @@ interface JsonProject {
 }
 
 interface Crate {
+    /// Optional crate name used for display purposes, without affecting semantics.
+    /// See the `deps` key for semantically-significant crate names.
+    display_name?: string;
     /// Path to the root module of the crate.
     root_module: string;
     /// Edition of the crate.