Merge #7618

7618: Show qualified variant pattern completions r=Veykril a=Veykril

bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Show qualified variant pattern completions

Merge #7616

7616: Show `Self` pattern and Self-prefixed enum-variant completions r=Veykril a=Veykril


Variant pattern completions are to be done still.

Closes #6549, at least that should address all that's left from that issue from what I can see.

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Merge #7615

7615: Add parsing benchmark r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Add parsing benchmark

Show Self pattern completions for Adts if inside impls

Show completions for enum variant with self prefix if inside impl

Merge #7614

7614: Unleash inner item resolution to users r=jonas-schievink a=jonas-schievink


Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>

Remove unneeded return

Merge #7613

7613: Benchmarking infrastructure r=matklad a=matklad

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Infra for "unit" benchmarking

Remove `pub`

Use `block_def_map` in `Resolver`

This required a few changes to not bail out immediately if a
`ModuleScope` doesn't resolve a path.

The `LocalItemsScope` hack is now removed.

Teach `find_path` about inner items

Add another block def map test

Make `with_ancestor_maps` public

Add `TestDB::module_at_position`

Add expression scopes for blocks

Merge #7611

7611: Cleanups r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

restore accidentally deleted test

More precise navigation to parent

Cleanup tests

Merge #7597

7597: Set remote branch on xtask promote r=matklad a=lnicola

to hopefully fix this:

```
$ git switch master
Already on 'master'
Your branch is up to date with 'upstream/master'.
$ git fetch upstream
$ git reset --hard upstream/master
HEAD is now at 921ec4b3fca Auto merge of #81313 - LeSeulArtichaut:revert-32558, r=jyn514
$ git submodule update --recursive
Submodule path 'src/tools/rust-analyzer': checked out '1a59f75cdaa730c16a694a4294eccf6dfe6fe0ad'
$ git switch -c rust-analyzer-2021-02-08
Switched to a new branch 'rust-analyzer-2021-02-08'
$ git fetch origin
$ git reset --hard origin/release
HEAD is now at 336909b63 Merge #7587
$ git add src/tools/rust-analyzer
$ git commit "-m:arrow_up: rust-analyzer"
[rust-analyzer-2021-02-08 1774ec1a683] :arrow_up: rust-analyzer
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git push
fatal: The current branch rust-analyzer-2021-02-08 has no upstream branch.
To push the current branch and set the remote as upstream, use

    git push --set-upstream origin rust-analyzer-2021-02-08

Error: command `git push` failed, exit code: 128
```

Co-authored-by: Laurențiu Nicola <lnicola@dend.ro>

Track remote branch on xtask promote

Merge #7610

7610: Cleanup test r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Cleanup test

Fix highlighting of injected attributes

Modernize tests

Merge #7602

7602: Check for dyn impls in method resolution r=flodiebold a=Veykril

Fixes #6777

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Check for dyn impls in method resolution

Merge #7600

7600: Update crates r=flodiebold a=kjeremy

Pulls in https://github.com/rust-lang/chalk/pull/682

Co-authored-by: kjeremy <kjeremy@gmail.com>

Update crates

Pulls in https://github.com/rust-lang/chalk/pull/682

Merge #7599

7599: Add emacs guide r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Add emacs guide

Merge #7595

7595: Add `config: &CargoConfig` parameter to `fn load_cargo(…)` r=matklad a=regexident

For projects using rust-analyzer as a library it is desirable to be able to provide a custom-config to `fn load_cargo(…)` to pass features, etc, rather than having to copy & paste `fn load_cargo(…)` into one's project and maintain a fork of it and keep it in sync with upstream.

Co-authored-by: Vincent Esche <regexident@gmail.com>

Consolidate `fn load_cargo(…)` parameters into `struct LoadCargoConfig { … }`

Add `config: &CargoConfig` parameter to `fn load_cargo(…)`

Merge #7592

7592: [Doc] Note about Eclipse IDE support r=lnicola a=mickaelistria

Co-authored-by: Mickael Istria <mistria@redhat.com>

[Doc] Note about Eclipse IDE support

Merge #7593

7593: fix: add for keyword in completion #7588 r=lnicola a=gowrizrh

Fixes #7588
bors r+

Co-authored-by: Gowri <gowri.sankar@aligent.com.au>
Co-authored-by: Gowri <gowrizrh@gmail.com>

chore: swap order of placeholders

Merge #7549

7549:  Documentation: Explain how initial configuration is sent over LSP and document vim-lsp r=ilya-bobyr a=ilya-bobyr

