Auto merge of #12490 - yue4u:fix/show-enum-in-fresh-use-tree, r=Veykril

fix: complete non-std enum at the start of `use` completions

close: #12421

Auto merge of #12464 - harpsword:fix-inline-variable-mismatched-type, r=Veykril

feat: fix inline variable produce mismatched type

wrap reference for RefExpr initializer to fix #12453

Auto merge of #12477 - hasali19:auto-reload, r=Veykril

Restart server automatically on settings changes

Closes #12476

I think this works quite well, but if you think it would be better to put it behind a setting I can do that.

Auto merge of #12473 - yue4u:fix/no-enum-parens-in-use, r=Veykril

fix: avoid adding enum parens in use path

close #12420

Auto merge of #12502 - Veykril:deps, r=Veykril

internal: Bump Dependencies

internal: Bump Dependencies

Auto merge of #12501 - Veykril:dashmap, r=Veykril

internal: Update dashmap and freeze its version

internal: Update dashmap and freeze its version

feat: append :: after

Auto merge of #12487 - lukechu10:master, r=lnicola

minor: hide param inlay hint when argument is fn-like macro with similar name

Closes #12486

Auto merge of #12493 - bjorn3:fix_warnings, r=lnicola

Fix a couple of weak warnings found by rust-analyzer itself

Hide param inlay hint when argument is fn-like macro with similar name

Fix a couple of weak warnings found by rust-analyzer itself

Auto merge of #12492 - bjorn3:proc_macro_abi_1_63, r=lnicola

feat: Add proc macro ABI for rustc 1.63

Fixes https://github.com/rust-lang/rust-analyzer/issues/12489

This bumps the MSRV to 1.61 due to usage of function pointers and `impl Trait` in const functions.

<details>

<summary>Diff from upstream proc_macro as of rust-lang/rust@e45d9973b2665897a768312e971b82cc62633103 (misses lib.rs as it got renamed to mod.rs)</summary>

