[IMP] server: diagnostic filters configuration

Author: mmahrouss

server/src/core/config.rs

@@ -5,6 +5,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use std::{fs, path::Path};
 use itertools::Itertools;
+use glob::Pattern;
 use regex::Regex;
 use ruff_python_ast::{Expr, Mod};
 use ruff_python_parser::{Mode, ParseOptions};
@@ -89,7 +90,72 @@ impl Default for MergeMethod {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct DiagnosticFilter {
+    pub paths: Pattern,
+    pub codes: Vec<Regex>,
+    pub types: Vec<DiagnosticSetting>,
+    pub negation: bool,
+}
 
+impl<'de> serde::Deserialize<'de> for DiagnosticFilter {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(serde::Deserialize)]
+        struct Helper {
+            path: String,
+            #[serde(default)]
+            codes: Vec<String>,
+            #[serde(default)]
+            types: Vec<DiagnosticSetting>,
+        }
+        let helper = Helper::deserialize(deserializer)?;
+        let (path_str, negation) = if let Some(stripped) = helper.path.strip_prefix('!') {
+            (stripped, true)
+        } else {
+            (helper.path.as_str(), false)
+        };
+        let sanitized_path = PathBuf::from(path_str).sanitize();
+        let path_pattern = Pattern::new(&sanitized_path).map_err(serde::de::Error::custom)?;
+        let mut code_regexes = Vec::with_capacity(helper.codes.len());
+        for code in &helper.codes {
+            let regex = Regex::new(code).map_err(serde::de::Error::custom)?;
+            code_regexes.push(regex);
+        }
+        for t in &helper.types {
+            if let DiagnosticSetting::Disabled = t {
+                return Err(serde::de::Error::custom("DiagnosticFilter.types cannot contain 'Disabled'"));
+            }
+        }
+        Ok(DiagnosticFilter {
+            paths: path_pattern,
+            codes: code_regexes,
+            types: helper.types,
+            negation,
+        })
+    }
+}
+
+impl Serialize for DiagnosticFilter {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut s = serializer.serialize_struct("DiagnosticFilter", 3)?;
+        let mut path_str = self.paths.as_str().to_string();
+        if self.negation {
+            path_str = format!("!{}", path_str);
+        }
+        s.serialize_field("path", &path_str)?;
+        let codes: Vec<String> = self.codes.iter().map(|r| r.as_str().to_string()).collect();
+        s.serialize_field("codes", &codes)?;
+        s.serialize_field("types", &self.types)?;
+        s.end()
+    }
+}
 #[derive(Debug, Deserialize, Clone, Serialize)]
 pub struct ConfigFile {
     #[serde(default)]
@@ -239,7 +305,7 @@ impl ConfigFile {
                     "python_path", "additional_stubs", "additional_stubs_merge",
                     "refresh_mode", "file_cache", "diag_missing_imports",
                     "ac_filter_model_names", "auto_refresh_delay", "add_workspace_addon_path",
-                    "diagnostic_settings"
+                    "diagnostic_settings", "diagnostic_filters"
                 ];
                 for key in order {
                     if let Some(val) = map.get(key) {
@@ -525,6 +591,9 @@ pub struct ConfigEntryRaw {
     #[serde(default)]
     diagnostic_settings: HashMap<DiagnosticCode, Sourced<DiagnosticSetting>>,
 
+    #[serde(default)]
+    pub diagnostic_filters: Vec<Sourced<DiagnosticFilter>>,
+
     #[serde(skip_deserializing, rename(serialize = "abstract"))]
     abstract_: bool
 }
@@ -550,6 +619,7 @@ impl Default for ConfigEntryRaw {
             base: None,
             diagnostic_settings: Default::default(),
             abstract_: false,
+            diagnostic_filters: vec![],
         }
     }
 }
@@ -593,6 +663,7 @@ pub struct ConfigEntry {
     pub no_typeshed: bool,
     pub abstract_: bool,
     pub diagnostic_settings: HashMap<DiagnosticCode, DiagnosticSetting>,
+    pub diagnostic_filters: Vec<DiagnosticFilter>,
 }
 
 impl Default for ConfigEntry {
@@ -612,6 +683,7 @@ impl Default for ConfigEntry {
             no_typeshed: false,
             abstract_: false,
             diagnostic_settings: Default::default(),
+            diagnostic_filters: vec![],
         }
     }
 }
@@ -724,6 +796,9 @@ fn read_config_from_file<P: AsRef<Path>>(path: P) -> Result<HashMap<String, Conf
         entry.diagnostic_settings.values_mut().for_each(|sourced| {
             sourced.sources.insert(path.sanitize());
         });
+        entry.diagnostic_filters.iter_mut().for_each(|filter| {
+            filter.sources.insert(path.sanitize());
+        });
 
         (entry.name.clone(), entry)
     }).collect();
@@ -799,6 +874,7 @@ fn apply_merge(child: &ConfigEntryRaw, parent: &ConfigEntryRaw) -> ConfigEntryRa
     let version = child.version.clone().or(parent.version.clone());
     let base = child.base.clone().or(parent.base.clone());
     let diagnostic_settings = merge_sourced_diagnostic_setting_map(&child.diagnostic_settings, &parent.diagnostic_settings);
+    let diagnostic_filters = child.diagnostic_filters.iter().chain(parent.diagnostic_filters.iter()).cloned().collect::<Vec<_>>();
 
     ConfigEntryRaw {
         odoo_path,
@@ -818,6 +894,7 @@ fn apply_merge(child: &ConfigEntryRaw, parent: &ConfigEntryRaw) -> ConfigEntryRa
         version,
         base,
         diagnostic_settings: diagnostic_settings,
+        diagnostic_filters: diagnostic_filters,
         ..Default::default()
     }
 }