This request contains two related but independent changes.
The first explains `rust-analyzer` initial configuration over LSP.
The second - adds documentation on `vim-lsp` Vim plugin and provides an example of the initial configuration for `rust-analyzer` when using this particular LSP client.

Let me know if you would prefer the changes to be reviewed in two separate pull requests.

Co-authored-by: Ilya Bobyr <ilya.bobyr@gmail.com>

Vim docs: vim-lsp with initial configuration.

`vim-lsp` is another popular LSP client for Vim.  And, as there is no
`rust-analyzer` specific UI, it is non-trivial to figure out how the
initial configuration is performed.

Explain how initial configuration is sent over LSP.

ci: update relevant test case expected values

fix: add for keyword in completion #7588

Merge #7587

7587: AdtDef -> Adt r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

AdtDef -> Adt

Merge #7586

7586: Add a section on entry points r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Add a section on entry points

Fixing architecture image on dark theme

Merge #7585

7585: More information for mbe in architecture.md r=edwin0cheng a=edwin0cheng

bors r+

Co-authored-by: Edwin Cheng <edwin0cheng@gmail.com>

Remove redunacny

More information for mbe

Merge #7584

7584: Update architecture.md for mbe and proc-macro r=edwin0cheng a=edwin0cheng

Co-authored-by: Edwin Cheng <edwin0cheng@gmail.com>

Update architecture.md for mbe and proc-macro

Merge #7583

7583: Update architecture.md r=bjorn3 a=aTuck

Typo

Co-authored-by: Adam Tuck <tuckaet@gmail.com>

Update architecture.md

Typo

Merge #7578

7578: Add a semantic token type for char literals r=Veykril a=petr-tik

Fixes #7530

The LSP spec doesn't recognise character literals, so
had to extend the suported types to our own custom type

Co-authored-by: petr-tik <petr-tik@users.noreply.github.com>

Add a semantic token type for char literals

The LSP spec doesn't recognise character literals, so
had to extend the suported types to our own custom type

Merge #7577

7577: cargo update r=kjeremy a=kjeremy

Co-authored-by: kjeremy <kjeremy@gmail.com>

Merge #7576

7576: Fix resolveCodeAction trying to edit files before creating them r=Veykril a=Veykril

Fixes #7208
bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

cargo update

Fix resolveCodeAction trying to edit files before creating them

Merge #7575

7575: Fix resolution of `self` module within blocks r=jonas-schievink a=jonas-schievink

bors r+

Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>

Test `super` resolution too

Fix resolution of `self` module within blocks

Merge #7572

7572: Add `find_or_create_impl_block` to assist utils r=matklad a=yoshuawuyts

This is another continuation of https://github.com/rust-analyzer/rust-analyzer/pull/7562, introducing a small util to either find an `impl` block, or create a new one if none exists. I copied this code from the `generate_new` assist into https://github.com/rust-analyzer/rust-analyzer/pull/7562, and this unifies both into a helper.

It doesn't feel super polished in its current state, but my hope is that this is enough of a starting point that it can be expanded on later. For example something that would be useful would be a flag which either returns the index of the start of the block, or the end of the block.

Anyway, I hope this is useful. Thanks!

Co-authored-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Add `find_or_create_impl_block` to assist utils

Merge #7573

7573: Do not overwrite lock file r=kjeremy a=kjeremy

Use `npm ci` instead of `npm install`. `npm install` will overwrite
the lock file if you have a newer npm version than the one that
generated the package-lock.json

Co-authored-by: kjeremy <kjeremy@gmail.com>

Merge #7574

7574: Remove various redundant clones r=kjeremy a=yoshuawuyts

I noticed when running clippy through RA that there are a few instances where `clone` is called where it's not actually needed. I figured a small patch to remove these might be welcome here.

Thanks!

Co-authored-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Do not overwrite lock file

Use `npm ci` instead of `npm install`. `npm install` will overwrite
the lock file if you have a newer npm version than the one that
generated the package-lock.json

Remove redundant clones

Merge #7505

7505: Widen Highlights root range to covering element r=Veykril a=Veykril

There have been a few issues about/containing spurious syntax highlighting panics, which all seem to come from the `rust_analyzer::handlers::handle_semantic_tokens_range` request, which I believe this to be the cause of as the text range we want to highlight here is currently potentially smaller than that of the covering element, so we might highlight something that is inside the covering element, but outside of the text range we wish to highlight causing the assert to fail.
Unfortunately this isn't really easy to test since I have yet to find a reproducible cause(#7504 doesn't work for me cause I can't seem to checkout the given commit).

