Add elp ssr command

Summary:
We have the ability to specifiy an AdHoc diagnostic in a config file, from the diff titled `[ELP] Specify SSR match as Ad-Hoc diagnostic`.

We now simplify usage by allowing it to be given on the command line too, so a simple

```
elp ssr "{_A, _B}"
```

will find and report all 2 element tuples in the project.

Note: the full syntax for ssr can also be used if guards are required, e.g.

```
elp ssr "ssr: {_X = _Y} when _X == foo."
```

Reviewed By: michalmuskala

Differential Revision: D85443930

fbshipit-source-id: 108e2a583437fb3a6e702c21aef874395b376e7b

Author: alanz

crates/elp/src/bin/args.rs

@@ -332,6 +332,50 @@ pub struct Lint {
     pub ignore_apps: Vec<String>,
 }
 
+#[derive(Clone, Debug, Bpaf)]
+pub struct Ssr {
+    /// Path to directory with project, or to a JSON file (defaults to `.`)
+    #[bpaf(argument("PROJECT"), fallback(PathBuf::from(".")))]
+    pub project: PathBuf,
+    /// Parse a single module from the project, not the entire project.
+    #[bpaf(argument("MODULE"))]
+    pub module: Option<String>,
+    /// Parse a single application from the project, not the entire project.
+    #[bpaf(long("app"), long("application"), argument("APP"))]
+    pub app: Option<String>,
+    /// Parse a single file from the project, not the entire project. This can be an include file or escript, etc.
+    #[bpaf(argument("FILE"))]
+    pub file: Option<String>,
+
+    /// Run with rebar
+    pub rebar: bool,
+    /// Rebar3 profile to pickup (default is test)
+    #[bpaf(long("as"), argument("PROFILE"), fallback("test".to_string()))]
+    pub profile: String,
+
+    /// Also generate diagnostics for generated files
+    pub include_generated: bool,
+    /// Also generate diagnostics for test files
+    pub include_tests: bool,
+
+    /// Show diagnostics in JSON format
+    #[bpaf(
+        argument("FORMAT"),
+        complete(format_completer),
+        fallback(None),
+        guard(format_guard, "Please use json")
+    )]
+    pub format: Option<String>,
+
+    /// Report system memory usage and other statistics
+    #[bpaf(long("report-system-stats"))]
+    pub report_system_stats: bool,
+
+    /// SSR spec to use
+    #[bpaf(positional("SSR_SPEC"))]
+    pub ssr_spec: String,
+}
+
 #[derive(Clone, Debug, Bpaf)]
 pub struct Explain {
     /// Error code to explain
@@ -397,6 +441,7 @@ pub enum Command {
     GenerateCompletions(GenerateCompletions),
     RunServer(RunServer),
     Lint(Lint),
+    Ssr(Ssr),
     Version(Version),
     Shell(Shell),
     Explain(Explain),
@@ -507,6 +552,12 @@ pub fn command() -> impl Parser<Command> {
         .command("lint")
         .help("Parse files in project and emit diagnostics, optionally apply fixes.");
 
+    let ssr = ssr()
+        .map(Command::Ssr)
+        .to_options()
+        .command("ssr")
+        .help("Run SSR (Structural Search and Replace) pattern matching on project files.");
+
     let run_server = run_server()
         .map(Command::RunServer)
         .to_options()
@@ -556,6 +607,7 @@ pub fn command() -> impl Parser<Command> {
         eqwalize_target,
         dialyze_all,
         lint,
+        ssr,
         run_server,
         generate_completions,
         parse_all,

crates/elp/src/bin/lint_cli.rs

@@ -109,7 +109,7 @@ fn get_and_report_diagnostics_config(args: &Lint, cli: &mut dyn Cli) -> Result<D
     Ok(diagnostics_config)
 }
 
-fn load_project(
+pub fn load_project(
     args: &Lint,
     cli: &mut dyn Cli,
     query_config: &BuckQueryConfig,
@@ -396,6 +396,7 @@ fn get_diagnostics_config(args: &Lint) -> Result<DiagnosticsConfig> {
     } else {
         LintConfig::default()
     };
+
     let cfg = DiagnosticsConfig::default()
         .configure_diagnostics(
             &cfg_from_file,

crates/elp/src/bin/main.rs

@@ -43,6 +43,7 @@ mod lint_cli;
 // @fb-only
 mod reporting;
 mod shell;
+mod ssr_cli;
 
 // Use jemalloc as the global allocator
 #[cfg(not(any(target_env = "msvc", target_os = "openbsd")))]
@@ -135,6 +136,7 @@ fn try_main(cli: &mut dyn Cli, args: Args) -> Result<()> {
         args::Command::BuildInfo(args) => build_info_cli::save_build_info(args, &query_config)?,
         args::Command::ProjectInfo(args) => build_info_cli::save_project_info(args, &query_config)?,
         args::Command::Lint(args) => lint_cli::run_lint_command(&args, cli, &query_config)?,
+        args::Command::Ssr(args) => ssr_cli::run_ssr_command(&args, cli, &query_config)?,
         args::Command::GenerateCompletions(args) => {
             let instructions = args::gen_completions(&args.shell);
             writeln!(cli, "#Please run this:\n{instructions}")?
@@ -2000,6 +2002,40 @@ mod tests {
         )
     }
 
+    #[test]
+    fn lint_ssr_as_cli_arg() {
+        simple_snapshot(
+            args_vec!["ssr", "ssr: {_@A, _@B}.",],
+            "linter",
+            expect_file!("../resources/test/linter/ssr_ad_hoc.stdout"),
+            true,
+            None,
+        )
+    }
+
+    #[test]
+    fn lint_ssr_as_cli_arg_without_prefix() {
+        simple_snapshot(
+            args_vec!["ssr", "{_@A, _@B}",],
+            "linter",
+            expect_file!("../resources/test/linter/ssr_ad_hoc.stdout"),
+            true,
+            None,
+        )
+    }
+
+    #[test]
+    fn lint_ssr_as_cli_arg_malformed() {
+        simple_snapshot_expect_stderror(
+            args_vec!["ssr", "ssr: {_@A, = _@B}.",],
+            "linter",
+            expect_file!("../resources/test/linter/ssr_ad_hoc_cli_parse_error.stdout"),
+            true,
+            None,
+            false,
+        )
+    }
+
     #[test_case(false ; "rebar")]
     #[test_case(true  ; "buck")]
     fn eqwalizer_tests_check(buck: bool) {
@@ -2221,6 +2257,16 @@ mod tests {
         expected.assert_eq(&stdout);
     }
 
+    #[test]
+    fn ssr_help() {
+        let args = args::args()
+            .run_inner(Args::from(&["ssr", "--help"]))
+            .unwrap_err();
+        let expected = expect_file!["../resources/test/ssr_help.stdout"];
+        let stdout = args.unwrap_stdout();
+        expected.assert_eq(&stdout);
+    }
+
     #[test]
     fn build_info_help() {
         let args = args::args()

crates/elp/src/bin/ssr_cli.rs

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is dual-licensed under either the MIT license found in the
+ * LICENSE-MIT file in the root directory of this source tree or the Apache
+ * License, Version 2.0 found in the LICENSE-APACHE file in the root directory
+ * of this source tree. You may select, at your option, one of the
+ * above-listed licenses.
+ */
+
+use anyhow::Result;
+use anyhow::bail;
+use elp::cli::Cli;
+use elp_ide::AnalysisHost;
+use elp_ide::diagnostics;
+use elp_ide::diagnostics::DiagnosticsConfig;
+use elp_ide::diagnostics::FallBackToAll;
+use elp_ide::diagnostics::LintConfig;
+use elp_ide::diagnostics::MatchSsr;
+use elp_project_model::buck::BuckQueryConfig;
+
+use crate::args::Ssr;
+use crate::lint_cli;
+
+fn normalize_ssr_pattern(pattern: &str) -> String {
+    if pattern.starts_with("ssr:") {
+        pattern.to_string()
+    } else {
+        format!("ssr: {}.", pattern)
+    }
+}
+
+pub fn run_ssr_command(
+    args: &Ssr,
+    cli: &mut dyn Cli,
+    query_config: &BuckQueryConfig,
+) -> Result<()> {
+    // Normalize the SSR pattern
+    let normalized_pattern = normalize_ssr_pattern(&args.ssr_spec);
+
+    // Validate the SSR pattern early
+    let analysis_host = AnalysisHost::default();
+    let analysis = analysis_host.analysis();
+    match analysis.validate_ssr_pattern(&normalized_pattern) {
+        Ok(Ok(())) => {}
+        Ok(Err(e)) => bail!("invalid SSR pattern '{}': {}", args.ssr_spec, e),
+        Err(_cancelled) => bail!("SSR pattern validation was cancelled"),
+    }
+
+    // Create the lint config with the SSR pattern
+    let mut lint_config = LintConfig::default();
+    let ssr_lint = diagnostics::Lint::LintMatchSsr(MatchSsr {
+        ssr_pattern: normalized_pattern,
+        message: None,
+    });
+    lint_config.ad_hoc_lints.lints.push(ssr_lint);
+
+    // Build the diagnostics config
+    let diagnostics_config = DiagnosticsConfig::default()
+        .configure_diagnostics(
+            &lint_config,
+            &Some("ad-hoc: ssr-match".to_string()),
+            &None,
+            FallBackToAll::Yes,
+        )?
+        .set_include_generated(args.include_generated)
+        .set_experimental(false)
+        .set_use_cli_severity(false);
+
+    if diagnostics_config.enabled.all_enabled() && args.is_format_normal() {
+        writeln!(cli, "Reporting all diagnostics codes")?;
+    }
+
+    // Convert Ssr args to Lint args to reuse lint_cli functionality
+    let lint_args = crate::args::Lint {
+        project: args.project.clone(),
+        module: args.module.clone(),
+        app: args.app.clone(),
+        file: args.file.clone(),
+        rebar: args.rebar,
+        profile: args.profile.clone(),
+        include_generated: args.include_generated,
+        include_tests: args.include_tests,
+        print_diags: true,
+        format: args.format.clone(),
+        prefix: None,
+        include_erlc_diagnostics: false,
+        include_ct_diagnostics: false,
+        include_edoc_diagnostics: false,
+        include_eqwalizer_diagnostics: false,
+        include_suppressed: false,
+        use_cli_severity: false,
+        diagnostic_ignore: None,
+        diagnostic_filter: Some("ad-hoc: ssr-match".to_string()),
+        experimental_diags: false,
+        read_config: false,
+        config_file: None,
+        apply_fix: false,
+        ignore_fix_only: false,
+        in_place: false,
+        to: None,
+        recursive: false,
+        with_check: false,
+        check_eqwalize_all: false,
+        one_shot: false,
+        report_system_stats: args.report_system_stats,
+        ignore_apps: vec![],
+    };
+
+    // Load the project
+    let mut loaded = lint_cli::load_project(&lint_args, cli, query_config)?;
+
+    // Run the codemod with the SSR pattern
+    lint_cli::do_codemod(cli, &mut loaded, &diagnostics_config, &lint_args)
+}
+
+impl Ssr {
+    pub fn is_format_normal(&self) -> bool {
+        self.format.is_none()
+    }
+}

crates/elp/src/resources/test/help.stdout

@@ -16,6 +16,7 @@ Available commands:
     eqwalize-target       Eqwalize all opted-in modules in specified buck target
     dialyze-all           Run Dialyzer on the whole project by shelling out to a `dialyzer-run` tool on the path to do the legwork.
     lint                  Parse files in project and emit diagnostics, optionally apply fixes.
+    ssr                   Run SSR (Structural Search and Replace) pattern matching on project files.
     server                Run lsp server
     generate-completions  Generate shell completions
     parse-all             Dump ast for all files in a project for specified rebar.config file

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

@@ -0,0 +1 @@
+invalid SSR pattern 'ssr: {_@A, = _@B}.': Parse error: Could not lower rule

crates/elp/src/resources/test/linter/ssr_as_cli_arg.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/ssr_help.stdout

@@ -0,0 +1,17 @@
+Usage: [--project PROJECT] [--module MODULE] [--app APP] [--file FILE] [--rebar] [--as PROFILE] [--include-generated] [--include-tests] [[--format FORMAT]] [--report-system-stats] <SSR_SPEC>
+
+Available positional items:
+    <SSR_SPEC>  SSR spec to use
+
+Available options:
+        --project <PROJECT>    Path to directory with project, or to a JSON file (defaults to `.`)
+        --module <MODULE>      Parse a single module from the project, not the entire project.
+        --app <APP>            Parse a single application from the project, not the entire project.
+        --file <FILE>          Parse a single file from the project, not the entire project. This can be an include file or escript, etc.
+        --rebar                Run with rebar
+        --as <PROFILE>         Rebar3 profile to pickup (default is test)
+        --include-generated    Also generate diagnostics for generated files
+        --include-tests        Also generate diagnostics for test files
+        --format <FORMAT>      Show diagnostics in JSON format
+        --report-system-stats  Report system memory usage and other statistics
+    -h, --help                 Prints help information

crates/ide/src/lib.rs

@@ -566,6 +566,16 @@ impl Analysis {
         self.with_db(|db| db.is_otp(file_id))
     }
 
+    /// Validates an SSR pattern string by attempting to parse it.
+    /// Returns `Ok(())` if the pattern is valid, or an error message if parsing fails.
+    pub fn validate_ssr_pattern(&self, pattern: &str) -> Cancellable<Result<(), String>> {
+        self.with_db(|db| {
+            elp_ide_ssr::SsrRule::parse_str(db, pattern)
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+        })
+    }
+
     /// Search symbols. Only module names are currently supported.
     pub fn symbol_search(
         &self,