```diff
diff -u --recursive ../rust/library/proc_macro/src/bridge/client.rs crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/bridge/client.rs
--- ../rust/library/proc_macro/src/bridge/client.rs     2022-06-08 13:14:57.763123238 +0000
+++ crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/bridge/client.rs 2022-06-08 13:33:23.378430287 +0000
`@@` -430,27 +430,27 `@@`
     buf
 }

-impl Client<crate::TokenStream, crate::TokenStream> {
-    pub const fn expand1(f: impl Fn(crate::TokenStream) -> crate::TokenStream + Copy) -> Self {
+impl Client<super::super::TokenStream, super::super::TokenStream> {
+    pub const fn expand1(f: impl Fn(super::super::TokenStream) -> super::super::TokenStream + Copy) -> Self {
         Client {
             get_handle_counters: HandleCounters::get,
             run: super::selfless_reify::reify_to_extern_c_fn_hrt_bridge(move |bridge| {
-                run_client(bridge, |input| f(crate::TokenStream(input)).0)
+                run_client(bridge, |input| f(super::super::TokenStream(input)).0)
             }),
             _marker: PhantomData,
         }
     }
 }

-impl Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream> {
+impl Client<(super::super::TokenStream, super::super::TokenStream), super::super::TokenStream> {
     pub const fn expand2(
-        f: impl Fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream + Copy,
+        f: impl Fn(super::super::TokenStream, super::super::TokenStream) -> super::super::TokenStream + Copy,
     ) -> Self {
         Client {
             get_handle_counters: HandleCounters::get,
             run: super::selfless_reify::reify_to_extern_c_fn_hrt_bridge(move |bridge| {
                 run_client(bridge, |(input, input2)| {
-                    f(crate::TokenStream(input), crate::TokenStream(input2)).0
+                    f(super::super::TokenStream(input), super::super::TokenStream(input2)).0
                 })
             }),
             _marker: PhantomData,
`@@` -464,17 +464,17 `@@`
     CustomDerive {
         trait_name: &'static str,
         attributes: &'static [&'static str],
-        client: Client<crate::TokenStream, crate::TokenStream>,
+        client: Client<super::super::TokenStream, super::super::TokenStream>,
     },

     Attr {
         name: &'static str,
-        client: Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream>,
+        client: Client<(super::super::TokenStream, super::super::TokenStream), super::super::TokenStream>,
     },

     Bang {
         name: &'static str,
-        client: Client<crate::TokenStream, crate::TokenStream>,
+        client: Client<super::super::TokenStream, super::super::TokenStream>,
     },
 }

`@@` -490,21 +490,21 `@@`
     pub const fn custom_derive(
         trait_name: &'static str,
         attributes: &'static [&'static str],
-        expand: impl Fn(crate::TokenStream) -> crate::TokenStream + Copy,
+        expand: impl Fn(super::super::TokenStream) -> super::super::TokenStream + Copy,
     ) -> Self {
         ProcMacro::CustomDerive { trait_name, attributes, client: Client::expand1(expand) }
     }

     pub const fn attr(
         name: &'static str,
-        expand: impl Fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream + Copy,
+        expand: impl Fn(super::super::TokenStream, super::super::TokenStream) -> super::super::TokenStream + Copy,
     ) -> Self {
         ProcMacro::Attr { name, client: Client::expand2(expand) }
     }

     pub const fn bang(
         name: &'static str,
-        expand: impl Fn(crate::TokenStream) -> crate::TokenStream + Copy,
+        expand: impl Fn(super::super::TokenStream) -> super::super::TokenStream + Copy,
     ) -> Self {
         ProcMacro::Bang { name, client: Client::expand1(expand) }
     }
diff -u --recursive ../rust/library/proc_macro/src/bridge/mod.rs crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/bridge/mod.rs
--- ../rust/library/proc_macro/src/bridge/mod.rs        2022-06-08 13:14:57.763123238 +0000
+++ crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/bridge/mod.rs    2022-06-08 13:33:39.694243060 +0000
`@@` -8,7 +8,7 `@@`

 #![deny(unsafe_code)]

-use crate::{Delimiter, Level, LineColumn, Spacing};
+pub use super::{Delimiter, Level, LineColumn, Spacing};
 use std::fmt;
 use std::hash::Hash;
 use std::marker;
diff '--color=always' -u --recursive ../rust/library/proc_macro/src/bridge/server.rs crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/bridge/server.rs
--- ../rust/library/proc_macro/src/bridge/server.rs     2022-06-08 13:14:57.763123238 +0000
+++ crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/bridge/server.rs 2022-06-08 13:33:54.306075391 +0000
`@@` -274,7 +274,7 `@@`
     Result::decode(&mut &buf[..], &mut dispatcher.handle_store)
 }

-impl client::Client<crate::TokenStream, crate::TokenStream> {
+impl client::Client<super::super::TokenStream, super::super::TokenStream> {
     pub fn run<S: Server>(
         &self,
         strategy: &impl ExecutionStrategy,
`@@` -295,7 +295,7 `@@`
     }
 }

-impl client::Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream> {
+impl client::Client<(super::super::TokenStream, super::super::TokenStream), super::super::TokenStream> {
     pub fn run<S: Server>(
         &self,
         strategy: &impl ExecutionStrategy,
diff -u --recursive ../rust/library/proc_macro/src/diagnostic.rs crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/diagnostic.rs
--- ../rust/library/proc_macro/src/diagnostic.rs        2022-05-11 10:07:59.099909725 +0000
+++ crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/diagnostic.rs    2022-06-08 13:35:01.169308145 +0000
`@@` -1,7 +1,6 `@@`
-use crate::Span;
+use super::Span;

 /// An enum representing a diagnostic level.
-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 #[derive(Copy, Clone, Debug)]
 #[non_exhaustive]
 pub enum Level {
`@@` -16,27 +15,23 `@@`
 }

 /// Trait implemented by types that can be converted into a set of `Span`s.
-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 pub trait MultiSpan {
     /// Converts `self` into a `Vec<Span>`.
     fn into_spans(self) -> Vec<Span>;
 }

-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl MultiSpan for Span {
     fn into_spans(self) -> Vec<Span> {
         vec![self]
     }
 }

-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl MultiSpan for Vec<Span> {
     fn into_spans(self) -> Vec<Span> {
         self
     }
 }

-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl<'a> MultiSpan for &'a [Span] {
     fn into_spans(self) -> Vec<Span> {
         self.to_vec()
`@@` -45,7 +40,6 `@@`

 /// A structure representing a diagnostic message and associated children
 /// messages.
-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 #[derive(Clone, Debug)]
 pub struct Diagnostic {
     level: Level,
`@@` -56,7 +50,6 `@@`

 macro_rules! diagnostic_child_methods {
     ($spanned:ident, $regular:ident, $level:expr) => {
-        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
         #[doc = concat!("Adds a new child diagnostics message to `self` with the [`",
                         stringify!($level), "`] level, and the given `spans` and `message`.")]
         pub fn $spanned<S, T>(mut self, spans: S, message: T) -> Diagnostic
