Changelog #35

Author: matklad

generated_assists.adoc

@@ -291,7 +291,7 @@ enum A { One(One) }
 
 [discrete]
 === `extract_variable`
-**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/extract_variable.rs#L14[extract_variable.rs]
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/extract_variable.rs#L13[extract_variable.rs]
 
 Extracts subexpression into a variable.
 
@@ -343,7 +343,7 @@ fn handle(action: Action) {
 
 [discrete]
 === `fix_visibility`
-**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/fix_visibility.rs#L9[fix_visibility.rs]
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/fix_visibility.rs#L10[fix_visibility.rs]
 
 Makes inaccessible item public.
 

generated_features.adoc

@@ -291,6 +291,19 @@ The syntax for a structural search replace command is `<search_pattern> ==>> <re
 A `$<name>` placeholder in the search pattern will match any AST node and `$<name>` will reference it in the replacement.
 Within a macro call, a placeholder will match up until whatever token follows the placeholder.
 
+All paths in both the search pattern and the replacement template must resolve in the context
+in which this command is invoked. Paths in the search pattern will then match the code if they
+resolve to the same item, even if they're written differently. For example if we invoke the
+command in the module `foo` with a pattern of `Bar`, then code in the parent module that refers
+to `foo::Bar` will match.
+
+Paths in the replacement template will be rendered appropriately for the context in which the
+replacement occurs. For example if our replacement template is `foo::Bar` and we match some
+code in the `foo` module, we'll insert just `Bar`.
+
+Method calls should generally be written in UFCS form. e.g. `foo::Bar::baz($s, $a)` will match
+`$s.baz($a)`, provided the method call `baz` resolves to the method `foo::Bar::baz`.
+
 Placeholders may be given constraints by writing them as `${<name>:<constraint1>:<constraint2>...}`.
 
 Supported constraints:

manual.adoc

@@ -110,8 +110,8 @@ 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, like the few latest LSP requests
 * 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 all LSP requests, add `"rust-analyzer.trace.server": "verbose"` to the settings and look for `Server Trace` in the panel.
-* To enable client-side logging, add `"rust-analyzer.trace.extension": true` to the settings and open the `Console` tab of VS Code developer tools.
+* 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.
 
 === rust-analyzer Language Server Binary
 
@@ -273,9 +273,6 @@ However, if you use some other build system, you'll have to describe the structu
 [source,TypeScript]
 ----
 interface JsonProject {
-   /// The set of paths containing the crates for this project.
-   /// Any `Crate` must be nested inside some `root`.
-   roots: string[];
    /// The set of crates comprising the current project.
    /// Must include all transitive dependencies as well as sysroot crate (libstd, libcore and such).
    crates: Crate[];
@@ -288,11 +285,37 @@ interface Crate {
     edition: "2015" | "2018";
     /// Dependencies
     deps: Dep[];
+    /// Should this crate be treated as a member of current "workspace".
+    ///
+    /// By default, inferred from the `root_module` (members are the crates which reside
+    /// inside the directory opened in the editor).
+    ///
+    /// Set this to `false` for things like standard library and 3rd party crates to
+    /// enable performance optimizations (rust-analyzer assumes that non-member crates
+    /// don't change).
+    is_workspace_member?: boolean;
+    /// Optionally specify the (super)set of `.rs` files comprising this crate.
+    ///
+    /// By default, rust-analyzer assumes that only files under `root_module.parent` can belong to a crate.
+    /// `include_dirs` are included recursively, unless a subdirectory is in `exclude_dirs`.
+    ///
+    /// Different crates can share the same `source`.
+    ///
+    /// If two crates share an `.rs` file in common, they *must* have the same `source`.
+    /// rust-analyzer assumes that files from one source can't refer to files in another source.
+    source?: {
+        include_dirs: string[],
+        exclude_dirs: string[],
+    },
     /// The set of cfgs activated for a given crate, like `["unix", "feature=foo", "feature=bar"]`.
     cfg: string[];
+    /// Target triple for this Crate.
+    ///
+    /// Used when running `rustc --print cfg` to get target-specific cfgs.
+    target?: string;
+    /// Environment variables, used for the `env!` macro
+    env: : { [key: string]: string; },
 
-    /// value of the OUT_DIR env variable.
-    out_dir?: string;
     /// For proc-macro crates, path to compiles proc-macro (.so file).
     proc_macro_dylib_path?: string;
 }

thisweek/_posts/2020-07-27-changelog-35.adoc

@@ -0,0 +1,46 @@
+= Changelog #35
+:sectanchors:
+:page-layout: post
+
+Commit: commit:8ff40af7286b66294d8b64f0c8fdb3179a84be76[] +
+Release: release:2020-07-27[]
+
+== Sponsors
+
+**Become a sponsor:** https://opencollective.com/rust-analyzer/[opencollective.com/rust-analyzer]
+
+== New Features
+
+* pr:5524[] allow opting out of experimental diagnostics like MismatchedArgCount.
+* pr:5518[] use resolved paths in SSR rules. The main user-visible changes are:
+  ** SSR now matches paths based on whether they resolve to the same thing instead of whether they're written the same.
+    *** So `foo()` won't match `foo()` if it's a different function `foo()`, but will match `bar::foo()` if it's the same `foo`.
+  ** Paths in the replacement will now be rendered with appropriate qualification for their context.
+    *** For example `foo::Bar` will render as just `Bar` inside the module `foo`, but might render as `baz::foo::Bar` from elsewhere.
+  ** This means that all paths in the search pattern and replacement template must be able to be resolved.
+  ** It now also matters where you invoke SSR from, since paths are resolved relative to wherever that is.
+  ** Search now uses find-uses on paths to locate places to try matching. This means that when a path is present in the pattern, search will generally be pretty fast.
+  ** Function calls can now match method calls again, but this time only if they resolve to the same function.
+* pr:5527[] track internal metrics: https://rust-analyzer.github.io/metrics/.
+* pr:5470[] use `cargo.target` for `checkOnSave`.
+* pr:5451[] highlight more cases punctuation characters.
+* pr:5475[] support `Trait as _` imports.
+* pr:5492[] use symbol tags.
+* pr:5500[] problem matcher auto detects relative/absolute paths and matches VSCode LSP's owner and source.
+* pr:5473[] new format of `rust-project.json` -- configuration file for non Cargo-based projects.
+
+== Fixes
+
+* pr:5467[] allow null or empty values for configuration.
+* pr:5466[] do not show default types in function and closure return values.
+* pr:5478[] replace existing visibility modifier in **Fix Visibility** assist.
+* pr:5480[] fix snippetTextEdits applying to other files.
+
+== Internal Improvements
+
+* pr:5458[], pr:5472[] fully switch from `insta` to `expect`.
+* pr:5479[] allow gathering memory stats on non-jemalloc Linux.
+* pr:5481[] track document versions in the server.
+* pr:5497[] store macro invocation parameters green trees instead of token
+  trees, which improves memory usage.
+* pr:5519[] cache macro expansion in semantics.