See #7504, #7298, #7299 and #7416, all of those contain an assertion failure in syntax highlighting, but only in the range request.

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Merge #7570 #7571

7570: Add doc gen to the `generate_enum_match_method` assist r=yoshuawuyts a=yoshuawuyts

Implements a small extension to https://github.com/rust-analyzer/rust-analyzer/pull/7562, generating default comments. I wasn't sure if this would fit the goals of Rust-Analyzer, so I chose to split it into a separate PR. This is especially useful when writing code in a codebase which uses `#![warn(missing_docs)]` lint, as many production-grade libraries do.

The comments we're generating here are similar to the ones found on [`Option::is_some`](https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some) and [`Result::is_err`](https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err). I briefly considered only generating these for `pub` types, but they seem small and unobtrusive enough that they're probably useful in the general case. Thanks!

## Example

__input__
```rust
pub(crate) enum Variant {
    Undefined,
    Minor, // cursor here
    Major,
}
```

__output__
```rust
pub(crate) enum Variant {
    Undefined,
    Minor,
    Major,
}

impl Variant {
    /// Returns `true` if the variant is [`Minor`].
    pub(crate) fn is_minor(&self) -> bool {
        matches!(self, Self::Minor)
    }
}
```

## Future Directions

This opens up the path to adding an assist for generating these comments on existing `is_` methods. This would make it both easy to document new code, and update existing code with documentation.

7571: Cleanup decl_check r=Veykril a=Veykril

bors r+

Co-authored-by: Yoshua Wuyts <yoshuawuyts@gmail.com>
Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Cleanup decl_check

Add doc gen to the `generate_enum_match_method` assist

Merge #7569

7569: Add howtos r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Add howtos

Merge #7562

7562: add `generate_enum_match` assist r=matklad a=yoshuawuyts

This adds a `generate_enum_match` assist, which generates `is_` variants for enums (e.g. `Option::{is_none,is_some}` in std). This is my first attempt at contributing to Rust-Analyzer, so I'm not sure if I've gotten everything right. Thanks!

## Example

**Input**
```rust
pub(crate) enum Variant {
    Undefined,
    Minor, // cursor here
    Major,
}
```
**Output**
```rust
pub(crate) enum Variant {
    Undefined,
    Minor,
    Major,
}

impl Variant {
    pub(crate) fn is_minor(&self) -> bool {
        matches!(self, Self::Minor)
    }
}
```

## Future Directions