`@@` -68,7 +61,6 `@@`
             self
         }

-        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
         #[doc = concat!("Adds a new child diagnostic message to `self` with the [`",
                         stringify!($level), "`] level, and the given `message`.")]
         pub fn $regular<T: Into<String>>(mut self, message: T) -> Diagnostic {
`@@` -80,10 +72,8 `@@`

 /// Iterator over the children diagnostics of a `Diagnostic`.
 #[derive(Debug, Clone)]
-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 pub struct Children<'a>(std::slice::Iter<'a, Diagnostic>);

-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl<'a> Iterator for Children<'a> {
     type Item = &'a Diagnostic;

`@@` -92,17 +82,14 `@@`
     }
 }

-#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl Diagnostic {
     /// Creates a new diagnostic with the given `level` and `message`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn new<T: Into<String>>(level: Level, message: T) -> Diagnostic {
         Diagnostic { level, message: message.into(), spans: vec![], children: vec![] }
     }

     /// Creates a new diagnostic with the given `level` and `message` pointing to
     /// the given set of `spans`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn spanned<S, T>(spans: S, level: Level, message: T) -> Diagnostic
     where
         S: MultiSpan,
`@@` -117,59 +104,51 `@@`
     diagnostic_child_methods!(span_help, help, Level::Help);

     /// Returns the diagnostic `level` for `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn level(&self) -> Level {
         self.level
     }

     /// Sets the level in `self` to `level`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn set_level(&mut self, level: Level) {
         self.level = level;
     }

     /// Returns the message in `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn message(&self) -> &str {
         &self.message
     }

     /// Sets the message in `self` to `message`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn set_message<T: Into<String>>(&mut self, message: T) {
         self.message = message.into();
     }

     /// Returns the `Span`s in `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn spans(&self) -> &[Span] {
         &self.spans
     }

     /// Sets the `Span`s in `self` to `spans`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn set_spans<S: MultiSpan>(&mut self, spans: S) {
         self.spans = spans.into_spans();
     }

     /// Returns an iterator over the children diagnostics of `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn children(&self) -> Children<'_> {
         Children(self.children.iter())
     }

     /// Emit the diagnostic.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn emit(self) {
