2 files changed, 99 insertions, 9 deletions

diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 1046d7ab3..79dbb0865 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -17,7 +17,7 @@ use ra_syntax::{
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
 
-use crate::{Diagnostic, FileId, Fix, SourceFileEdit};
+use crate::{AnalysisConfig, Diagnostic, FileId, Fix, SourceFileEdit};
 
 mod diagnostics_with_fix;
 use diagnostics_with_fix::DiagnosticWithFix;
@@ -32,6 +32,7 @@ pub(crate) fn diagnostics(
     db: &RootDatabase,
     file_id: FileId,
     enable_experimental: bool,
+    analysis_config: &AnalysisConfig,
 ) -> Vec<Diagnostic> {
     let _p = profile("diagnostics");
     let sema = Semantics::new(db);
@@ -40,6 +41,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,
         range: err.range(),
         message: format!("Syntax Error: {}", err),
         severity: Severity::Error,
@@ -51,7 +53,7 @@ pub(crate) fn diagnostics(
         check_struct_shorthand_initialization(&mut res, file_id, &node);
     }
     let res = RefCell::new(res);
-    let mut sink = DiagnosticSinkBuilder::new()
+    let mut sink_builder = DiagnosticSinkBuilder::new()
         .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
             res.borrow_mut().push(diagnostic_with_fix(d, &sema));
         })
@@ -65,10 +67,20 @@ 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)
+        .filter(|diag| !diag.is_experimental() || enable_experimental);
+
+    if !analysis_config.disabled_diagnostics.is_empty() {
+        // Do not collect disabled diagnostics.
+        sink_builder =
+            sink_builder.filter(|diag| !analysis_config.disabled_diagnostics.contains(diag.name()));
+    }
+
+    // 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()),
                 message: d.message(),
                 range: sema.diagnostics_display_range(d).range,
                 severity: Severity::Error,
@@ -85,6 +97,7 @@ pub(crate) fn diagnostics(
 
 fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
     Diagnostic {
+        name: Some(d.name().into()),
         range: sema.diagnostics_display_range(d).range,
         message: d.message(),
         severity: Severity::Error,
@@ -111,6 +124,7 @@ fn check_unnecessary_braces_in_use_statement(
                 });
 
         acc.push(Diagnostic {
+            name: None,
             range: use_range,
             message: "Unnecessary braces in use statement".to_string(),
             severity: Severity::WeakWarning,
@@ -157,6 +171,7 @@ fn check_struct_shorthand_initialization(
 
                 let field_range = record_field.syntax().text_range();
                 acc.push(Diagnostic {
+                    name: None,
                     range: field_range,
                     message: "Shorthand struct initialization".to_string(),
                     severity: Severity::WeakWarning,
@@ -174,10 +189,14 @@ fn check_struct_shorthand_initialization(
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashSet;
     use stdx::trim_indent;
     use test_utils::assert_eq_text;
 
-    use crate::mock_analysis::{analysis_and_position, single_file, MockAnalysis};
+    use crate::{
+        mock_analysis::{analysis_and_position, single_file, MockAnalysis},
+        AnalysisConfig,
+    };
     use expect::{expect, Expect};
 
     /// Takes a multi-file input fixture with annotated cursor positions,
@@ -241,6 +260,51 @@ mod tests {
         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 mut analysis = mock.analysis();
+        analysis.set_config(AnalysisConfig { disabled_diagnostics: disabled_diagnostics.clone() });
+
+        let diagnostics = files
+            .clone()
+            .into_iter()
+            .flat_map(|file_id| analysis.diagnostics(file_id, true).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.
+        analysis.set_config(AnalysisConfig { disabled_diagnostics: Default::default() });
+
+        let diagnostics = files
+            .into_iter()
+            .flat_map(|file_id| analysis.diagnostics(file_id, true).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?"
+        );
+    }
+
     fn check_expect(ra_fixture: &str, expect: Expect) {
         let (analysis, file_id) = single_file(ra_fixture);
         let diagnostics = analysis.diagnostics(file_id, true).unwrap();
@@ -503,6 +567,9 @@ fn test_fn() {
             expect![[r#"
                 [
                     Diagnostic {
+                        name: Some(
+                            "unresolved-module",
+                        ),
                         message: "unresolved module",
                         range: 0..8,
                         severity: Error,
@@ -676,4 +743,9 @@ struct Foo {
             ",
         )
     }
+
+    #[test]
+    fn test_disabled_diagnostics() {
+        check_disabled_diagnostics(r#"mod foo;"#, &["unresolved-module"]);
+    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 89fcb6f17..2cbd7e4f0 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -45,7 +45,7 @@ mod syntax_highlighting;
 mod syntax_tree;
 mod typing;
 
-use std::sync::Arc;
+use std::{collections::HashSet, sync::Arc};
 
 use ra_cfg::CfgOptions;
 use ra_db::{
@@ -100,8 +100,15 @@ pub use ra_text_edit::{Indel, TextEdit};
 
 pub type Cancelable<T> = Result<T, Canceled>;
 
+/// Configuration parameters for the analysis run.
+#[derive(Debug, Default, Clone)]
+pub struct AnalysisConfig {
+    pub disabled_diagnostics: HashSet<String>,
+}
+
 #[derive(Debug)]
 pub struct Diagnostic {
+    pub name: Option<String>,
     pub message: String,
     pub range: TextRange,
     pub severity: Severity,
@@ -145,11 +152,16 @@ impl<T> RangeInfo<T> {
 #[derive(Debug)]
 pub struct AnalysisHost {
     db: RootDatabase,
+    config: AnalysisConfig,
 }
 
 impl AnalysisHost {
-    pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
-        AnalysisHost { db: RootDatabase::new(lru_capacity) }
+    pub fn new(lru_capacity: Option<usize>) -> Self {
+        Self::with_config(lru_capacity, AnalysisConfig::default())
+    }
+
+    pub fn with_config(lru_capacity: Option<usize>, config: AnalysisConfig) -> Self {
+        AnalysisHost { db: RootDatabase::new(lru_capacity), config }
     }
 
     pub fn update_lru_capacity(&mut self, lru_capacity: Option<usize>) {
@@ -159,7 +171,7 @@ impl AnalysisHost {
     /// Returns a snapshot of the current state, which you can query for
     /// semantic information.
     pub fn analysis(&self) -> Analysis {
-        Analysis { db: self.db.snapshot() }
+        Analysis { db: self.db.snapshot(), config: self.config.clone() }
     }
 
     /// Applies changes to the current state of the world. If there are
@@ -203,6 +215,7 @@ impl Default for AnalysisHost {
 #[derive(Debug)]
 pub struct Analysis {
     db: salsa::Snapshot<RootDatabase>,
+    config: AnalysisConfig,
 }
 
 // As a general design guideline, `Analysis` API are intended to be independent
@@ -498,7 +511,7 @@ impl Analysis {
         file_id: FileId,
         enable_experimental: bool,
     ) -> Cancelable<Vec<Diagnostic>> {
-        self.with_db(|db| diagnostics::diagnostics(db, file_id, enable_experimental))
+        self.with_db(|db| diagnostics::diagnostics(db, file_id, enable_experimental, &self.config))
     }
 
     /// Returns the edit required to rename reference at the position to the new
@@ -524,6 +537,11 @@ impl Analysis {
         })
     }
 
+    /// Sets the provided config.
+    pub fn set_config(&mut self, config: AnalysisConfig) {
+        self.config = config;
+    }
+
     /// Performs an operation on that may be Canceled.
     fn with_db<F: FnOnce(&RootDatabase) -> T + std::panic::UnwindSafe, T>(
         &self,