18 files changed, 323 insertions, 250 deletions

diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 4f0b4a62e..9a883acb9 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -84,6 +84,7 @@ pub struct DiagnosticsConfig {
 pub(crate) fn diagnostics(
     db: &RootDatabase,
     config: &DiagnosticsConfig,
+    resolve: bool,
     file_id: FileId,
 ) -> Vec<Diagnostic> {
     let _p = profile::span("diagnostics");
@@ -107,25 +108,25 @@ pub(crate) fn diagnostics(
     let res = RefCell::new(res);
     let sink_builder = DiagnosticSinkBuilder::new()
         .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::MissingFields, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::NoSuchField, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::RemoveThisSemicolon, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::IncorrectCase, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema));
+            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema));
+            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
         })
         .on::<hir::diagnostics::InactiveCode, _>(|d| {
             // If there's inactive code somewhere in a macro, don't propagate to the call-site.
@@ -152,7 +153,7 @@ pub(crate) fn diagnostics(
             // Override severity and mark as unused.
             res.borrow_mut().push(
                 Diagnostic::hint(range, d.message())
-                    .with_fix(d.fix(&sema))
+                    .with_fix(d.fix(&sema, resolve))
                     .with_code(Some(d.code())),
             );
         })
@@ -208,15 +209,23 @@ pub(crate) fn diagnostics(
     res.into_inner()
 }
 
-fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+fn diagnostic_with_fix<D: DiagnosticWithFix>(
+    d: &D,
+    sema: &Semantics<RootDatabase>,
+    resolve: bool,
+) -> Diagnostic {
     Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema))
+        .with_fix(d.fix(&sema, resolve))
         .with_code(Some(d.code()))
 }
 
-fn warning_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+fn warning_with_fix<D: DiagnosticWithFix>(
+    d: &D,
+    sema: &Semantics<RootDatabase>,
+    resolve: bool,
+) -> Diagnostic {
     Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema))
+        .with_fix(d.fix(&sema, resolve))
         .with_code(Some(d.code()))
 }
 
@@ -271,13 +280,19 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
 }
 
 fn fix(id: &'static str, label: &str, source_change: SourceChange, target: TextRange) -> Assist {
+    let mut res = unresolved_fix(id, label, target);
+    res.source_change = Some(source_change);
+    res
+}
+
+fn unresolved_fix(id: &'static str, label: &str, target: TextRange) -> Assist {
     assert!(!id.contains(' '));
     Assist {
         id: AssistId(id, AssistKind::QuickFix),
         label: Label::new(label),
         group: None,
         target,
-        source_change: Some(source_change),
+        source_change: None,
     }
 }
 