-        fn to_internal(spans: Vec<Span>) -> crate::bridge::client::MultiSpan {
-            let mut multi_span = crate::bridge::client::MultiSpan::new();
+        fn to_internal(spans: Vec<Span>) -> super::bridge::client::MultiSpan {
+            let mut multi_span = super::bridge::client::MultiSpan::new();
             for span in spans {
                 multi_span.push(span.0);
             }
             multi_span
         }

-        let mut diag = crate::bridge::client::Diagnostic::new(
+        let mut diag = super::bridge::client::Diagnostic::new(
             self.level,
             &self.message[..],
             to_internal(self.spans),
Only in ../rust/library/proc_macro/src/: lib.rs
Only in crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/: mod.rs
diff -u --recursive ../rust/library/proc_macro/src/quote.rs crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/quote.rs
--- ../rust/library/proc_macro/src/quote.rs     2022-05-11 10:22:36.097429479 +0000
+++ crates/proc-macro-srv/src/abis/abi_1_63/proc_macro/quote.rs 2022-06-08 13:35:08.737221303 +0000
`@@` -4,7 +4,7 `@@`
 //! This quasiquoter uses macros 2.0 hygiene to reliably access
 //! items from `proc_macro`, to build a `proc_macro::TokenStream`.

-use crate::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
+use super::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};

 macro_rules! quote_tt {
     (($($t:tt)*)) => { Group::new(Delimiter::Parenthesis, quote!($($t)*)) };
`@@` -59,10 +59,9 `@@`
 /// This is the actual implementation of the `quote!()` proc macro.
 ///
 /// It is loaded by the compiler in `register_builtin_macros`.
-#[unstable(feature = "proc_macro_quote", issue = "54722")]
 pub fn quote(stream: TokenStream) -> TokenStream {
     if stream.is_empty() {
-        return quote!(crate::TokenStream::new());
+        return quote!(super::TokenStream::new());
     }
     let proc_macro_crate = quote!(crate);
     let mut after_dollar = false;
`@@` -73,7 +72,7 `@@`
                 after_dollar = false;
                 match tree {
                     TokenTree::Ident(_) => {
-                        return Some(quote!(Into::<crate::TokenStream>::into(
+                        return Some(quote!(Into::<super::TokenStream>::into(
                         Clone::clone(&(@ tree))),));
                     }
                     TokenTree::Punct(ref tt) if tt.as_char() == '$' => {}
`@@` -86,33 +85,33 `@@`
                 }
             }

-            Some(quote!(crate::TokenStream::from((@ match tree {
-                TokenTree::Punct(tt) => quote!(crate::TokenTree::Punct(crate::Punct::new(
+            Some(quote!(super::TokenStream::from((@ match tree {
+                TokenTree::Punct(tt) => quote!(super::TokenTree::Punct(super::Punct::new(
                     (@ TokenTree::from(Literal::character(tt.as_char()))),
                     (@ match tt.spacing() {
-                        Spacing::Alone => quote!(crate::Spacing::Alone),
-                        Spacing::Joint => quote!(crate::Spacing::Joint),
+                        Spacing::Alone => quote!(super::Spacing::Alone),
+                        Spacing::Joint => quote!(super::Spacing::Joint),
                     }),
                 ))),
-                TokenTree::Group(tt) => quote!(crate::TokenTree::Group(crate::Group::new(
+                TokenTree::Group(tt) => quote!(super::TokenTree::Group(super::Group::new(
                     (@ match tt.delimiter() {
-                        Delimiter::Parenthesis => quote!(crate::Delimiter::Parenthesis),
-                        Delimiter::Brace => quote!(crate::Delimiter::Brace),
-                        Delimiter::Bracket => quote!(crate::Delimiter::Bracket),
-                        Delimiter::None => quote!(crate::Delimiter::None),
+                        Delimiter::Parenthesis => quote!(super::Delimiter::Parenthesis),
+                        Delimiter::Brace => quote!(super::Delimiter::Brace),
+                        Delimiter::Bracket => quote!(super::Delimiter::Bracket),
+                        Delimiter::None => quote!(super::Delimiter::None),
                     }),
                     (@ quote(tt.stream())),
                 ))),
-                TokenTree::Ident(tt) => quote!(crate::TokenTree::Ident(crate::Ident::new(
+                TokenTree::Ident(tt) => quote!(super::TokenTree::Ident(super::Ident::new(
                     (@ TokenTree::from(Literal::string(&tt.to_string()))),
                     (@ quote_span(proc_macro_crate.clone(), tt.span())),
                 ))),
-                TokenTree::Literal(tt) => quote!(crate::TokenTree::Literal({
+                TokenTree::Literal(tt) => quote!(super::TokenTree::Literal({
                     let mut iter = (@ TokenTree::from(Literal::string(&tt.to_string())))
-                        .parse::<crate::TokenStream>()
+                        .parse::<super::TokenStream>()
                         .unwrap()
                         .into_iter();
-                    if let (Some(crate::TokenTree::Literal(mut lit)), None) =
+                    if let (Some(super::TokenTree::Literal(mut lit)), None) =
                         (iter.next(), iter.next())
                     {
                         lit.set_span((@ quote_span(proc_macro_crate.clone(), tt.span())));
`@@` -129,12 +128,11 `@@`
         panic!("unexpected trailing `$` in `quote!`");
     }

-    quote!([(@ tokens)].iter().cloned().collect::<crate::TokenStream>())
+    quote!([(@ tokens)].iter().cloned().collect::<super::TokenStream>())
 }

 /// Quote a `Span` into a `TokenStream`.
 /// This is needed to implement a custom quoter.
-#[unstable(feature = "proc_macro_quote", issue = "54722")]
 pub fn quote_span(proc_macro_crate: TokenStream, span: Span) -> TokenStream {
     let id = span.save_span();
     quote!((@ proc_macro_crate ) ::Span::recover_proc_macro_span((@ TokenTree::from(Literal::usize_unsuffixed(id)))))
```

</details>

Add doc comment

Rustfmt

Add proc macro ABI for rustc 1.63

fix: show non-std enum in a fresh use tree completion

Auto merge of #12480 - KOLANICH-tools:unneeded_destr_assignment, r=jonas-schievink

Remove the unneeded destructuring assignment

in `run` in `project-model/src/build_scripts.rs`

Remove the unneeded destructuring assignment in `run` in `project-model/src/build_scripts.rs`

Add restartServerOnConfigChange setting

Restart server automatically on settings changes

Auto merge of #12475 - Veykril:trait-impl-completion, r=Veykril

fix: Fix trait impl completions using wrong insert position

Fixes https://github.com/rust-lang/rust-analyzer/issues/12474

fix: Fix trait impl completions using wrong insert position

fix: avoid adding enum parens in use

Auto merge of #12472 - Veykril:output-ch, r=Veykril

internal: Keep output channels across restarts

cc https://github.com/rust-lang/rust-analyzer/pull/12470

internal: Keep output channels across restarts

Auto merge of #12471 - Veykril:reload-restart, r=Veykril

fix: Restart the server instead of reloading the window when config changes

 cc https://github.com/rust-lang/rust-analyzer/issues/12469#event-6743447147

fix: Restart the server instead of reloading the window when config changes

Auto merge of #12470 - Veykril:output-ch, r=Veykril

fix: Cleanup output channels when restarting server

Fixes https://github.com/rust-lang/rust-analyzer/issues/12469

fix: Cleanup output channels when restarting server

Auto merge of #12466 - lnicola:worker-thread-stack, r=lnicola

Increase worker thread stack and name them

CC #11370

Auto merge of #12468 - Veykril:cancelled-diags, r=Veykril

minor: Don't log cancelled diagnostics

Since we retry requests now we can actually hit this legitimately

minor: Don't log cancelled diagnostics

Auto merge of #12467 - Veykril:assist-fix, r=Veykril

fix: Fix match to if let assist for wildcard pats

fix: Fix match to if let assist for wildcard pats

Increase worker thread stack and name them

Auto merge of #12465 - Veykril:buildscripts, r=Veykril

internal: Only record build script outputs when the output has been changed

Follow up to https://github.com/rust-lang/rust-analyzer/pull/12457

Only record build script outputs when the output has been changed

feat: fix inline variable produce mismatched type

wrap reference for RefExpr initializer

Auto merge of #12461 - Veykril:completions, r=Veykril

Move trait_impl completion analysis into CompletionContext

Remove some of the unnecessary helpfer functions from CompletionContext

Simplify

Move trait_impl completion analysis into CompletionContext

Auto merge of #12459 - Veykril:completions, r=Veykril

internal: Clean up keyword completion handling

https://github.com/rust-lang/rust-analyzer/issues/12144

Auto merge of #12457 - Veykril:logging, r=Veykril

internal: Don't log default build script outputs

Auto merge of #12460 - Veykril:move-guard, r=Veykril

minor: Reduce move-guard trigger range

minor: Reduce move-guard trigger range

internal: Don't log default build script outputs

Deduplicate

Remove prev-sibling completion machinery

More precise where keyword completions

Remove dead code

Fix visibility mods not being completed for field defs

internal: Move most remaining keyword completions to item list completions

Auto merge of #12333 - nolanderc:order-import-assist, r=Veykril

Order auto-imports by relevance

Fixes #10337.

Basically we sort the imports according to how "far away" the imported item is from where we want to import it to. This change makes it so that imports from the current crate are sorted before any third-party crates. Additionally, we make an exception for builtin crates (`std`, `core`, etc.) so that they are sorted before any third-party crates.

There are probably other heuristics that should be added to improve the experience (such as preferring imports that are common elsewhere in the same crate, and ranking crates depending on the dependency graph). However, I think this is a first good step.

PS. This is my first time contributing here, so please be gentle if I have missed something obvious :-)

Auto merge of #12452 - iDawer:assist.merge_selected_imports, r=Veykril

feature: `Merge imports` assist can merge multiple selected imports.

The selected imports have to have a common prefix in paths.

Select imports or use trees to merge:
```rust
$0use std::fmt::Display;
use std::fmt::Debug;
use std::fmt::Write;$0
```
Apply `Merge imports`:
```rust
use std::fmt::{Display, Debug, Write};
```

Closes #12426

Auto merge of #12451 - TimNN:double-dollar, r=Veykril

feat: Support `$$` in macros.

The implementation mirrors what `rustc` currently does [1]. Part of #11952.

\[1]: https://github.com/rust-lang/rust/blob/0595ea1d12cf745e0a672d05341429ecb0917e66/compiler/rustc_expand/src/mbe/quoted.rs#L230-L241

Auto merge of #12456 - lnicola:thread-names, r=lnicola

internal: Shorten main thread names

Linux effectively has a 15 byte limit, which resulted in `rust-analyzer s` and `rust-analyzer p`. That's still unambiguous, but probably not obvious.

Shorten main thread name

feat: Support `$$` in macros.

The implementation mirrors what `rustc` currently does [1]. Part of #11952.

[1]: https://github.com/rust-lang/rust/blob/0595ea1d12cf745e0a672d05341429ecb0917e66/compiler/rustc_expand/src/mbe/quoted.rs#L230-L241

Allow merging of multiple selected imports.

The selected imports have to have a common prefix in paths.

Before
```rust
$0use std::fmt::Display;
use std::fmt::Debug;$0
```
After
```rust
use std::fmt::{Display, Debug};
```

Auto merge of #12444 - XFFXFF:fix_12442, r=Veykril

fix: parsing of `?` opt-out trait bounds

fixes #12442

fix: parsing of `?` opt-out trait bounds

thanks to Veykril

Auto merge of #12347 - feniljain:fix_extract_module, r=Veykril

fix(extract_module) resolving import panics and improve import resolution

- Should solve #11766
- While adding a test case for this issue, I observed another issue:
For this test case:
```rust
            mod x {
                pub struct Foo;
                pub struct Bar;
            }

            use x::{Bar, Foo};

            $0type A = (Foo, Bar);$0
```
extract module should yield this:

```rust
            mod x {
                pub struct Foo;
                pub struct Bar;
            }

            use x::{};

            mod modname {
                use super::x::Bar;

                use super::x::Foo;

                pub(crate) type A = (Foo, Bar);
            }
```

instead it gave:

```rust
            mod x {
                pub struct Foo;
                pub struct Bar;
            }

            use x::{};

            mod modname {
                use x::Bar;

                use x::Foo;

                pub(crate) type A = (Foo, Bar);
            }
```

So fixed this problem with second commit

Auto merge of #12443 - Veykril:fmtfix, r=Veykril

minor: Fix rustfmt failing on main_loop.rs

minor: Fix rustfmt failing on main_loop.rs

Auto merge of #12440 - Maan2003:empty-msg-diag, r=jonas-schievink

fix(diagnostic): Don't remove diagnostic with empty message

Use " " as message if it is empty

[discussion on zulip](https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Frust-analyzer/topic/empty.20diagnostic.20message)


fix(diagnostic): Don't remove diagnostic with empty message

Use " " as message if it is empty

Auto merge of #12431 - Veykril:request-retry, r=Veykril

fix: Fix completions disappearing when typing two keys in quick succession

With this PR we now retry requests if they get cancelled due to document changes.

This fixes the completions problem we have where completions seem to randomly disappear, see https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Frust-analyzer/topic/Completions.20not.20always.20appearing

Fixes https://github.com/rust-lang/rust-analyzer/issues/10187
Fixes https://github.com/rust-lang/rust-analyzer/issues/7560
Fixes https://github.com/rust-lang/rust-analyzer/issues/12153

Sync handlers cannot be cancelled

Auto merge of #12435 - jhgg:vscode/status-bar-color-fix, r=Veykril

[editors/vscode] cleaer status bar bg color / command  when server status returns to OK

fixes #12433

[editors/vscode] cleaer status bar bg color / command  when server status returns to OK

fix: Fix completions disappearing when typing two keys in quick succession

Auto merge of #12430 - Veykril:completions, r=Veykril

minor: Remove unused code

minor: Remove unused code

Auto merge of #12427 - Veykril:configfix, r=Veykril

fix: Fix VSCode config patching incorrectly patching some configs

fix: Fix VSCode config patching incorrectly patching some configs

Auto merge of #12336 - bitgaoshu:mismatch, r=flodiebold

fix: #12267  type-mismatch when using equals w/ a trait bound

Auto merge of #12425 - feniljain:fix_bugs, r=lnicola

fix: float display impl

should solve #12414

fix: float display impl

fix(extract_module): Remove redundancy causing else, and also add import fix loop for names

Auto merge of #12418 - Veykril:completions, r=Veykril

internal: More precise completion filtering with existing item qualifiers

Now we are approaching the more complex cases for filtering completions

More precise completion filtering

Auto merge of #12417 - jonas-schievink:pr-msg-style, r=jonas-schievink

minor: Update commit/PR style guide

What matters for the changelog is having PR title/description from the user's perspective, while commits can be internal.

Update commit/PR style

Use char for trigger character

Auto merge of #12416 - Veykril:inlay-hints, r=Veykril

Add implicit static lifetime hints

Add implicit static lifetime hints

Auto merge of #12406 - harpsword:fix-add-inlayHints-closures-without-block, r=Veykril

fix: add an option to show inlay hint for return type of closures wit…

fix #12321

Auto merge of #12387 - 00nktk:fix-mod-rename, r=Veykril

fix(ide-db): correct single-file module rename

Fixes a bug where rust-analyzer would emit `WorkspaceEdit`s with paths to dirs instead of files for the following project layout.

lib.rs
```rust
mod foo;
```

foo.rs
```rust
mod bar {
    struct Bar;
}
```
Also fixes emitted paths for modules with mod.rs.
The bug resulted in panic in helix editor when attempting to rename a module.

Auto merge of #12412 - yue4u:fix/visibility-completion, r=Veykril

fix: Retrigger visibility completion after parentheses

close #12390

This PR add `(` to trigger_characters as discussed in original issue.

Some questions:

1. Is lsp's `ctx.trigger_character` from `params.context` is the same as `ctx.original_token` inside actually completions?
    1. If not what's the difference?
    2. if they are the same, it's unnecessary to pass it down from handler at all.
    3.  if they are the same, maybe we could parse it from fixture directly instead of using the `check_with_trigger_character` I added.
2. Some completion fixtures written as `($0)` ( https://github.com/rust-lang/rust-analyzer/blob/master/crates/ide-completion/src/tests/fn_param.rs#L105 as an example), If I understand correctly they are not invoked outside tests at all?
    1. using `ctx.original_token` directly would break these tests as well as parsing trigger_character from fixture for now.
    2. I think it make sense to allow `(` triggering these cases?
3. I hope this line up with #12144

fix: visibility completion

Auto merge of #12409 - lowr:fix/usize-overflow, r=Veykril

fix overflow during type inference for tuple struct patterns

The following code causes integer overflow during type inference for (malformed) tuple struct patterns.

```rust
struct S(usize);
let S(.., a, b) = S(1);
```

It has been panicking only in debug builds, and working in a way in release builds but it was inconsistent with type inference for tuple patterns:

```rust
struct S(usize);
let S(.., a, b) = S(1); // a -> unknown, b -> usize
let (.., a, b) = (1,);  // a -> usize, b -> unknown
```

With this PR, the overflow no longer happens by utilizing `saturating_sub()` like in other places and type inference for tuple struct patterns is in line with that for tuple patterns.

fix overflow during tuple struct type inference

fix: add an option to show inlay hint for return type of closures without block

fix(ide-db): correct single-file module rename

Cleanup auto-import ordering

Addresses issues raised by @Veykril in #12333

Auto merge of #12402 - Veykril:feat-docs, r=Veykril

minor: Freshen up goto feature docs

Fixes https://github.com/rust-lang/rust-analyzer/issues/2541

minor: Freshen up goto feature docs