I made this as a stepping stone for some of the more involved refactors (e.g. #5944). I'm not sure yet how to create, use, and test `window.showQuickPick`-based asssists in RA. But once that's possible, it'd probably be nice to be able to generate match methods in bulk through the quickpick UI rather than one-by-one:

```
[x] Select enum members to generate methods for. (3 selected) [ OK ]
---------------------------------------------------------------------------
[x] Undefined
[x] Minor
[x] Major
```

Co-authored-by: Yoshua Wuyts <yoshuawuyts+github@gmail.com>
Co-authored-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Merge #7568

7568: Fix merging of `segment_index` in path resolution r=jonas-schievink a=jonas-schievink

This caused associated item lookup to fail when modifying `resolver.rs` to handle block expressions with inner items.

bors r+

Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>

Fix merging of `segment_index` in path resolution

Merge #7567

7567: Remove unnecessary allocs in case_conv r=Veykril a=Veykril

and some replace unwraps

bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Remove unnecessary allocs in case_conv

Move `find_struct_impl` to assist utils

add `generate-enum-match` assist

Merge #7535

7535: Extract function assist r=cpud36 a=cpud36

This PR adds `extract function/method` assist. closes #5409.

# Supported features
Assist should support extracting from expressions(`1`, `2 + 2`, `loop { }`) and from a series of statements, e.g.:
```rust
foo();
$0bar();
baz();$0
quix();
```
Assist also supports extracting parameters, like:
```rust
fn foo() -> i32 {
  let n = 1;
  $0n + 1$0
}

// -
fn foo() -> i32 {
  let n = 1;
  fun_name(n)
}

fn fun_name(n: i32) -> i32 {
  n + 1
}
```

Extracting methods also generally works.

Assist allows referencing outer variables, both mutably and immutably, and handles handles access to variables local to extracted function:
```rust
fn foo() {
  let mut n = 1;
  let mut m = 2;
  let mut moved_v = Vec::new();
  let mut ref_mut_v = Vec::new();
  $0
  n += 1;
  let k = 1;
  moved_v.push(n);
  let r = &mut m;
  ref_mut_v.push(*r);
  let h = 3;
  $0
  n = ref_mut_v.len() + k;
  n -= h + m;
}

// -
fn foo() {
  let mut n = 1;
  let mut m = 2;
  let mut moved_v = Vec::new();
  let mut ref_mut_v = Vec::new();

  let (k, h) =  fun_name(&mut n, moved_v, &mut m, &mut ref_mut_v);

  n = ref_mut_v.len() + k;
  n -= h + m;
}

fn fun_name(n: &mut i32, mut moved_v: Vec<i32>, m: &mut i32, ref_mut_v: &mut Vec<i32>) -> (i32, i32) {
  *n += 1;
  let k = 1;
  moved_v.push(*n);
  let r = m;
  ref_mut_v.push(*r);
  let h = 3;
  (k, h)
}
```

So we handle both input and output paramters

# Showcase


# Working with non-`Copy` types

Consider the following example:
```rust
fn foo() {
  let v = Vec::new();
  $0
  let n = v.len();
  $0
  let is_empty = v.is_empty();
}
```
`v` must be a parameter to extracted function.
The question is, what type should it have.
It could be `v: Vec<i32>`, or `v: &Vec<i32>`.
The former is incorrect for `Vec<i32>`, but the later is silly for `i32`.

To resolve this we need to know if the type implements `Copy` trait.

I didn't find any api available from assists to query this.
`hir_ty::method_resolution::implements` seems relevant, but is isn't publicly re-exported from `hir`.

# Star(`*`) token and pointer dereference

If I understand correctly, in order to create expression like `*p`, one should use `ast::make::expr_prefix(T![*], ...)`, which
in turn calls `token(T![*])`.

`token` does not have star in `tokens::SOURCE_FILE`, so this panics.
I had to add `*` to `SOURCE_FILE` to make it work.

Correct me if this is not intended way to do this.

# Lowering access `value -> mut ref -> shared ref`

Consider the following example:
```rust
fn foo() {
  let v = Vec::new();
  $0 let n = v.len(); $0
}
```
`v` is not used after extracted function body, so both `v: &Vec<i32>` and `v: Vec<i32>` would work.
Currently the later would be chosen.

We can however check the body of extracted function and conclude that `v: &Vec<i32>` is sufficient.
Using `v: &Vec<i32>`(that is a minimal required access level) might be a better default.
I am unsure.

# Cleanup
The assist seems to be reasonably handling most of common cases.
If there are no concerns with code it produces(i.e. with test cases), I will start cleaning up

[edit]
added showcase

Co-authored-by: Vladyslav Katasonov <cpud47@gmail.com>

allow extracted body to be indented(dedent it)

allow transitive `&mut` access for fields in extract_function

add tests for extracting if/match/while/for exprs

document extract_function assist implementation

use `&T` for non copy params of extracted function

Use shared ref if param is not `T: Copy` and is used after body

Merge #7561

7561: Avoid using ModPath's fields directly r=jonas-schievink a=jonas-schievink

bors r+

Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>

Avoid using ModPath's fields directly

 split extract_function into pieces and order them

Merge #7559

7559: Make `ModPath`'s representation private r=jonas-schievink a=jonas-schievink

This lets us switch out the `Vec` for something more efficient

bors r+

Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>

Make `ModPath`'s representation private

Merge #7558

7558: Update thread_local r=kjeremy a=kjeremy

Pulls in https://github.com/Amanieu/thread_local-rs/pull/30 which fixes
a leak when dropping ThreadLocal.

Co-authored-by: kjeremy <kjeremy@gmail.com>

Update thread_local

Pulls in https://github.com/Amanieu/thread_local-rs/pull/30 which fixes
a leak when dropping ThreadLocal.

Merge #7557

7557: Intern `TypeRef`s in the containing `ItemTree` r=jonas-schievink a=jonas-schievink

This reduces the memory used by `ItemTreeQuery` by ~20%. As it turns out, `TypeRef` is very heavy, and is used a lot in `ItemTree`:

* Many types are frequently repeated throughout the same file. This is what this PR addresses by storing identical `TypeRef`s only once per `ItemTree`.
* The vast majority of `TypeRef` consist of a plain path with only a single element. "Type anchors" like in `<Ty>::func` are used incredibly rarely, and even multi-segment paths are much rarer than single-segment paths.

Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>