Specify SSR match as Ad-Hoc diagnostic

Summary:
Structured Search (and not yet Replace) SSR is a way of specifying a "semantic grep", which searches by comparing the AST rather than text. We use it as a building block for diagnostics.

But often we want to just do a quick search for a pattern in a file or code base.

This diff allows us to do this, by specifying it in a config file.

Reviewed By: TD5

Differential Revision: D85340131

fbshipit-source-id: f1e4ce515a535cc6032483dc39297eab4e6eecd5

Author: alanz

crates/elp/src/bin/lint_cli.rs

@@ -993,7 +993,7 @@ mod tests {
         expect![[r#"
             enabled_lints = ["P1700"]
             disabled_lints = []
-            
+
             [erlang_service]
             warnings_as_errors = true
             [[ad_hoc_lints.lints]]

crates/elp/src/bin/main.rs

@@ -1938,6 +1938,37 @@ mod tests {
         )
     }
 
+    #[test]
+    fn lint_ssr_from_config() {
+        simple_snapshot(
+            args_vec![
+                "lint",
+                "--config-file",
+                "../../test_projects/linter/elp_lint_ssr_adhoc.toml",
+            ],
+            "linter",
+            expect_file!("../resources/test/linter/ssr_ad_hoc.stdout"),
+            true,
+            None,
+        )
+    }
+
+    #[test]
+    fn lint_ssr_from_bad_config() {
+        simple_snapshot_expect_stderror(
+            args_vec![
+                "lint",
+                "--config-file",
+                "../../test_projects/linter/elp_lint_ssr_adhoc_parse_fail.toml",
+            ],
+            "linter",
+            expect_file!("../resources/test/linter/ssr_ad_hoc_parse_fail.stdout"),
+            true,
+            None,
+            false,
+        )
+    }
+
     #[test_case(false ; "rebar")]
     #[test_case(true  ; "buck")]
     fn eqwalizer_tests_check(buck: bool) {

crates/elp/src/lib.rs

@@ -162,6 +162,7 @@ mod tests {
     use elp_ide::diagnostics::ErlangServiceConfig;
     use elp_ide::diagnostics::Lint;
     use elp_ide::diagnostics::LintsFromConfig;
+    use elp_ide::diagnostics::MatchSsr;
     use elp_ide::diagnostics::ReplaceCall;
     use elp_ide::diagnostics::ReplaceCallAction;
     use elp_ide::diagnostics::Replacement;
@@ -188,6 +189,10 @@ mod tests {
                             perm: vec![1, 2],
                         }),
                     }),
+                    Lint::LintMatchSsr(MatchSsr {
+                        ssr_pattern: "ssr: _@A = 10.".to_string(),
+                        message: None,
+                    }),
                 ],
             },
             linters: FxHashMap::default(),
