10 files changed, 123 insertions, 60 deletions

diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 00745238a..69b828f47 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -2,8 +2,8 @@ use hir::{
     Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
     HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
 };
-use ide_db::base_db::SourceDatabase;
 use ide_db::{
+    base_db::SourceDatabase,
     defs::{Definition, NameClass, NameRefClass},
     RootDatabase,
 };
@@ -94,7 +94,12 @@ pub(crate) fn hover(
     let node = token.parent();
     let definition = match_ast! {
         match node {
-            ast::Name(name) => NameClass::classify(&sema, &name).and_then(|d| d.defined(sema.db)),
+            // we don't use NameClass::referenced_or_defined here as we do not want to resolve
+            // field pattern shorthands to their definition
+            ast::Name(name) => NameClass::classify(&sema, &name).and_then(|class| match class {
+                NameClass::ConstReference(def) => Some(def),
+                def => def.defined(sema.db),
+            }),
             ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
             ast::Lifetime(lifetime) => NameClass::classify_lifetime(&sema, &lifetime)
                 .map_or_else(|| NameRefClass::classify_lifetime(&sema, &lifetime).map(|d| d.referenced(sema.db)), |d| d.defined(sema.db)),
@@ -3446,6 +3451,37 @@ impl<const LEN: usize> Foo<LEN$0> {}
     }
 
     #[test]
+    fn hover_const_pat() {
+        check(
+            r#"
+/// This is a doc
+const FOO: usize = 3;
+fn foo() {
+    match 5 {
+        FOO$0 => (),
+        _ => ()
+    }
+}
+"#,
+            expect![[r#"
+                *FOO*
+
+                ```rust
+                test
+                ```
+
+                ```rust
+                const FOO: usize = 3
+                ```
+
+                ---
+
+                This is a doc
+            "#]],
+        );
+    }
+
+    #[test]
     fn hover_mod_def() {
         check(
             r#"
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 42d0a38e8..4ceb20742 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -109,26 +109,31 @@ fn get_chaining_hints(
     // Chaining can be defined as an expression whose next sibling tokens are newline and dot
     // Ignoring extra whitespace and comments
     let next = tokens.next()?.kind();
-    let next_next = tokens.next()?.kind();
-    if next == SyntaxKind::WHITESPACE && next_next == T![.] {
-        let ty = sema.type_of_expr(&expr)?;
-        if ty.is_unknown() {
-            return None;
+    if next == SyntaxKind::WHITESPACE {
+        let mut next_next = tokens.next()?.kind();
+        while next_next == SyntaxKind::WHITESPACE {
+            next_next = tokens.next()?.kind();
         }
-        if matches!(expr, ast::Expr::PathExpr(_)) {
-            if let Some(hir::Adt::Struct(st)) = ty.as_adt() {
-                if st.fields(sema.db).is_empty() {
-                    return None;
+        if next_next == T![.] {
+            let ty = sema.type_of_expr(&expr)?;
+            if ty.is_unknown() {
+                return None;
+            }
+            if matches!(expr, ast::Expr::PathExpr(_)) {
+                if let Some(hir::Adt::Struct(st)) = ty.as_adt() {
+                    if st.fields(sema.db).is_empty() {
+                        return None;
+                    }
                 }
             }
+            acc.push(InlayHint {
+                range: expr.syntax().text_range(),
+                kind: InlayKind::ChainingHint,
+                label: hint_iterator(sema, &famous_defs, config, &ty).unwrap_or_else(|| {
+                    ty.display_truncated(sema.db, config.max_length).to_string().into()
+                }),
+            });
         }
-        acc.push(InlayHint {
-            range: expr.syntax().text_range(),
-            kind: InlayKind::ChainingHint,
-            label: hint_iterator(sema, &famous_defs, config, &ty).unwrap_or_else(|| {
-                ty.display_truncated(sema.db, config.max_length).to_string().into()
-            }),
-        });
     }
     Some(())
 }
@@ -983,6 +988,7 @@ struct C;
 fn main() {
     let c = A(B(C))
         .into_b() // This is a comment
+        // This is another comment
         .into_c();
 }
 "#,
diff --git a/crates/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index e6006a3c8..25606da60 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -10,9 +10,10 @@
 
 use crate::proc_macro::bridge::{self, server};
 
-use std::collections::{Bound, HashMap};
+use std::collections::HashMap;
 use std::hash::Hash;
 use std::iter::FromIterator;
+use std::ops::Bound;
 use std::str::FromStr;
 use std::{ascii, vec::IntoIter};
 
diff --git a/crates/rust-analyzer/src/cli.rs b/crates/rust-analyzer/src/cli.rs
index 6879a462d..ed732eb38 100644
--- a/crates/rust-analyzer/src/cli.rs
+++ b/crates/rust-analyzer/src/cli.rs
@@ -18,7 +18,7 @@ pub use self::{
     analysis_bench::{BenchCmd, BenchWhat, Position},
     analysis_stats::AnalysisStatsCmd,
     diagnostics::diagnostics,
-    load_cargo::load_cargo,
+    load_cargo::{load_workspace, load_workspace_at, LoadCargoConfig},
     ssr::{apply_ssr_rules, search_for_patterns},
 };
 
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 877abd12b..8991f3bdb 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -17,7 +17,7 @@ use ide_db::{
 use vfs::AbsPathBuf;
 
 use crate::cli::{
-    load_cargo::{load_cargo, LoadCargoConfig},
+    load_cargo::{load_workspace_at, LoadCargoConfig},
     print_memory_usage, Verbosity,
 };
 
@@ -63,13 +63,13 @@ impl BenchCmd {
         let start = Instant::now();
         eprint!("loading: ");
 
+        let cargo_config = Default::default();
         let load_cargo_config = LoadCargoConfig {
-            cargo_config: Default::default(),
             load_out_dirs_from_check: self.load_output_dirs,
             with_proc_macro: self.with_proc_macro,
         };
-
-        let (mut host, vfs) = load_cargo(&self.path, &load_cargo_config)?;
+        let (mut host, vfs) =
+            load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
         eprintln!("{:?}\n", start.elapsed());
 
         let file_id = {
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 6d6f398f4..9072d8944 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -25,7 +25,7 @@ use stdx::format_to;
 use syntax::AstNode;
 
 use crate::cli::{
-    load_cargo::{load_cargo, LoadCargoConfig},
+    load_cargo::{load_workspace_at, LoadCargoConfig},
     print_memory_usage,
     progress_report::ProgressReport,
     report_metric, Result, Verbosity,
@@ -59,12 +59,13 @@ impl AnalysisStatsCmd {
         };
 
         let mut db_load_sw = self.stop_watch();
+        let cargo_config = Default::default();
         let load_cargo_config = LoadCargoConfig {
-            cargo_config: Default::default(),
             load_out_dirs_from_check: self.load_output_dirs,
             with_proc_macro: self.with_proc_macro,
         };
-        let (host, vfs) = load_cargo(&self.path, &load_cargo_config)?;
+        let (host, vfs) =
+            load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
         let db = host.raw_database();
         eprintln!("{:<20} {}", "Database loaded:", db_load_sw.elapsed());
 
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index c60374c24..876f6c44f 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -11,7 +11,7 @@ use ide::{DiagnosticsConfig, Severity};
 use ide_db::base_db::SourceDatabaseExt;
 
 use crate::cli::{
-    load_cargo::{load_cargo, LoadCargoConfig},
+    load_cargo::{load_workspace_at, LoadCargoConfig},
     Result,
 };
 
@@ -33,12 +33,9 @@ pub fn diagnostics(
     load_out_dirs_from_check: bool,
     with_proc_macro: bool,
 ) -> Result<()> {
-    let load_cargo_config = LoadCargoConfig {
-        cargo_config: Default::default(),
-        load_out_dirs_from_check,
-        with_proc_macro,
-    };
-    let (host, _vfs) = load_cargo(path, &load_cargo_config)?;
+    let cargo_config = Default::default();
+    let load_cargo_config = LoadCargoConfig { load_out_dirs_from_check, with_proc_macro };
+    let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let analysis = host.analysis();
 
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index cf0cd81de..23442afac 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -14,16 +14,28 @@ use vfs::{loader::Handle, AbsPath, AbsPathBuf};
 use crate::reload::{ProjectFolders, SourceRootConfig};
 
 pub struct LoadCargoConfig {
-    pub cargo_config: CargoConfig,
     pub load_out_dirs_from_check: bool,
     pub with_proc_macro: bool,
 }
 
-pub fn load_cargo(root: &Path, config: &LoadCargoConfig) -> Result<(AnalysisHost, vfs::Vfs)> {
+pub fn load_workspace_at(
+    root: &Path,
+    cargo_config: &CargoConfig,
+    load_config: &LoadCargoConfig,
+    progress: &dyn Fn(String),
+) -> Result<(AnalysisHost, vfs::Vfs)> {
     let root = AbsPathBuf::assert(std::env::current_dir()?.join(root));
     let root = ProjectManifest::discover_single(&root)?;
-    let ws = ProjectWorkspace::load(root, &config.cargo_config, &|_| {})?;
+    let workspace = ProjectWorkspace::load(root, cargo_config, progress)?;
 
+    load_workspace(workspace, load_config, progress)
+}
+
+pub fn load_workspace(
+    ws: ProjectWorkspace,
+    config: &LoadCargoConfig,
+    progress: &dyn Fn(String),
+) -> Result<(AnalysisHost, vfs::Vfs)> {
     let (sender, receiver) = unbounded();
     let mut vfs = vfs::Vfs::default();
     let mut loader = {
@@ -42,7 +54,7 @@ pub fn load_cargo(root: &Path, config: &LoadCargoConfig) -> Result<(AnalysisHost
     let build_data = if config.load_out_dirs_from_check {
         let mut collector = BuildDataCollector::default();
         ws.collect_build_data_configs(&mut collector);
-        Some(collector.collect(&|_| {})?)
+        Some(collector.collect(progress)?)
     } else {
         None
     };
@@ -66,11 +78,12 @@ pub fn load_cargo(root: &Path, config: &LoadCargoConfig) -> Result<(AnalysisHost
     });
 
     log::debug!("crate graph: {:?}", crate_graph);
-    let host = load(crate_graph, project_folders.source_root_config, &mut vfs, &receiver);
+    let host =
+        load_crate_graph(crate_graph, project_folders.source_root_config, &mut vfs, &receiver);
     Ok((host, vfs))
 }
 
-fn load(
+fn load_crate_graph(
     crate_graph: CrateGraph,
     source_root_config: SourceRootConfig,
     vfs: &mut vfs::Vfs,
@@ -120,17 +133,17 @@ mod tests {
     use hir::Crate;
 
     #[test]
-    fn test_loading_rust_analyzer() {
+    fn test_loading_rust_analyzer() -> Result<()> {
         let path = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap();
-        let load_cargo_config = LoadCargoConfig {
-            cargo_config: Default::default(),
-            load_out_dirs_from_check: false,
-            with_proc_macro: false,
-        };
+        let cargo_config = Default::default();
+        let load_cargo_config =
+            LoadCargoConfig { load_out_dirs_from_check: false, with_proc_macro: false };
+        let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
 
-        let (host, _vfs) = load_cargo(path, &load_cargo_config).unwrap();
         let n_crates = Crate::all(host.raw_database()).len();
         // RA has quite a few crates, but the exact count doesn't matter
         assert!(n_crates > 20);
+
+        Ok(())
     }
 }
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
index 8729ff0d9..71c61ed58 100644
--- a/crates/rust-analyzer/src/cli/ssr.rs
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -1,19 +1,18 @@
 //! Applies structured search replace rules from the command line.
 
 use crate::cli::{
-    load_cargo::{load_cargo, LoadCargoConfig},
+    load_cargo::{load_workspace_at, LoadCargoConfig},
     Result,
 };
 use ssr::{MatchFinder, SsrPattern, SsrRule};
 
 pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
     use ide_db::base_db::SourceDatabaseExt;
-    let load_cargo_config = LoadCargoConfig {
-        cargo_config: Default::default(),
-        load_out_dirs_from_check: true,
-        with_proc_macro: true,
-    };
-    let (host, vfs) = load_cargo(&std::env::current_dir()?, &load_cargo_config)?;
+    let cargo_config = Default::default();
+    let load_cargo_config =
+        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
+    let (host, vfs) =
+        load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
     for rule in rules {
@@ -36,12 +35,11 @@ pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
 pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<String>) -> Result<()> {
     use ide_db::base_db::SourceDatabaseExt;
     use ide_db::symbol_index::SymbolsDatabase;
-    let load_cargo_config = LoadCargoConfig {
-        cargo_config: Default::default(),
-        load_out_dirs_from_check: true,
-        with_proc_macro: true,
-    };
-    let (host, _vfs) = load_cargo(&std::env::current_dir()?, &load_cargo_config)?;
+    let cargo_config = Default::default();
+    let load_cargo_config =
+        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
+    let (host, _vfs) =
+        load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
     for pattern in patterns {
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index ee6f2a867..f01548c50 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -65,6 +65,17 @@ impl DiagnosticCollection {
         file_id: FileId,
         diagnostics: Vec<lsp_types::Diagnostic>,
     ) {
+        if let Some(existing_diagnostics) = self.native.get(&file_id) {
+            if existing_diagnostics.len() == diagnostics.len()
+                && diagnostics
+                    .iter()
+                    .zip(existing_diagnostics)
+                    .all(|(new, existing)| are_diagnostics_equal(new, existing))
+            {
+                return;
+            }
+        }
+
         self.native.insert(file_id, diagnostics);
         self.changes.insert(file_id);
     }