@@ -1150,6 +1227,7 @@ fn merge_all_workspaces(
                 &raw_entry.diagnostic_settings,
             );
             merged_entry.abstract_ = merged_entry.abstract_ || raw_entry.abstract_;
+            merged_entry.diagnostic_filters.extend(raw_entry.diagnostic_filters.iter().cloned());
         }
     }
     // Only infer odoo_path from workspace folders at this stage, to give priority to the user-defined one
@@ -1190,6 +1268,7 @@ fn merge_all_workspaces(
                 diagnostic_settings: raw_entry.diagnostic_settings.into_iter()
                     .map(|(k, v)| (k, v.value))
                     .collect(),
+                diagnostic_filters: raw_entry.diagnostic_filters.into_iter().map(|f| f.value).collect(),
                 ..Default::default()
             },
         );

server/src/core/file_mgr.rs

@@ -2,15 +2,15 @@ use lsp_types::notification::{Notification, PublishDiagnostics};
 use ropey::Rope;
 use ruff_python_ast::Mod;
 use ruff_python_parser::{Mode, ParseOptions, Parsed, Token, TokenKind};
-use lsp_types::{Diagnostic, MessageType, NumberOrString, Position, PublishDiagnosticsParams, Range, TextDocumentContentChangeEvent};
+use lsp_types::{Diagnostic, DiagnosticSeverity, MessageType, NumberOrString, Position, PublishDiagnosticsParams, Range, TextDocumentContentChangeEvent};
 use tracing::{error, warn};
 use std::collections::hash_map::DefaultHasher;
 use std::collections::HashSet;
 use std::hash::{Hash, Hasher};
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::{collections::HashMap, fs};
-use crate::core::diagnostics::{create_diagnostic, DiagnosticCode};
+use crate::core::diagnostics::{create_diagnostic, DiagnosticCode, DiagnosticSetting};
 use crate::threads::SessionInfo;
 use crate::utils::PathSanitizer;
 use std::rc::Rc;
@@ -292,36 +292,69 @@ impl FileInfo {
         if self.need_push {
             let mut all_diagnostics = Vec::new();
 
-            for diagnostics in self.diagnostics.values() {
-                for d in diagnostics.iter() {
-                    //check noqa lines
-                    let updated = self.update_range(d.clone());
-                    let updated_line = updated.range.start.line;
-                    if let Some(noqa_line) = self.noqas_lines.get(&updated_line) {
-                        match noqa_line {
-                            NoqaInfo::None => {},
-                            NoqaInfo::All => {
-                                continue;
-                            }
-                            NoqaInfo::Codes(codes) => {
-                                match &updated.code {
-                                    None => {continue;},
-                                    Some(NumberOrString::Number(n)) => {
-                                        if codes.contains(&n.to_string()) {
-                                            continue;
-                                        }
-                                    },
-                                    Some(NumberOrString::String(s)) => {
-                                        if codes.contains(&s) {
-                                            continue;
-                                        }
+            'diagnostics: for d in self.diagnostics.values().flatten() {
+                //check noqa lines
+                let updated = self.update_range(d.clone());
+                let updated_line = updated.range.start.line;
+                if let Some(noqa_line) = self.noqas_lines.get(&updated_line) {
+                    match noqa_line {
+                        NoqaInfo::None => {},
+                        NoqaInfo::All => {
+                            continue;
+                        }
+                        NoqaInfo::Codes(codes) => {
+                            match &updated.code {
+                                None => {continue;},
+                                Some(NumberOrString::Number(n)) => {
+                                    if codes.contains(&n.to_string()) {
+                                        continue;
+                                    }
+                                },
+                                Some(NumberOrString::String(s)) => {
+                                    if codes.contains(&s) {
+                                        continue;
                                     }
                                 }
                             }
                         }
                     }
-                    all_diagnostics.push(updated);
                 }
+                for filter in &session.sync_odoo.config.diagnostic_filters {
+                    // Path match
+                    if (!filter.negation && !filter.paths.matches(&self.uri)) || (filter.negation && filter.paths.matches(&self.uri)) {
+                        continue;
+                    }
+                    if !filter.codes.is_empty(){
+                        // we pass the filter if we do not have code, or does it not match the filter
+                        let Some(updated_code) = &updated.code else {
+                            continue;
+                        };
+                        let updated_code = match updated_code {
+                            NumberOrString::Number(n) => n.to_string(),
+                            NumberOrString::String(s) => s.clone(),
+                        };
+                        if !filter.codes.iter().any(|re| re.is_match(&updated_code)) {
+                            continue;
+                        }
+                    }
+                    if !filter.types.is_empty() {
+                        // we pass the filter if we do not have severity, or does it not match the filter
+                        let Some(severity) = &updated.severity else {
+                            continue;
+                        };
+                        if !filter.types.iter().any(|t| match (t, severity) {
+                            (DiagnosticSetting::Error, &DiagnosticSeverity::ERROR)
+                            | (DiagnosticSetting::Warning, &DiagnosticSeverity::WARNING)
+                            | (DiagnosticSetting::Info, &DiagnosticSeverity::INFORMATION)
+                            | (DiagnosticSetting::Hint, &DiagnosticSeverity::HINT) => true,
+                            _ => false,
+                        }) {
+                            continue;
+                        }
+                    }
+                    continue 'diagnostics;
+                }
+                all_diagnostics.push(updated);
             }
             session.send_notification::<PublishDiagnosticsParams>(PublishDiagnostics::METHOD, PublishDiagnosticsParams{
                 uri: FileMgr::pathname2uri(&self.uri),