@@ -223,6 +228,10 @@ mod tests {
             type = "ArgsPermutation"
             perm = [1, 2]
 
+            [[ad_hoc_lints.lints]]
+            type = "LintMatchSsr"
+            ssr_pattern = "ssr: _@A = 10."
+
             [linters]
         "#]]
         .assert_eq(&toml::to_string::<LintConfig>(&lint_config).unwrap());

crates/elp/src/resources/test/linter/ssr_ad_hoc.stdout

@@ -0,0 +1,3 @@
+Diagnostics reported in 1 modules:
+  app_a: 1
+      15:12-15:17::[WeakWarning] [ad-hoc: ssr-match] SSR pattern matched: ssr: {_@A, _@B}.

crates/elp/src/resources/test/linter/ssr_ad_hoc_parse_fail.stdout

@@ -0,0 +1 @@
+errors parsing "{project_path}/elp_lint_ssr_adhoc_parse_fail.toml": invalid SSR pattern 'ssr: {_@A, = 10}.': Parse error: Could not lower rule for key `ad_hoc_lints.lints` at line 3 column 1

crates/ide/src/diagnostics.rs

@@ -149,6 +149,7 @@ mod unused_record_field;
 pub use elp_ide_db::DiagnosticCode;
 pub use from_config::Lint;
 pub use from_config::LintsFromConfig;
+pub use from_config::MatchSsr;
 pub use from_config::ReplaceCall;
 pub use from_config::ReplaceCallAction;
 pub use replace_call::Replacement;

crates/ide/src/diagnostics/from_config.rs

@@ -10,12 +10,21 @@
 
 //! Read a section of the config file and generate diagnostics from it.
 
+use elp_ide_db::DiagnosticCode;
+use elp_ide_db::RootDatabase;
 use elp_ide_db::elp_base_db::FileId;
+use elp_ide_ssr::SsrRule;
+use elp_ide_ssr::SsrSearchScope;
+use elp_ide_ssr::match_pattern;
 use hir::Semantic;
+use hir::Strategy;
+use hir::fold::MacroStrategy;
+use hir::fold::ParenStrategy;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::Diagnostic;
+use super::Severity;
 use super::TypeReplacement;
 use super::replace_call;
 use super::replace_call::Replacement;
@@ -41,13 +50,15 @@ impl LintsFromConfig {
 pub enum Lint {
     ReplaceCall(ReplaceCall),
     ReplaceInSpec(ReplaceInSpec),
+    LintMatchSsr(MatchSsr),
 }
 
 impl Lint {
     pub fn get_diagnostics(&self, acc: &mut Vec<Diagnostic>, sema: &Semantic, file_id: FileId) {
         match self {
             Lint::ReplaceCall(l) => l.get_diagnostics(acc, sema, file_id),
             Lint::ReplaceInSpec(l) => l.get_diagnostics(acc, sema, file_id),
+            Lint::LintMatchSsr(l) => l.get_diagnostics(acc, sema, file_id),
         }
     }
 }
@@ -115,12 +126,82 @@ impl ReplaceInSpec {
 
 // ---------------------------------------------------------------------
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct MatchSsr {
+    pub ssr_pattern: String,
+    #[serde(default)]
+    pub message: Option<String>,
+}
+
+impl<'de> Deserialize<'de> for MatchSsr {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::Error;
+
+        #[derive(Deserialize)]
+        struct MatchSsrHelper {
+            ssr_pattern: String,
+            #[serde(default)]
+            message: Option<String>,
+        }
+
+        let helper = MatchSsrHelper::deserialize(deserializer)?;
+
+        // Validate the SSR pattern by trying to parse it
+        // Use a minimal database for validation
+        let db = RootDatabase::default();
+        SsrRule::parse_str(&db, &helper.ssr_pattern).map_err(|e| {
+            D::Error::custom(format!(
+                "invalid SSR pattern '{}': {}",
+                helper.ssr_pattern, e
+            ))
+        })?;
+
+        Ok(MatchSsr {
+            ssr_pattern: helper.ssr_pattern,
+            message: helper.message,
+        })
+    }
+}
+
+impl MatchSsr {
+    pub fn get_diagnostics(&self, acc: &mut Vec<Diagnostic>, sema: &Semantic, file_id: FileId) {
+        let strategy = Strategy {
+            macros: MacroStrategy::Expand,
+            parens: ParenStrategy::InvisibleParens,
+        };
+
+        let scope = SsrSearchScope::WholeFile(file_id);
+        let matches = match_pattern(sema, strategy, &self.ssr_pattern, scope);
+
+        for matched in matches.matches {
+            let message = self
+                .message
+                .clone()
+                .unwrap_or_else(|| format!("SSR pattern matched: {}", self.ssr_pattern));
+
+            let diag = Diagnostic::new(
+                DiagnosticCode::AdHoc("ssr-match".to_string()),
+                message,
+                matched.range.range,
+            )
+            .with_severity(Severity::WeakWarning);
+            acc.push(diag);
+        }
+    }
+}
+
+// ---------------------------------------------------------------------
+
 #[cfg(test)]
 mod tests {
     use expect_test::expect;
 
     use super::Lint;
     use super::LintsFromConfig;
+    use super::MatchSsr;
     use super::ReplaceCall;
     use super::ReplaceCallAction;
     use super::ReplaceInSpec;
@@ -492,4 +573,57 @@ mod tests {
         "#]]
         .assert_eq(&result);
     }
+
+    #[test]
+    fn serde_serialize_match_ssr() {
+        let result = toml::to_string::<MatchSsr>(&MatchSsr {
+            ssr_pattern: "ssr: _@A = 10.".to_string(),
+            message: Some("Found pattern".to_string()),
+        })
+        .unwrap();
+        expect![[r#"
+            ssr_pattern = "ssr: _@A = 10."
+            message = "Found pattern"
+        "#]]
+        .assert_eq(&result);
+    }
+
+    #[test]
+    fn serde_deserialize_match_ssr() {
+        let match_ssr: MatchSsr = toml::from_str(
+            r#"
+              ssr_pattern = "ssr: _@A = 10."
+              message = "Found pattern"
+             "#,
+        )
+        .unwrap();
+
+        expect![[r#"
+            MatchSsr {
+                ssr_pattern: "ssr: _@A = 10.",
+                message: Some(
+                    "Found pattern",
+                ),
+            }
+        "#]]
+        .assert_debug_eq(&match_ssr);
+    }
+
+    #[test]
+    fn serde_serialize_lint_match_ssr() {
+        let result = toml::to_string::<LintsFromConfig>(&LintsFromConfig {
+            lints: vec![Lint::LintMatchSsr(MatchSsr {
+                ssr_pattern: "ssr: _@A = 10.".to_string(),
+                message: Some("Found pattern".to_string()),
+            })],
+        })
+        .unwrap();
+        expect![[r#"
+            [[lints]]
+            type = "LintMatchSsr"
+            ssr_pattern = "ssr: _@A = 10."
+            message = "Found pattern"
+        "#]]
+        .assert_eq(&result);
+    }
 }

test_projects/linter/elp_lint_ssr_adhoc.toml

@@ -0,0 +1,5 @@
+enabled_lints = ["ad-hoc: ssr-match"]
+
+[[ad_hoc_lints.lints]]
+type = "LintMatchSsr"
+ssr_pattern = "ssr: {_@A, _@B}."

test_projects/linter/elp_lint_ssr_adhoc_parse_fail.toml

@@ -0,0 +1,5 @@
+enabled_lints = ["ad-hoc: ssr-match"]
+
+[[ad_hoc_lints.lints]]
+type = "LintMatchSsr"
+ssr_pattern = "ssr: {_@A, = 10}."