20 files changed, 268 insertions, 231 deletions

diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
index 79574b9ac..11c171fc2 100644
--- a/crates/assists/src/assist_context.rs
+++ b/crates/assists/src/assist_context.rs
@@ -6,6 +6,7 @@ use algo::find_covering_element;
 use base_db::{FileId, FileRange};
 use hir::Semantics;
 use ide_db::{
+    label::Label,
     source_change::{SourceChange, SourceFileEdit},
     RootDatabase,
 };
@@ -157,8 +158,9 @@ impl Assists {
         if !self.is_allowed(&id) {
             return None;
         }
-        let label = Assist::new(id, label.into(), None, target);
-        self.add_impl(label, f)
+        let label = Label::new(label.into());
+        let assist = Assist { id, label, group: None, target };
+        self.add_impl(assist, f)
     }
 
     pub(crate) fn add_group(
@@ -172,12 +174,12 @@ impl Assists {
         if !self.is_allowed(&id) {
             return None;
         }
-
-        let label = Assist::new(id, label.into(), Some(group.clone()), target);
-        self.add_impl(label, f)
+        let label = Label::new(label.into());
+        let assist = Assist { id, label, group: Some(group.clone()), target };
+        self.add_impl(assist, f)
     }
 
-    fn add_impl(&mut self, label: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
+    fn add_impl(&mut self, assist: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
         let source_change = if self.resolve {
             let mut builder = AssistBuilder::new(self.file);
             f(&mut builder);
@@ -186,7 +188,7 @@ impl Assists {
             None
         };
 
-        self.buf.push((label, source_change));
+        self.buf.push((assist, source_change));
         Some(())
     }
 
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index c589b08dc..14834480a 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -19,7 +19,7 @@ pub mod ast_transform;
 
 use base_db::FileRange;
 use hir::Semantics;
-use ide_db::{source_change::SourceChange, RootDatabase};
+use ide_db::{label::Label, source_change::SourceChange, RootDatabase};
 use syntax::TextRange;
 
 pub(crate) use crate::assist_context::{AssistContext, Assists};
@@ -68,7 +68,7 @@ pub struct GroupLabel(pub String);
 pub struct Assist {
     pub id: AssistId,
     /// Short description of the assist, as shown in the UI.
-    label: String,
+    pub label: Label,
     pub group: Option<GroupLabel>,
     /// Target ranges are used to sort assists: the smaller the target range,
     /// the more specific assist is, and so it should be sorted first.
@@ -82,11 +82,6 @@ pub struct ResolvedAssist {
 }
 
 impl Assist {
-    fn new(id: AssistId, label: String, group: Option<GroupLabel>, target: TextRange) -> Assist {
-        assert!(label.starts_with(char::is_uppercase));
-        Assist { id, label, group, target }
-    }
-
     /// Return all the assists applicable at the given position.
     ///
     /// Assists are returned in the "unresolved" state, that is only labels are
@@ -118,10 +113,6 @@ impl Assist {
         });
         acc.finish_resolved()
     }
-
-    pub fn label(&self) -> &str {
-        self.label.as_str()
-    }
 }
 
 mod handlers {
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index c7723de00..3e19d9117 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -2,7 +2,7 @@
 
 use std::any::Any;
 
-use hir_expand::diagnostics::Diagnostic;
+use hir_expand::diagnostics::{Diagnostic, DiagnosticCode};
 use syntax::{ast, AstPtr, SyntaxNodePtr};
 
 use hir_expand::{HirFileId, InFile};
@@ -15,8 +15,8 @@ pub struct UnresolvedModule {
 }
 
 impl Diagnostic for UnresolvedModule {
-    fn name(&self) -> &'static str {
-        "unresolved-module"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-module")
     }
     fn message(&self) -> String {
         "unresolved module".to_string()
diff --git a/crates/hir_expand/src/diagnostics.rs b/crates/hir_expand/src/diagnostics.rs
index 6c81b2501..78ccc212c 100644
--- a/crates/hir_expand/src/diagnostics.rs
+++ b/crates/hir_expand/src/diagnostics.rs
@@ -20,8 +20,17 @@ use syntax::SyntaxNodePtr;
 
 use crate::InFile;
 
+#[derive(Copy, Clone, PartialEq)]
+pub struct DiagnosticCode(pub &'static str);
+
+impl DiagnosticCode {
+    pub fn as_str(&self) -> &str {
+        self.0
+    }
+}
+
 pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
-    fn name(&self) -> &'static str;
+    fn code(&self) -> DiagnosticCode;
     fn message(&self) -> String;
     /// Used in highlighting and related purposes
     fn display_source(&self) -> InFile<SyntaxNodePtr>;
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 38fa24ee0..9ba005fab 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -6,7 +6,7 @@ mod unsafe_check;
 use std::any::Any;
 
 use hir_def::DefWithBodyId;
-use hir_expand::diagnostics::{Diagnostic, DiagnosticSink};
+use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{name::Name, HirFileId, InFile};
 use stdx::format_to;
 use syntax::{ast, AstPtr, SyntaxNodePtr};
@@ -32,8 +32,8 @@ pub struct NoSuchField {
 }
 
 impl Diagnostic for NoSuchField {
-    fn name(&self) -> &'static str {
-        "no-such-field"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("no-such-field")
     }
 
     fn message(&self) -> String {
@@ -58,8 +58,8 @@ pub struct MissingFields {
 }
 
 impl Diagnostic for MissingFields {
-    fn name(&self) -> &'static str {
-        "missing-structure-fields"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-structure-fields")
     }
     fn message(&self) -> String {
         let mut buf = String::from("Missing structure fields:\n");
@@ -94,8 +94,8 @@ pub struct MissingPatFields {
 }
 
 impl Diagnostic for MissingPatFields {
-    fn name(&self) -> &'static str {
-        "missing-pat-fields"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-pat-fields")
     }
     fn message(&self) -> String {
         let mut buf = String::from("Missing structure fields:\n");
@@ -127,8 +127,8 @@ pub struct MissingMatchArms {
 }
 
 impl Diagnostic for MissingMatchArms {
-    fn name(&self) -> &'static str {
-        "missing-match-arm"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-match-arm")
     }
     fn message(&self) -> String {
         String::from("Missing match arm")
@@ -148,8 +148,8 @@ pub struct MissingOkInTailExpr {
 }
 
 impl Diagnostic for MissingOkInTailExpr {
-    fn name(&self) -> &'static str {
-        "missing-ok-in-tail-expr"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-ok-in-tail-expr")
     }
     fn message(&self) -> String {
         "wrap return expression in Ok".to_string()
@@ -169,8 +169,8 @@ pub struct BreakOutsideOfLoop {
 }
 
 impl Diagnostic for BreakOutsideOfLoop {
-    fn name(&self) -> &'static str {
-        "break-outside-of-loop"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("break-outside-of-loop")
     }
     fn message(&self) -> String {
         "break outside of loop".to_string()
@@ -190,8 +190,8 @@ pub struct MissingUnsafe {
 }
 
 impl Diagnostic for MissingUnsafe {
-    fn name(&self) -> &'static str {
-        "missing-unsafe"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-unsafe")
     }
     fn message(&self) -> String {
         format!("This operation is unsafe and requires an unsafe function or block")
@@ -213,8 +213,8 @@ pub struct MismatchedArgCount {
 }
 
 impl Diagnostic for MismatchedArgCount {
-    fn name(&self) -> &'static str {
-        "mismatched-arg-count"
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("mismatched-arg-count")
     }
     fn message(&self) -> String {
         let s = if self.expected == 1 { "" } else { "s" };
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index c953925ec..91c9d38c5 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -8,7 +8,7 @@ mod method_resolution;
 mod macros;
 mod display_source_code;
 
-use std::sync::Arc;
+use std::{env, sync::Arc};
 
 use base_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt};
 use expect::Expect;
@@ -22,12 +22,14 @@ use hir_def::{
     AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
-use stdx::format_to;
+use stdx::{format_to, RacyFlag};
 use syntax::{
     algo,
     ast::{self, AstNode},
     SyntaxNode,
 };
+use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry};
+use tracing_tree::HierarchicalLayer;
 
 use crate::{
     db::HirDatabase, display::HirDisplay, infer::TypeMismatch, test_db::TestDB, InferenceResult, Ty,
@@ -37,9 +39,12 @@ use crate::{
 // against snapshots of the expected results using expect. Use
 // `env UPDATE_EXPECT=1 cargo test -p hir_ty` to update the snapshots.
 
-fn setup_tracing() -> tracing::subscriber::DefaultGuard {
-    use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry};
-    use tracing_tree::HierarchicalLayer;
+fn setup_tracing() -> Option<tracing::subscriber::DefaultGuard> {
+    static ENABLE: RacyFlag = RacyFlag::new();
+    if !ENABLE.get(|| env::var("CHALK_DEBUG").is_ok()) {
+        return None;
+    }
+
     let filter = EnvFilter::from_env("CHALK_DEBUG");
     let layer = HierarchicalLayer::default()
         .with_indent_lines(true)
@@ -47,7 +52,7 @@ fn setup_tracing() -> tracing::subscriber::DefaultGuard {
         .with_indent_amount(2)
         .with_writer(std::io::stderr);
     let subscriber = Registry::default().with(filter).with(layer);
-    tracing::subscriber::set_default(subscriber)
+    Some(tracing::subscriber::set_default(subscriber))
 }
 
 fn check_types(ra_fixture: &str) {
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 606a6064b..92b5adaa2 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -4,22 +4,48 @@
 //! macro-expanded files, but we need to present them to the users in terms of
 //! original files. So we need to map the ranges.
 
-use std::{cell::RefCell, collections::HashSet};
+mod fixes;
+
+use std::cell::RefCell;
 
 use base_db::SourceDatabase;
 use hir::{diagnostics::DiagnosticSinkBuilder, Semantics};
 use ide_db::RootDatabase;
 use itertools::Itertools;
+use rustc_hash::FxHashSet;
 use syntax::{
     ast::{self, AstNode},
     SyntaxNode, TextRange, T,
 };
 use text_edit::TextEdit;
 
-use crate::{Diagnostic, FileId, Fix, SourceFileEdit};
+use crate::{FileId, Label, SourceChange, SourceFileEdit};
+
+use self::fixes::DiagnosticWithFix;
+
+#[derive(Debug)]
+pub struct Diagnostic {
+    // pub name: Option<String>,
+    pub message: String,
+    pub range: TextRange,
+    pub severity: Severity,
+    pub fix: Option<Fix>,
+}
 
-mod diagnostics_with_fix;
-use diagnostics_with_fix::DiagnosticWithFix;
+#[derive(Debug)]
+pub struct Fix {
+    pub label: Label,
+    pub source_change: SourceChange,
+    /// Allows to trigger the fix only when the caret is in the range given
+    pub fix_trigger_range: TextRange,
+}
+
+impl Fix {
+    fn new(label: &str, source_change: SourceChange, fix_trigger_range: TextRange) -> Self {
+        let label = Label::new(label);
+        Self { label, source_change, fix_trigger_range }
+    }
+}
 
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
@@ -27,11 +53,16 @@ pub enum Severity {
     WeakWarning,
 }
 
+#[derive(Default, Debug, Clone)]
+pub struct DiagnosticsConfig {
+    pub disable_experimental: bool,
+    pub disabled: FxHashSet<String>,
+}
+
 pub(crate) fn diagnostics(
     db: &RootDatabase,
+    config: &DiagnosticsConfig,
     file_id: FileId,
-    enable_experimental: bool,
-    disabled_diagnostics: Option<HashSet<String>>,
 ) -> Vec<Diagnostic> {
     let _p = profile::span("diagnostics");
     let sema = Semantics::new(db);
@@ -40,7 +71,7 @@ pub(crate) fn diagnostics(
 
     // [#34344] Only take first 128 errors to prevent slowing down editor/ide, the number 128 is chosen arbitrarily.
     res.extend(parse.errors().iter().take(128).map(|err| Diagnostic {
-        name: None,
+        // name: None,
         range: err.range(),
         message: format!("Syntax Error: {}", err),
         severity: Severity::Error,
@@ -52,7 +83,7 @@ pub(crate) fn diagnostics(
         check_struct_shorthand_initialization(&mut res, file_id, &node);
     }
     let res = RefCell::new(res);
-    let mut sink_builder = DiagnosticSinkBuilder::new()
+    let sink_builder = DiagnosticSinkBuilder::new()
         .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
             res.borrow_mut().push(diagnostic_with_fix(d, &sema));
         })
@@ -66,19 +97,15 @@ pub(crate) fn diagnostics(
             res.borrow_mut().push(diagnostic_with_fix(d, &sema));
         })
         // Only collect experimental diagnostics when they're enabled.
-        .filter(|diag| !diag.is_experimental() || enable_experimental);
-
-    if let Some(disabled_diagnostics) = disabled_diagnostics {
-        // Do not collect disabled diagnostics.
-        sink_builder = sink_builder.filter(move |diag| !disabled_diagnostics.contains(diag.name()));
-    }
+        .filter(|diag| !(diag.is_experimental() && config.disable_experimental))
+        .filter(|diag| !config.disabled.contains(diag.code().as_str()));
 
     // Finalize the `DiagnosticSink` building process.
     let mut sink = sink_builder
         // Diagnostics not handled above get no fix and default treatment.
         .build(|d| {
             res.borrow_mut().push(Diagnostic {
-                name: Some(d.name().into()),
+                // name: Some(d.name().into()),
                 message: d.message(),
                 range: sema.diagnostics_display_range(d).range,
                 severity: Severity::Error,
@@ -95,7 +122,7 @@ pub(crate) fn diagnostics(
 
 fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
     Diagnostic {
-        name: Some(d.name().into()),
+        // name: Some(d.name().into()),
         range: sema.diagnostics_display_range(d).range,
         message: d.message(),
         severity: Severity::Error,
@@ -122,7 +149,7 @@ fn check_unnecessary_braces_in_use_statement(
                 });
 
         acc.push(Diagnostic {
-            name: None,
+            // name: None,
             range: use_range,
             message: "Unnecessary braces in use statement".to_string(),
             severity: Severity::WeakWarning,
@@ -169,7 +196,7 @@ fn check_struct_shorthand_initialization(
 
                 let field_range = record_field.syntax().text_range();
                 acc.push(Diagnostic {
-                    name: None,
+                    // name: None,
                     range: field_range,
                     message: "Shorthand struct initialization".to_string(),
                     severity: Severity::WeakWarning,
@@ -187,12 +214,14 @@ fn check_struct_shorthand_initialization(
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashSet;
+    use expect::{expect, Expect};
     use stdx::trim_indent;
     use test_utils::assert_eq_text;
 
-    use crate::mock_analysis::{analysis_and_position, single_file, MockAnalysis};
-    use expect::{expect, Expect};
+    use crate::{
+        mock_analysis::{analysis_and_position, single_file, MockAnalysis},
+        DiagnosticsConfig,
+    };
 
     /// Takes a multi-file input fixture with annotated cursor positions,
     /// and checks that:
@@ -203,8 +232,11 @@ mod tests {
         let after = trim_indent(ra_fixture_after);
 
         let (analysis, file_position) = analysis_and_position(ra_fixture_before);
-        let diagnostic =
-            analysis.diagnostics(file_position.file_id, true, None).unwrap().pop().unwrap();
+        let diagnostic = analysis
+            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .unwrap()
+            .pop()
+            .unwrap();
         let mut fix = diagnostic.fix.unwrap();
         let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
         let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
@@ -230,7 +262,11 @@ mod tests {
         let ra_fixture_after = &trim_indent(ra_fixture_after);
         let (analysis, file_pos) = analysis_and_position(ra_fixture_before);
         let current_file_id = file_pos.file_id;
-        let diagnostic = analysis.diagnostics(current_file_id, true, None).unwrap().pop().unwrap();
+        let diagnostic = analysis
+            .diagnostics(&DiagnosticsConfig::default(), current_file_id)
+            .unwrap()
+            .pop()
+            .unwrap();
         let mut fix = diagnostic.fix.unwrap();
         let edit = fix.source_change.source_file_edits.pop().unwrap();
         let changed_file_id = edit.file_id;
@@ -251,58 +287,16 @@ mod tests {
         let analysis = mock.analysis();
         let diagnostics = files
             .into_iter()
-            .flat_map(|file_id| analysis.diagnostics(file_id, true, None).unwrap())
-            .collect::<Vec<_>>();
-        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
-    }
-
-    /// Takes a multi-file input fixture with annotated cursor position and the list of disabled diagnostics,
-    /// and checks that provided diagnostics aren't spawned during analysis.
-    fn check_disabled_diagnostics(ra_fixture: &str, disabled_diagnostics: &[&'static str]) {
-        let disabled_diagnostics: HashSet<_> =
-            disabled_diagnostics.into_iter().map(|diag| diag.to_string()).collect();
-
-        let mock = MockAnalysis::with_files(ra_fixture);
-        let files = mock.files().map(|(it, _)| it).collect::<Vec<_>>();
-        let analysis = mock.analysis();
-
-        let diagnostics = files
-            .clone()
-            .into_iter()
             .flat_map(|file_id| {
-                analysis.diagnostics(file_id, true, Some(disabled_diagnostics.clone())).unwrap()
+                analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
             })
             .collect::<Vec<_>>();
-
-        // First, we have to check that diagnostic is not emitted when it's added to the disabled diagnostics list.
-        for diagnostic in diagnostics {
-            if let Some(name) = diagnostic.name {
-                assert!(!disabled_diagnostics.contains(&name), "Diagnostic {} is disabled", name);
-            }
-        }
-
-        // Then, we must reset the config and repeat the check, so that we'll be sure that without
-        // config these diagnostics are emitted.
-        // This is required for tests to not become outdated if e.g. diagnostics name changes:
-        // without this additional run the test will pass simply because a diagnostic with an old name
-        // will no longer exist.
-        let diagnostics = files
-            .into_iter()
-            .flat_map(|file_id| analysis.diagnostics(file_id, true, None).unwrap())
-            .collect::<Vec<_>>();
-
-        assert!(
-            diagnostics
-                .into_iter()
-                .filter_map(|diag| diag.name)
-                .any(|name| disabled_diagnostics.contains(&name)),
-            "At least one of the diagnostics was not emitted even without config; are the diagnostics names correct?"
-        );
+        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
     }
 
     fn check_expect(ra_fixture: &str, expect: Expect) {
         let (analysis, file_id) = single_file(ra_fixture);
-        let diagnostics = analysis.diagnostics(file_id, true, None).unwrap();
+        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
         expect.assert_debug_eq(&diagnostics)
     }
 
@@ -562,9 +556,6 @@ fn test_fn() {
             expect![[r#"
                 [
                     Diagnostic {
-                        name: Some(
-                            "unresolved-module",
-                        ),
                         message: "unresolved module",
                         range: 0..8,
                         severity: Error,
@@ -741,6 +732,15 @@ struct Foo {
 
     #[test]
     fn test_disabled_diagnostics() {
-        check_disabled_diagnostics(r#"mod foo;"#, &["unresolved-module"]);
+        let mut config = DiagnosticsConfig::default();
+        config.disabled.insert("unresolved-module".into());
+
+        let (analysis, file_id) = single_file(r#"mod foo;"#);
+
+        let diagnostics = analysis.diagnostics(&config, file_id).unwrap();
+        assert!(diagnostics.is_empty());
+
+        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        assert!(!diagnostics.is_empty());
     }
 }
diff --git a/crates/ide/src/diagnostics/diagnostics_with_fix.rs b/crates/ide/src/diagnostics/fixes.rs
index 85b46c995..68ae1c239 100644
--- a/crates/ide/src/diagnostics/diagnostics_with_fix.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -1,7 +1,5 @@
 //! Provides a way to attach fixes to the diagnostics.
 //! The same module also has all curret custom fixes for the diagnostics implemented.
-use crate::Fix;
-use ast::{edit::IndentLevel, make};
 use base_db::FileId;
 use hir::{
     db::AstDatabase,
@@ -12,9 +10,15 @@ use ide_db::{
     source_change::{FileSystemEdit, SourceFileEdit},
     RootDatabase,
 };
-use syntax::{algo, ast, AstNode};
+use syntax::{
+    algo,
+    ast::{self, edit::IndentLevel, make},
+    AstNode,
+};
 use text_edit::TextEdit;
 
+use crate::diagnostics::Fix;
+
 /// A [Diagnostic] that potentially has a fix available.
 ///
 /// [Diagnostic]: hir::diagnostics::Diagnostic
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 4b797f374..e3af6d5bc 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -44,7 +44,7 @@ mod syntax_highlighting;
 mod syntax_tree;
 mod typing;
 
-use std::{collections::HashSet, sync::Arc};
+use std::sync::Arc;
 
 use base_db::{
     salsa::{self, ParallelDatabase},
@@ -65,7 +65,7 @@ pub use crate::{
     completion::{
         CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
     },
-    diagnostics::Severity,
+    diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
     display::NavigationTarget,
     expand_macro::ExpandedMacro,
     file_structure::StructureNode,
@@ -88,6 +88,7 @@ pub use base_db::{
 pub use hir::{Documentation, Semantics};
 pub use ide_db::{
     change::AnalysisChange,
+    label::Label,
     line_index::{LineCol, LineIndex},
     search::SearchScope,
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
@@ -99,35 +100,6 @@ pub use text_edit::{Indel, TextEdit};
 
 pub type Cancelable<T> = Result<T, Canceled>;
 
-#[derive(Debug)]
-pub struct Diagnostic {
-    pub name: Option<String>,
-    pub message: String,
-    pub range: TextRange,
-    pub severity: Severity,
-    pub fix: Option<Fix>,
-}
-
-#[derive(Debug)]
-pub struct Fix {
-    pub label: String,
-    pub source_change: SourceChange,
-    /// Allows to trigger the fix only when the caret is in the range given
-    pub fix_trigger_range: TextRange,
-}
-
-impl Fix {
-    pub fn new(
-        label: impl Into<String>,
-        source_change: SourceChange,
-        fix_trigger_range: TextRange,
-    ) -> Self {
-        let label = label.into();
-        assert!(label.starts_with(char::is_uppercase) && !label.ends_with('.'));
-        Self { label, source_change, fix_trigger_range }
-    }
-}
-
 /// Info associated with a text range.
 #[derive(Debug)]
 pub struct RangeInfo<T> {
@@ -148,7 +120,7 @@ pub struct AnalysisHost {
 }
 
 impl AnalysisHost {
-    pub fn new(lru_capacity: Option<usize>) -> Self {
+    pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
         AnalysisHost { db: RootDatabase::new(lru_capacity) }
     }
 
@@ -495,13 +467,10 @@ impl Analysis {
     /// Computes the set of diagnostics for the given file.
     pub fn diagnostics(
         &self,
+        config: &DiagnosticsConfig,
         file_id: FileId,
-        enable_experimental: bool,
-        disabled_diagnostics: Option<HashSet<String>>,
     ) -> Cancelable<Vec<Diagnostic>> {
-        self.with_db(|db| {
-            diagnostics::diagnostics(db, file_id, enable_experimental, disabled_diagnostics)
-        })
+        self.with_db(|db| diagnostics::diagnostics(db, config, file_id))
     }
 
     /// Returns the edit required to rename reference at the position to the new
diff --git a/crates/ide_db/src/label.rs b/crates/ide_db/src/label.rs
new file mode 100644
index 000000000..c0e89e72f
--- /dev/null
+++ b/crates/ide_db/src/label.rs
@@ -0,0 +1,49 @@
+//! See `Label`
+use std::fmt;
+
+/// A type to specify UI label, like an entry in the list of assists. Enforces
+/// proper casing:
+///
+///    Frobnicate bar
+///
+/// Note the upper-case first letter and the absence of `.` at the end.
+#[derive(Clone)]
+pub struct Label(String);
+
+impl PartialEq<str> for Label {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == other
+    }
+}
+
+impl PartialEq<&'_ str> for Label {
+    fn eq(&self, other: &&str) -> bool {
+        self == *other
+    }
+}
+
+impl From<Label> for String {
+    fn from(label: Label) -> String {
+        label.0
+    }
+}
+
+impl Label {
+    pub fn new(label: impl Into<String>) -> Label {
+        let label = label.into();
+        assert!(label.starts_with(char::is_uppercase) && !label.ends_with('.'));
+        Label(label)
+    }
+}
+
+impl fmt::Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl fmt::Debug for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
diff --git a/crates/ide_db/src/lib.rs b/crates/ide_db/src/lib.rs
index fd474cd0f..70ada02f3 100644
--- a/crates/ide_db/src/lib.rs
+++ b/crates/ide_db/src/lib.rs
@@ -2,6 +2,7 @@
 //!
 //! It is mainly a `HirDatabase` for semantic analysis, plus a `SymbolsDatabase`, for fuzzy search.
 
+pub mod label;
 pub mod line_index;
 pub mod symbol_index;
 pub mod change;
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 43f0196af..c312e0a2e 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -7,7 +7,10 @@ use base_db::{
     salsa::{Database, Durability},
     FileId,
 };
-use ide::{Analysis, AnalysisChange, AnalysisHost, CompletionConfig, FilePosition, LineCol};
+use ide::{
+    Analysis, AnalysisChange, AnalysisHost, CompletionConfig, DiagnosticsConfig, FilePosition,
+    LineCol,
+};
 use vfs::AbsPathBuf;
 
 use crate::{
@@ -71,7 +74,7 @@ impl BenchCmd {
         match &self.what {
             BenchWhat::Highlight { .. } => {
                 let res = do_work(&mut host, file_id, |analysis| {
-                    analysis.diagnostics(file_id, true, None).unwrap();
+                    analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
                     analysis.highlight_as_html(file_id, false).unwrap()
                 });
                 if verbosity.is_verbose() {
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 31eb7ff3f..c424aa6e2 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -8,7 +8,7 @@ use rustc_hash::FxHashSet;
 
 use base_db::SourceDatabaseExt;
 use hir::Crate;
-use ide::Severity;
+use ide::{DiagnosticsConfig, Severity};
 
 use crate::cli::{load_cargo::load_cargo, Result};
 
@@ -47,7 +47,8 @@ pub fn diagnostics(
                 String::from("unknown")
             };
             println!("processing crate: {}, module: {}", crate_name, _vfs.file_path(file_id));
-            for diagnostic in analysis.diagnostics(file_id, true, None).unwrap() {
+            for diagnostic in analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
+            {
                 if matches!(diagnostic.severity, Severity::Error) {
                     found_error = true;
                 }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 44fd7c286..99f7751ac 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -7,24 +7,25 @@
 //! configure the server itself, feature flags are passed into analysis, and
 //! tweak things like automatic insertion of `()` in completions.
 
-use std::{collections::HashSet, ffi::OsString, path::PathBuf};
+use std::{ffi::OsString, path::PathBuf};
 
 use flycheck::FlycheckConfig;
-use ide::{AssistConfig, CompletionConfig, HoverConfig, InlayHintsConfig};
+use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
 use lsp_types::ClientCapabilities;
 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest};
+use rustc_hash::FxHashSet;
 use serde::Deserialize;
 use vfs::AbsPathBuf;
 
-use crate::diagnostics::DiagnosticsConfig;
+use crate::diagnostics::DiagnosticsMapConfig;
 
 #[derive(Debug, Clone)]
 pub struct Config {
     pub client_caps: ClientCapsConfig,
 
     pub publish_diagnostics: bool,
-    pub experimental_diagnostics: bool,
     pub diagnostics: DiagnosticsConfig,
+    pub diagnostics_map: DiagnosticsMapConfig,
     pub lru_capacity: Option<usize>,
     pub proc_macro_srv: Option<(PathBuf, Vec<OsString>)>,
     pub files: FilesConfig,
@@ -45,14 +46,6 @@ pub struct Config {
     pub with_sysroot: bool,
     pub linked_projects: Vec<LinkedProject>,
     pub root_path: AbsPathBuf,
-
-    pub analysis: AnalysisConfig,
-}
-
-/// Configuration parameters for the analysis run.
-#[derive(Debug, Default, Clone)]
-pub struct AnalysisConfig {
-    pub disabled_diagnostics: HashSet<String>,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -146,8 +139,8 @@ impl Config {
 
             with_sysroot: true,
             publish_diagnostics: true,
-            experimental_diagnostics: true,
             diagnostics: DiagnosticsConfig::default(),
+            diagnostics_map: DiagnosticsMapConfig::default(),
             lru_capacity: None,
             proc_macro_srv: None,
             files: FilesConfig { watcher: FilesWatcher::Notify, exclude: Vec::new() },
@@ -184,8 +177,6 @@ impl Config {
             hover: HoverConfig::default(),
             linked_projects: Vec::new(),
             root_path,
-
-            analysis: AnalysisConfig::default(),
         }
     }
 
@@ -200,8 +191,11 @@ impl Config {
 
         self.with_sysroot = data.withSysroot;
         self.publish_diagnostics = data.diagnostics_enable;
-        self.experimental_diagnostics = data.diagnostics_enableExperimental;
         self.diagnostics = DiagnosticsConfig {
+            disable_experimental: !data.diagnostics_enableExperimental,
+            disabled: data.diagnostics_disabled,
+        };
+        self.diagnostics_map = DiagnosticsMapConfig {
             warnings_as_info: data.diagnostics_warningsAsInfo,
             warnings_as_hint: data.diagnostics_warningsAsHint,
         };
@@ -303,8 +297,6 @@ impl Config {
             goto_type_def: data.hoverActions_enable && data.hoverActions_gotoTypeDef,
         };
 
-        self.analysis = AnalysisConfig { disabled_diagnostics: data.analysis_disabledDiagnostics };
-
         log::info!("Config::update() = {:#?}", self);
     }
 
@@ -369,14 +361,6 @@ impl Config {
             self.client_caps.status_notification = get_bool("statusNotification");
         }
     }
-
-    pub fn disabled_diagnostics(&self) -> Option<HashSet<String>> {
-        if self.analysis.disabled_diagnostics.is_empty() {
-            None
-        } else {
-            Some(self.analysis.disabled_diagnostics.clone())
-        }
-    }
 }
 
 #[derive(Deserialize)]
@@ -434,6 +418,7 @@ config_data! {
 
         diagnostics_enable: bool                = true,
         diagnostics_enableExperimental: bool    = true,
+        diagnostics_disabled: FxHashSet<String> = FxHashSet::default(),
         diagnostics_warningsAsHint: Vec<String> = Vec::new(),
         diagnostics_warningsAsInfo: Vec<String> = Vec::new(),
 
@@ -464,7 +449,5 @@ config_data! {
         rustfmt_overrideCommand: Option<Vec<String>> = None,
 
         withSysroot: bool = true,
-
-        analysis_disabledDiagnostics: HashSet<String> = HashSet::new(),
     }
 }
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index 108df3eb0..ee6f2a867 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -11,7 +11,7 @@ use crate::lsp_ext;
 pub(crate) type CheckFixes = Arc<FxHashMap<FileId, Vec<Fix>>>;
 
 #[derive(Debug, Default, Clone)]
-pub struct DiagnosticsConfig {
+pub struct DiagnosticsMapConfig {
     pub warnings_as_info: Vec<String>,
     pub warnings_as_hint: Vec<String>,
 }
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 6d5408156..df5583897 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -7,11 +7,11 @@ use stdx::format_to;
 
 use crate::{lsp_ext, to_proto::url_from_abs_path};
 
-use super::DiagnosticsConfig;
+use super::DiagnosticsMapConfig;
 
 /// Determines the LSP severity from a diagnostic
 fn diagnostic_severity(
-    config: &DiagnosticsConfig,
+    config: &DiagnosticsMapConfig,
     level: flycheck::DiagnosticLevel,
     code: Option<flycheck::DiagnosticCode>,
 ) -> Option<lsp_types::DiagnosticSeverity> {
@@ -141,7 +141,7 @@ pub(crate) struct MappedRustDiagnostic {
 ///
 /// If the diagnostic has no primary span this will return `None`
 pub(crate) fn map_rust_diagnostic_to_lsp(
-    config: &DiagnosticsConfig,
+    config: &DiagnosticsMapConfig,
     rd: &flycheck::Diagnostic,
     workspace_root: &Path,
 ) -> Vec<MappedRustDiagnostic> {
@@ -259,10 +259,10 @@ mod tests {
     use expect::{expect_file, ExpectFile};
 
     fn check(diagnostics_json: &str, expect: ExpectFile) {
-        check_with_config(DiagnosticsConfig::default(), diagnostics_json, expect)
+        check_with_config(DiagnosticsMapConfig::default(), diagnostics_json, expect)
     }
 
-    fn check_with_config(config: DiagnosticsConfig, diagnostics_json: &str, expect: ExpectFile) {
+    fn check_with_config(config: DiagnosticsMapConfig, diagnostics_json: &str, expect: ExpectFile) {
         let diagnostic: flycheck::Diagnostic = serde_json::from_str(diagnostics_json).unwrap();
         let workspace_root = Path::new("/test/");
         let actual = map_rust_diagnostic_to_lsp(&config, &diagnostic, workspace_root);
@@ -402,9 +402,9 @@ mod tests {
     #[cfg(not(windows))]
     fn rustc_unused_variable_as_info() {
         check_with_config(
-            DiagnosticsConfig {
+            DiagnosticsMapConfig {
                 warnings_as_info: vec!["unused_variables".to_string()],
-                ..DiagnosticsConfig::default()
+                ..DiagnosticsMapConfig::default()
             },
             r##"{
     "message": "unused variable: `foo`",
@@ -486,9 +486,9 @@ mod tests {
     #[cfg(not(windows))]
     fn rustc_unused_variable_as_hint() {
         check_with_config(
-            DiagnosticsConfig {
+            DiagnosticsMapConfig {
                 warnings_as_hint: vec!["unused_variables".to_string()],
-                ..DiagnosticsConfig::default()
+                ..DiagnosticsMapConfig::default()
             },
             r##"{
     "message": "unused variable: `foo`",
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 4f77b1b4d..33e60b500 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -271,24 +271,24 @@ pub(crate) fn handle_document_symbol(
         };
         parents.push((doc_symbol, symbol.parent));
     }
-    let mut document_symbols = Vec::new();
-    // Constructs `document_symbols` from `parents`, in order from the end.
-    while let Some((node, parent)) = parents.pop() {
-        match parent {
-            None => document_symbols.push(node),
-            Some(i) => {
-                parents[i].0.children.get_or_insert_with(Vec::new).push(node);
-            }
-        }
-    }
 
-    fn reverse(symbols: &mut Vec<DocumentSymbol>) {
-        for sym in symbols.iter_mut() {
-            sym.children.as_mut().map(|c| reverse(c));
+    // Builds hierarchy from a flat list, in reverse order (so that indices
+    // makes sense)
+    let document_symbols = {
+        let mut acc = Vec::new();
+        while let Some((mut node, parent_idx)) = parents.pop() {
+            if let Some(children) = &mut node.children {
+                children.reverse();
+            }
+            let parent = match parent_idx {
+                None => &mut acc,
+                Some(i) => parents[i].0.children.get_or_insert_with(Vec::new),
+            };
+            parent.push(node);
         }
-        symbols.reverse();
-    }
-    reverse(&mut document_symbols);
+        acc.reverse();
+        acc
+    };
 
     let res = if snap.config.client_caps.hierarchical_symbols {
         document_symbols.into()
@@ -775,21 +775,16 @@ fn handle_fixes(
         None => {}
     };
 
-    let diagnostics = snap.analysis.diagnostics(
-        file_id,
-        snap.config.experimental_diagnostics,
-        snap.config.disabled_diagnostics(),
-    )?;
+    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics, file_id)?;
 
     for fix in diagnostics
         .into_iter()
         .filter_map(|d| d.fix)
         .filter(|fix| fix.fix_trigger_range.intersect(range).is_some())
     {
-        let title = fix.label;
         let edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
         let action = lsp_ext::CodeAction {
-            title,
+            title: fix.label.to_string(),
             id: None,
             group: None,
             kind: Some(CodeActionKind::QUICKFIX),
@@ -1051,13 +1046,10 @@ pub(crate) fn publish_diagnostics(
 ) -> Result<Vec<Diagnostic>> {
     let _p = profile::span("publish_diagnostics");
     let line_index = snap.analysis.file_line_index(file_id)?;
+
     let diagnostics: Vec<Diagnostic> = snap
         .analysis
-        .diagnostics(
-            file_id,
-            snap.config.experimental_diagnostics,
-            snap.config.disabled_diagnostics(),
-        )?
+        .diagnostics(&snap.config.diagnostics, file_id)?
         .into_iter()
         .map(|d| Diagnostic {
             range: to_proto::range(&line_index, d.range),
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 66e04653a..f039cdc31 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -248,7 +248,7 @@ impl GlobalState {
             Event::Flycheck(task) => match task {
                 flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
                     let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
-                        &self.config.diagnostics,
+                        &self.config.diagnostics_map,
                         &diagnostic,
                         &workspace_root,
                     );
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 535de2f71..643dcb4fc 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -704,7 +704,7 @@ pub(crate) fn unresolved_code_action(
     index: usize,
 ) -> Result<lsp_ext::CodeAction> {
     let res = lsp_ext::CodeAction {
-        title: assist.label().to_string(),
+        title: assist.label.to_string(),
         id: Some(format!("{}:{}", assist.id.0, index.to_string())),
         group: assist.group.filter(|_| snap.config.client_caps.code_action_group).map(|gr| gr.0),
         kind: Some(code_action_kind(assist.id.1)),
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 265d19288..5d60f0219 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -1,5 +1,8 @@
 //! Missing batteries for standard libraries.
-use std::time::Instant;
+use std::{
+    sync::atomic::{AtomicUsize, Ordering},
+    time::Instant,
+};
 
 mod macros;
 
@@ -134,6 +137,31 @@ where
     left
 }
 
+pub struct RacyFlag(AtomicUsize);
+
+impl RacyFlag {
+    pub const fn new() -> RacyFlag {
+        RacyFlag(AtomicUsize::new(0))
+    }
+
+    pub fn get(&self, init: impl FnMut() -> bool) -> bool {
+        let mut init = Some(init);
+        self.get_impl(&mut || init.take().map_or(false, |mut f| f()))
+    }
+
+    fn get_impl(&self, init: &mut dyn FnMut() -> bool) -> bool {
+        match self.0.load(Ordering::Relaxed) {
+            0 => false,
+            1 => true,
+            _ => {
+                let res = init();
+                self.0.store(if res { 1 } else { 0 }, Ordering::Relaxed);
+                res
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;