@@ -299,7 +314,7 @@ mod tests {
 
         let (analysis, file_position) = fixture::position(ra_fixture_before);
         let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
             .unwrap()
             .pop()
             .unwrap();
@@ -328,7 +343,7 @@ mod tests {
     fn check_no_fix(ra_fixture: &str) {
         let (analysis, file_position) = fixture::position(ra_fixture);
         let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
             .unwrap()
             .pop()
             .unwrap();
@@ -342,7 +357,7 @@ mod tests {
         let diagnostics = files
             .into_iter()
             .flat_map(|file_id| {
-                analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
+                analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap()
             })
             .collect::<Vec<_>>();
         assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
@@ -350,7 +365,8 @@ mod tests {
 
     fn check_expect(ra_fixture: &str, expect: Expect) {
         let (analysis, file_id) = fixture::file(ra_fixture);
-        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap();
         expect.assert_debug_eq(&diagnostics)
     }
 
@@ -895,10 +911,11 @@ struct Foo {
 
         let (analysis, file_id) = fixture::file(r#"mod foo;"#);
 
-        let diagnostics = analysis.diagnostics(&config, file_id).unwrap();
+        let diagnostics = analysis.diagnostics(&config, true, file_id).unwrap();
         assert!(diagnostics.is_empty());
 
-        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap();
         assert!(!diagnostics.is_empty());
     }
 
@@ -1004,8 +1021,9 @@ impl TestStruct {
         let expected = r#"fn foo() {}"#;
 
         let (analysis, file_position) = fixture::position(input);
-        let diagnostics =
-            analysis.diagnostics(&DiagnosticsConfig::default(), file_position.file_id).unwrap();
+        let diagnostics = analysis
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
+            .unwrap();
         assert_eq!(diagnostics.len(), 1);
 
         check_fix(input, expected);
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 69cf5288c..7be8b3459 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -20,17 +20,26 @@ use syntax::{
 };
 use text_edit::TextEdit;
 
-use crate::{diagnostics::fix, references::rename::rename_with_semantics, Assist, FilePosition};
+use crate::{
+    diagnostics::{fix, unresolved_fix},
+    references::rename::rename_with_semantics,
+    Assist, FilePosition,
+};
 
 /// A [Diagnostic] that potentially has a fix available.
 ///
 /// [Diagnostic]: hir::diagnostics::Diagnostic
 pub(crate) trait DiagnosticWithFix: Diagnostic {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist>;
+    /// `resolve` determines if the diagnostic should fill in the `edit` field
+    /// of the assist.
+    ///
+    /// If `resolve` is false, the edit will be computed later, on demand, and
+    /// can be omitted.
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist>;
 }
 
 impl DiagnosticWithFix for UnresolvedModule {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         let root = sema.db.parse_or_expand(self.file)?;
         let unresolved_module = self.decl.to_node(&root);
         Some(fix(
@@ -50,7 +59,7 @@ impl DiagnosticWithFix for UnresolvedModule {
 }
 
 impl DiagnosticWithFix for NoSuchField {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         let root = sema.db.parse_or_expand(self.file)?;
         missing_record_expr_field_fix(
             &sema,
@@ -61,7 +70,7 @@ impl DiagnosticWithFix for NoSuchField {
 }
 
 impl DiagnosticWithFix for MissingFields {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         // Note that although we could add a diagnostics to
         // fill the missing tuple field, e.g :
         // `struct A(usize);`
@@ -97,7 +106,7 @@ impl DiagnosticWithFix for MissingFields {
 }
 
 impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         let root = sema.db.parse_or_expand(self.file)?;
         let tail_expr = self.expr.to_node(&root);
         let tail_expr_range = tail_expr.syntax().text_range();
@@ -110,7 +119,7 @@ impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
 }
 
 impl DiagnosticWithFix for RemoveThisSemicolon {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         let root = sema.db.parse_or_expand(self.file)?;
 
         let semicolon = self
@@ -130,7 +139,7 @@ impl DiagnosticWithFix for RemoveThisSemicolon {
 }
 
 impl DiagnosticWithFix for IncorrectCase {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, resolve: bool) -> Option<Assist> {
         let root = sema.db.parse_or_expand(self.file)?;
         let name_node = self.ident.to_node(&root);
 
@@ -138,16 +147,19 @@ impl DiagnosticWithFix for IncorrectCase {
         let frange = name_node.original_file_range(sema.db);
         let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
 
-        let rename_changes =
-            rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
-
         let label = format!("Rename to {}", self.suggested_text);
-        Some(fix("change_case", &label, rename_changes, frange.range))
+        let mut res = unresolved_fix("change_case", &label, frange.range);
+        if resolve {
+            let source_change = rename_with_semantics(sema, file_position, &self.suggested_text);
+            res.source_change = Some(source_change.ok().unwrap_or_default());
+        }
+
+        Some(res)
     }
 }
 
 impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         let root = sema.db.parse_or_expand(self.file)?;
         let next_expr = self.next_expr.to_node(&root);
         let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
index 5482b7287..7d39f4fbe 100644
--- a/crates/ide/src/diagnostics/unlinked_file.rs
+++ b/crates/ide/src/diagnostics/unlinked_file.rs
@@ -50,7 +50,7 @@ impl Diagnostic for UnlinkedFile {
 }
 
 impl DiagnosticWithFix for UnlinkedFile {
-    fn fix(&self, sema: &hir::Semantics<RootDatabase>) -> Option<Assist> {
+    fn fix(&self, sema: &hir::Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
         // If there's an existing module that could add a `mod` item to include the unlinked file,
         // suggest that as a fix.
 
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index d057d5402..a04333e63 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -110,6 +110,13 @@ mod tests {
         assert_eq!(expected, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() });
     }
 
+    fn check_unresolved(ra_fixture: &str) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let navs = analysis.goto_definition(position).unwrap().expect("no definition found").info;
+
+        assert!(navs.is_empty(), "didn't expect this to resolve anywhere: {:?}", navs)
+    }
+
     #[test]
     fn goto_def_for_extern_crate() {
         check(
@@ -927,17 +934,12 @@ fn f() -> impl Iterator<Item$0 = u8> {}
     }
 
     #[test]
-    #[should_panic = "unresolved reference"]
     fn unknown_assoc_ty() {
-        check(
+        check_unresolved(
             r#"
-trait Iterator {
-    type Item;
-       //^^^^
-}
-
+trait Iterator { type Item; }
 fn f() -> impl Iterator<Invalid$0 = u8> {}
-            "#,
+"#,
         )
     }
 
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 0615b26d3..d481be09d 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -526,9 +526,39 @@ impl Analysis {
     pub fn diagnostics(
         &self,
         config: &DiagnosticsConfig,
+        resolve: bool,
         file_id: FileId,
     ) -> Cancelable<Vec<Diagnostic>> {
-        self.with_db(|db| diagnostics::diagnostics(db, config, file_id))
+        self.with_db(|db| diagnostics::diagnostics(db, config, resolve, file_id))
+    }
+
+    /// Convenience function to return assists + quick fixes for diagnostics
+    pub fn assists_with_fixes(
+        &self,
+        assist_config: &AssistConfig,
+        diagnostics_config: &DiagnosticsConfig,
+        resolve: bool,
+        frange: FileRange,
+    ) -> Cancelable<Vec<Assist>> {
+        let include_fixes = match &assist_config.allowed {
+            Some(it) => it.iter().any(|&it| it == AssistKind::None || it == AssistKind::QuickFix),
+            None => true,
+        };
+
+        self.with_db(|db| {
+            let mut res = Assist::get(db, assist_config, resolve, frange);
+            ssr::add_ssr_assist(db, &mut res, resolve, frange);
+
+            if include_fixes {
+                res.extend(
+                    diagnostics::diagnostics(db, diagnostics_config, resolve, frange.file_id)
+                        .into_iter()
+                        .filter_map(|it| it.fix)
+                        .filter(|it| it.target.intersect(frange.range).is_some()),
+                );
+            }
+            res
+        })
     }
 
     /// Returns the edit required to rename reference at the position to the new
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index de2d22ac7..933cfa6f3 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -2,8 +2,7 @@ use std::time::Instant;
 
 use expect_test::{expect_file, ExpectFile};
 use ide_db::SymbolKind;
-use stdx::format_to;
-use test_utils::{bench, bench_fixture, skip_slow_tests};
+use test_utils::{bench, bench_fixture, skip_slow_tests, AssertLinear};
 
 use crate::{fixture, FileRange, HlTag, TextRange};
 
@@ -266,90 +265,27 @@ fn syntax_highlighting_not_quadratic() {
         return;
     }
 
-    let mut measures = Vec::new();
-    for i in 6..=10 {
-        let n = 1 << i;
-        let fixture = bench_fixture::big_struct_n(n);
-        let (analysis, file_id) = fixture::file(&fixture);
+    let mut al = AssertLinear::default();
+    while al.next_round() {
+        for i in 6..=10 {
+            let n = 1 << i;
 
-        let time = Instant::now();
+            let fixture = bench_fixture::big_struct_n(n);
+            let (analysis, file_id) = fixture::file(&fixture);
 
-        let hash = analysis
-            .highlight(file_id)
-            .unwrap()
-            .iter()
-            .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
-            .count();
-        assert!(hash > n as usize);
+            let time = Instant::now();
 
-        let elapsed = time.elapsed();
-        measures.push((n as f64, elapsed.as_millis() as f64))
-    }
+            let hash = analysis
+                .highlight(file_id)
+                .unwrap()
+                .iter()
+                .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
+                .count();
+            assert!(hash > n as usize);
 
-    assert_linear(&measures)
-}
-
-/// Checks that a set of measurements looks like a liner function rather than
-/// like a quadratic function. Algorithm:
-///
-/// 1. Linearly scale input to be in [0; 1)
-/// 2. Using linear regression, compute the best linear function approximating
-///    the input.
-/// 3. Compute RMSE and  maximal absolute error.
-/// 4. Check that errors are within tolerances and that the constant term is not
-///    too negative.
-///
-/// Ideally, we should use a proper "model selection" to directly compare
-/// quadratic and linear models, but that sounds rather complicated:
-///
-///     https://stats.stackexchange.com/questions/21844/selecting-best-model-based-on-linear-quadratic-and-cubic-fit-of-data
-fn assert_linear(xy: &[(f64, f64)]) {
-    let (mut xs, mut ys): (Vec<_>, Vec<_>) = xy.iter().copied().unzip();
-    normalize(&mut xs);
-    normalize(&mut ys);
-    let xy = xs.iter().copied().zip(ys.iter().copied());
-
-    // Linear regression: finding a and b to fit y = a + b*x.
-
-    let mean_x = mean(&xs);
-    let mean_y = mean(&ys);
-
-    let b = {
-        let mut num = 0.0;
-        let mut denom = 0.0;
-        for (x, y) in xy.clone() {
-            num += (x - mean_x) * (y - mean_y);
-            denom += (x - mean_x).powi(2);
+            let elapsed = time.elapsed();
+            al.sample(n as f64, elapsed.as_millis() as f64);
         }
-        num / denom
-    };
-
-    let a = mean_y - b * mean_x;
-
-    let mut plot = format!("y_pred = {:.3} + {:.3} * x\n\nx     y     y_pred\n", a, b);
-
-    let mut se = 0.0;
-    let mut max_error = 0.0f64;
-    for (x, y) in xy {
-        let y_pred = a + b * x;
-        se += (y - y_pred).powi(2);
-        max_error = max_error.max((y_pred - y).abs());
-
-        format_to!(plot, "{:.3} {:.3} {:.3}\n", x, y, y_pred);
-    }
-
-    let rmse = (se / xs.len() as f64).sqrt();
-    format_to!(plot, "\nrmse = {:.3} max error = {:.3}", rmse, max_error);
-
-    assert!(rmse < 0.05 && max_error < 0.1 && a > -0.1, "\nLooks quadratic\n{}", plot);
-
-    fn normalize(xs: &mut Vec<f64>) {
-        let max = xs.iter().copied().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap();
-        xs.iter_mut().for_each(|it| *it /= max);
-    }
-
-    fn mean(xs: &[f64]) -> f64 {
-        xs.iter().copied().sum::<f64>() / (xs.len() as f64)
     }
 }
 
diff --git a/crates/ide_assists/src/handlers/flip_comma.rs b/crates/ide_assists/src/handlers/flip_comma.rs
index 7f5e75d34..99be5e090 100644
--- a/crates/ide_assists/src/handlers/flip_comma.rs
+++ b/crates/ide_assists/src/handlers/flip_comma.rs
@@ -66,26 +66,12 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
     fn flip_comma_before_punct() {
         // See https://github.com/rust-analyzer/rust-analyzer/issues/1619
         // "Flip comma" assist shouldn't be applicable to the last comma in enum or struct
         // declaration body.
-        check_assist_target(
-            flip_comma,
-            "pub enum Test { \
-             A,$0 \
-             }",
-            ",",
-        );
-
-        check_assist_target(
-            flip_comma,
-            "pub struct Test { \
-             foo: usize,$0 \
-             }",
-            ",",
-        );
+        check_assist_not_applicable(flip_comma, "pub enum Test { A,$0 }");
+        check_assist_not_applicable(flip_comma, "pub struct Test { foo: usize,$0 }");
     }
 
     #[test]
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 3e2c82dac..3694f468f 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -28,7 +28,9 @@ pub use assist_config::AssistConfig;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AssistKind {
+    // FIXME: does the None variant make sense? Probably not.
     None,
+
     QuickFix,
     Generate,
     Refactor,
diff --git a/crates/rust-analyzer/build.rs b/crates/rust-analyzer/build.rs
index 999dc5928..13b903891 100644
--- a/crates/rust-analyzer/build.rs
+++ b/crates/rust-analyzer/build.rs
@@ -39,7 +39,8 @@ fn set_rerun() {
 }
 
 fn rev() -> Option<String> {
-    let output = Command::new("git").args(&["describe", "--tags"]).output().ok()?;
+    let output =
+        Command::new("git").args(&["describe", "--tags", "--exclude", "nightly"]).output().ok()?;
     let stdout = String::from_utf8(output.stdout).ok()?;
     Some(stdout)
 }
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 0085d0e4d..74f784338 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -57,7 +57,8 @@ pub fn diagnostics(
             let crate_name =
                 module.krate().display_name(db).as_deref().unwrap_or("unknown").to_string();
             println!("processing crate: {}, module: {}", crate_name, _vfs.file_path(file_id));
-            for diagnostic in analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
+            for diagnostic in
+                analysis.diagnostics(&DiagnosticsConfig::default(), false, file_id).unwrap()
             {
                 if matches!(diagnostic.severity, Severity::Error) {
                     found_error = true;
diff --git a/crates/rust-analyzer/src/from_proto.rs b/crates/rust-analyzer/src/from_proto.rs
index 5b02b2598..712d5a9c2 100644
--- a/crates/rust-analyzer/src/from_proto.rs
+++ b/crates/rust-analyzer/src/from_proto.rs
@@ -42,27 +42,27 @@ pub(crate) fn text_range(line_index: &LineIndex, range: lsp_types::Range) -> Tex
     TextRange::new(start, end)
 }
 
-pub(crate) fn file_id(world: &GlobalStateSnapshot, url: &lsp_types::Url) -> Result<FileId> {
-    world.url_to_file_id(url)
+pub(crate) fn file_id(snap: &GlobalStateSnapshot, url: &lsp_types::Url) -> Result<FileId> {
+    snap.url_to_file_id(url)
 }
 
 pub(crate) fn file_position(
-    world: &GlobalStateSnapshot,
+    snap: &GlobalStateSnapshot,
     tdpp: lsp_types::TextDocumentPositionParams,
 ) -> Result<FilePosition> {
-    let file_id = file_id(world, &tdpp.text_document.uri)?;
-    let line_index = world.file_line_index(file_id)?;
+    let file_id = file_id(snap, &tdpp.text_document.uri)?;
+    let line_index = snap.file_line_index(file_id)?;
     let offset = offset(&line_index, tdpp.position);
     Ok(FilePosition { file_id, offset })
 }
 
 pub(crate) fn file_range(
-    world: &GlobalStateSnapshot,
+    snap: &GlobalStateSnapshot,
     text_document_identifier: lsp_types::TextDocumentIdentifier,
     range: lsp_types::Range,
 ) -> Result<FileRange> {
-    let file_id = file_id(world, &text_document_identifier.uri)?;
-    let line_index = world.file_line_index(file_id)?;
+    let file_id = file_id(snap, &text_document_identifier.uri)?;
+    let line_index = snap.file_line_index(file_id)?;
     let range = text_range(&line_index, range);
     Ok(FileRange { file_id, range })
 }
@@ -82,7 +82,7 @@ pub(crate) fn assist_kind(kind: lsp_types::CodeActionKind) -> Option<AssistKind>
 }
 
 pub(crate) fn annotation(
-    world: &GlobalStateSnapshot,
+    snap: &GlobalStateSnapshot,
     code_lens: lsp_types::CodeLens,
 ) -> Result<Annotation> {
     let data = code_lens.data.unwrap();
@@ -91,25 +91,25 @@ pub(crate) fn annotation(
     match resolve {
         lsp_ext::CodeLensResolveData::Impls(params) => {
             let file_id =
-                world.url_to_file_id(&params.text_document_position_params.text_document.uri)?;
-            let line_index = world.file_line_index(file_id)?;
+                snap.url_to_file_id(&params.text_document_position_params.text_document.uri)?;
+            let line_index = snap.file_line_index(file_id)?;
 
             Ok(Annotation {
                 range: text_range(&line_index, code_lens.range),
                 kind: AnnotationKind::HasImpls {
-                    position: file_position(world, params.text_document_position_params)?,
+                    position: file_position(snap, params.text_document_position_params)?,
                     data: None,
                 },
             })
         }
         lsp_ext::CodeLensResolveData::References(params) => {
-            let file_id = world.url_to_file_id(&params.text_document.uri)?;
-            let line_index = world.file_line_index(file_id)?;
+            let file_id = snap.url_to_file_id(&params.text_document.uri)?;
+            let line_index = snap.file_line_index(file_id)?;
 
             Ok(Annotation {
                 range: text_range(&line_index, code_lens.range),
                 kind: AnnotationKind::HasReferences {
-                    position: file_position(world, params)?,
+                    position: file_position(snap, params)?,
                     data: None,
                 },
             })
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 107685c63..4f0c9d23c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -17,7 +17,7 @@ use lsp_server::ErrorCode;
 use lsp_types::{
     CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
     CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
-    CodeActionKind, CodeLens, CompletionItem, Diagnostic, DiagnosticTag, DocumentFormattingParams,
+    CodeLens, CompletionItem, Diagnostic, DiagnosticTag, DocumentFormattingParams,
     DocumentHighlight, FoldingRange, FoldingRangeParams, HoverContents, Location, NumberOrString,
     Position, PrepareRenameResponse, Range, RenameParams, SemanticTokensDeltaParams,
     SemanticTokensFullDeltaResult, SemanticTokensParams, SemanticTokensRangeParams,
@@ -36,7 +36,7 @@ use crate::{
     diff::diff,
     from_proto,
     global_state::{GlobalState, GlobalStateSnapshot},
-    line_index::{LineEndings, LineIndex},
+    line_index::LineEndings,
     lsp_ext::{self, InlayHint, InlayHintsParams},
     lsp_utils::all_edits_are_disjoint,
     to_proto, LspError, Result,
@@ -982,86 +982,52 @@ pub(crate) fn handle_code_action(
     params: lsp_types::CodeActionParams,
 ) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
     let _p = profile::span("handle_code_action");
-    // We intentionally don't support command-based actions, as those either
-    // requires custom client-code anyway, or requires server-initiated edits.
-    // Server initiated edits break causality, so we avoid those as well.
+
     if !snap.config.code_action_literals() {
+        // We intentionally don't support command-based actions, as those either
+        // require either custom client-code or server-initiated edits. Server
+        // initiated edits break causality, so we avoid those.
         return Ok(None);
     }
 
-    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
-    let line_index = snap.file_line_index(file_id)?;
-    let range = from_proto::text_range(&line_index, params.range);
-    let frange = FileRange { file_id, range };
+    let line_index =
+        snap.file_line_index(from_proto::file_id(&snap, &params.text_document.uri)?)?;
+    let frange = from_proto::file_range(&snap, params.text_document.clone(), params.range)?;
 
     let mut assists_config = snap.config.assist();
     assists_config.allowed = params
-        .clone()
         .context
         .only
+        .clone()
         .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
 
     let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
 
-    let include_quick_fixes = match &params.context.only {
-        Some(v) => v.iter().any(|it| {
-            it == &lsp_types::CodeActionKind::EMPTY || it == &lsp_types::CodeActionKind::QUICKFIX
-        }),
-        None => true,
-    };
-    if include_quick_fixes {
-        add_quick_fixes(&snap, frange, &line_index, &mut res)?;
-    }
-
-    if snap.config.code_action_resolve() {
-        for (index, assist) in
-            snap.analysis.assists(&assists_config, false, frange)?.into_iter().enumerate()
-        {
-            res.push(to_proto::unresolved_code_action(&snap, params.clone(), assist, index)?);
-        }
-    } else {
-        for assist in snap.analysis.assists(&assists_config, true, frange)?.into_iter() {
-            res.push(to_proto::resolved_code_action(&snap, assist)?);
-        }
-    }
-
-    Ok(Some(res))
-}
-
-fn add_quick_fixes(
-    snap: &GlobalStateSnapshot,
-    frange: FileRange,
-    line_index: &LineIndex,
-    acc: &mut Vec<lsp_ext::CodeAction>,
-) -> Result<()> {
-    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics(), frange.file_id)?;
-
-    for fix in diagnostics
-        .into_iter()
-        .filter_map(|d| d.fix)
-        .filter(|fix| fix.target.intersect(frange.range).is_some())
-    {
-        if let Some(source_change) = fix.source_change {
-            let edit = to_proto::snippet_workspace_edit(&snap, source_change)?;
-            let action = lsp_ext::CodeAction {
-                title: fix.label.to_string(),
-                group: None,
-                kind: Some(CodeActionKind::QUICKFIX),
-                edit: Some(edit),
-                is_preferred: Some(false),
-                data: None,
-            };
-            acc.push(action);
-        }
+    let code_action_resolve_cap = snap.config.code_action_resolve();
+    let assists = snap.analysis.assists_with_fixes(
+        &assists_config,
+        &snap.config.diagnostics(),
+        !code_action_resolve_cap,
+        frange,
+    )?;
+    for (index, assist) in assists.into_iter().enumerate() {
+        let resolve_data =
+            if code_action_resolve_cap { Some((index, params.clone())) } else { None };
+        let code_action = to_proto::code_action(&snap, assist, resolve_data)?;
+        res.push(code_action)
     }
 
+    // Fixes from `cargo check`.
     for fix in snap.check_fixes.get(&frange.file_id).into_iter().flatten() {
+        // FIXME: this mapping is awkward and shouldn't exist. Refactor
+        // `snap.check_fixes` to not convert to LSP prematurely.
         let fix_range = from_proto::text_range(&line_index, fix.range);
         if fix_range.intersect(frange.range).is_some() {
-            acc.push(fix.action.clone());
+            res.push(fix.action.clone());
         }
     }
-    Ok(())
+
+    Ok(Some(res))
 }
 
 pub(crate) fn handle_code_action_resolve(
@@ -1086,12 +1052,18 @@ pub(crate) fn handle_code_action_resolve(
         .only
         .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
 
-    let assists = snap.analysis.assists(&assists_config, true, frange)?;
+    let assists = snap.analysis.assists_with_fixes(
+        &assists_config,
+        &snap.config.diagnostics(),
+        true,
+        frange,
+    )?;
+
     let (id, index) = split_once(&params.id, ':').unwrap();
     let index = index.parse::<usize>().unwrap();
     let assist = &assists[index];
     assert!(assist.id.0 == id);
-    let edit = to_proto::resolved_code_action(&snap, assist.clone())?.edit;
+    let edit = to_proto::code_action(&snap, assist.clone(), None)?.edit;
     code_action.edit = edit;
     Ok(code_action)
 }
@@ -1210,7 +1182,7 @@ pub(crate) fn publish_diagnostics(
 
     let diagnostics: Vec<Diagnostic> = snap
         .analysis
-        .diagnostics(&snap.config.diagnostics(), file_id)?
+        .diagnostics(&snap.config.diagnostics(), false, file_id)?
         .into_iter()
         .map(|d| Diagnostic {
             range: to_proto::range(&line_index, d.range),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 9fac562ff..53852bfdc 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -843,40 +843,31 @@ pub(crate) fn code_action_kind(kind: AssistKind) -> lsp_types::CodeActionKind {
     }
 }
 
-pub(crate) fn unresolved_code_action(
+pub(crate) fn code_action(
     snap: &GlobalStateSnapshot,
-    code_action_params: lsp_types::CodeActionParams,
     assist: Assist,
-    index: usize,
+    resolve_data: Option<(usize, lsp_types::CodeActionParams)>,
 ) -> Result<lsp_ext::CodeAction> {
-    assert!(assist.source_change.is_none());
-    let res = lsp_ext::CodeAction {
+    let mut res = lsp_ext::CodeAction {
         title: assist.label.to_string(),
         group: assist.group.filter(|_| snap.config.code_action_group()).map(|gr| gr.0),
         kind: Some(code_action_kind(assist.id.1)),
         edit: None,
         is_preferred: None,
-        data: Some(lsp_ext::CodeActionData {
-            id: format!("{}:{}", assist.id.0, index.to_string()),
-            code_action_params,
-        }),
-    };
-    Ok(res)
-}
-
-pub(crate) fn resolved_code_action(
-    snap: &GlobalStateSnapshot,
-    assist: Assist,
-) -> Result<lsp_ext::CodeAction> {
-    let change = assist.source_change.unwrap();
-    let res = lsp_ext::CodeAction {
-        edit: Some(snippet_workspace_edit(snap, change)?),
-        title: assist.label.to_string(),
-        group: assist.group.filter(|_| snap.config.code_action_group()).map(|gr| gr.0),
-        kind: Some(code_action_kind(assist.id.1)),
-        is_preferred: None,
         data: None,
     };
+    match (assist.source_change, resolve_data) {
+        (Some(it), _) => res.edit = Some(snippet_workspace_edit(snap, it)?),
+        (None, Some((index, code_action_params))) => {
+            res.data = Some(lsp_ext::CodeActionData {
+                id: format!("{}:{}", assist.id.0, index.to_string()),
+                code_action_params,
+            });
+        }
+        (None, None) => {
+            stdx::never!("assist should always be resolved if client can't do lazy resolving")
+        }
+    };
     Ok(res)
 }
 
diff --git a/crates/rust-analyzer/tests/rust-analyzer/main.rs b/crates/rust-analyzer/tests/rust-analyzer/main.rs
index 1e4c04bbf..52a2674d5 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/main.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/main.rs
@@ -340,7 +340,6 @@ fn main() {}
                 }
               ]
             },
-            "isPreferred": false,
             "kind": "quickfix",
             "title": "Create module"
         }]),
@@ -411,7 +410,6 @@ fn main() {{}}
                 }
               ]
             },
-            "isPreferred": false,
             "kind": "quickfix",
             "title": "Create module"
         }]),
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index 5e388c0f0..75e677762 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -168,6 +168,7 @@ impl Server {
         self.send_notification(r)
     }
 
+    #[track_caller]
     pub(crate) fn request<R>(&self, params: R::Params, expected_resp: Value)
     where
         R: lsp_types::request::Request,
diff --git a/crates/test_utils/src/assert_linear.rs b/crates/test_utils/src/assert_linear.rs
new file mode 100644
index 000000000..6ecc232e1
--- /dev/null
+++ b/crates/test_utils/src/assert_linear.rs
@@ -0,0 +1,112 @@
+//! Checks that a set of measurements looks like a linear function rather than
+//! like a quadratic function. Algorithm:
+//!
+//! 1. Linearly scale input to be in [0; 1)
+//! 2. Using linear regression, compute the best linear function approximating
+//!    the input.
+//! 3. Compute RMSE and  maximal absolute error.
+//! 4. Check that errors are within tolerances and that the constant term is not
+//!    too negative.
+//!
+//! Ideally, we should use a proper "model selection" to directly compare
+//! quadratic and linear models, but that sounds rather complicated:
+//!
+//!     https://stats.stackexchange.com/questions/21844/selecting-best-model-based-on-linear-quadratic-and-cubic-fit-of-data
+//!
+//! We might get false positives on a VM, but never false negatives. So, if the
+//! first round fails, we repeat the ordeal three more times and fail only if
+//! every time there's a fault.
+use stdx::format_to;
+
+#[derive(Default)]
+pub struct AssertLinear {
+    rounds: Vec<Round>,
+}
+
+#[derive(Default)]
+struct Round {
+    samples: Vec<(f64, f64)>,
+    plot: String,
+    linear: bool,
+}
+
+impl AssertLinear {
+    pub fn next_round(&mut self) -> bool {
+        if let Some(round) = self.rounds.last_mut() {
+            round.finish();
+        }
+        if self.rounds.iter().any(|it| it.linear) || self.rounds.len() == 4 {
+            return false;
+        }
+        self.rounds.push(Round::default());
+        true
+    }
+
+    pub fn sample(&mut self, x: f64, y: f64) {
+        self.rounds.last_mut().unwrap().samples.push((x, y))
+    }
+}
+
+impl Drop for AssertLinear {
+    fn drop(&mut self) {
+        assert!(!self.rounds.is_empty());
+        if self.rounds.iter().all(|it| !it.linear) {
+            for round in &self.rounds {
+                eprintln!("\n{}", round.plot);
+            }
+            panic!("Doesn't look linear!")
+        }
+    }
+}
+
+impl Round {
+    fn finish(&mut self) {
+        let (mut xs, mut ys): (Vec<_>, Vec<_>) = self.samples.iter().copied().unzip();
+        normalize(&mut xs);
+        normalize(&mut ys);
+        let xy = xs.iter().copied().zip(ys.iter().copied());
+
+        // Linear regression: finding a and b to fit y = a + b*x.
+
+        let mean_x = mean(&xs);
+        let mean_y = mean(&ys);
+
+        let b = {
+            let mut num = 0.0;
+            let mut denom = 0.0;
+            for (x, y) in xy.clone() {
+                num += (x - mean_x) * (y - mean_y);
+                denom += (x - mean_x).powi(2);
+            }
+            num / denom
+        };
+
+        let a = mean_y - b * mean_x;
+
+        self.plot = format!("y_pred = {:.3} + {:.3} * x\n\nx     y     y_pred\n", a, b);
+
+        let mut se = 0.0;
+        let mut max_error = 0.0f64;
+        for (x, y) in xy {
+            let y_pred = a + b * x;
+            se += (y - y_pred).powi(2);
+            max_error = max_error.max((y_pred - y).abs());
+
+            format_to!(self.plot, "{:.3} {:.3} {:.3}\n", x, y, y_pred);
+        }
+
+        let rmse = (se / xs.len() as f64).sqrt();
+        format_to!(self.plot, "\nrmse = {:.3} max error = {:.3}", rmse, max_error);
+
+        self.linear = rmse < 0.05 && max_error < 0.1 && a > -0.1;
+
+        fn normalize(xs: &mut Vec<f64>) {
+            let max = xs.iter().copied().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap();
+            xs.iter_mut().for_each(|it| *it /= max);
+        }
+
+        fn mean(xs: &[f64]) -> f64 {
+            xs.iter().copied().sum::<f64>() / (xs.len() as f64)
+        }
+    }
+}
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index c5f859790..72466c957 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -8,6 +8,7 @@
 
 pub mod bench_fixture;
 mod fixture;
+mod assert_linear;
 
 use std::{
     convert::{TryFrom, TryInto},
@@ -22,7 +23,7 @@ use text_size::{TextRange, TextSize};
 pub use dissimilar::diff as __diff;
 pub use rustc_hash::FxHashMap;
 
-pub use crate::fixture::Fixture;
+pub use crate::{assert_linear::AssertLinear, fixture::Fixture};
 
 pub const CURSOR_MARKER: &str = "$0";
 pub const ESCAPED_CURSOR_MARKER: &str = "\\$0";
diff --git a/docs/dev/style.md b/docs/dev/style.md
index 468dedff2..7c47c26b2 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -152,6 +152,16 @@ Do not reuse marks between several tests.
 
 **Rationale:** marks provide an easy way to find the canonical test for each bit of code.
 This makes it much easier to understand.
+More than one mark per test / code branch doesn't add significantly to understanding.
+
+## `#[should_panic]`
+
+Do not use `#[should_panic]` tests.
+Instead, explicitly check for `None`, `Err`, etc.
+
+**Rationale:**a `#[should_panic]` is a tool for library authors, to makes sure that API does not fail silently, when misused.
+`rust-analyzer` is not a library, we don't need to test for API misuse, and we have to handle any user input without panics.
+Panic messages in the logs from the `#[should_panic]` tests are confusing.
 
 ## Function Preconditions