Add lists_reverse_append linter

Summary:
Introduce a new linter which identifies usages of the following pattern:

```
lists:reverse(List) ++ Tail
```

Suggesting to replace them with the more performing:

```
lists:reverse(List, Tail)
```

Reviewed By: michalmuskala, alanz

Differential Revision: D86967410

fbshipit-source-id: cc5142aa9548a69792bb5ba9ff6698afbd38227c

Author: robertoaloi

crates/ide/src/diagnostics.rs

@@ -108,6 +108,7 @@ mod head_mismatch;
 mod inefficient_enumerate;
 mod inefficient_flatlength;
 mod inefficient_last;
+mod lists_reverse_append;
 mod macro_precedence_suprise;
 mod map_find_to_syntax;
 mod map_insertion_to_syntax;
@@ -1558,6 +1559,7 @@ const SSR_PATTERN_LINTERS: &[&dyn SsrPatternsDiagnostics] = &[
     &binary_string_to_sigil::LINTER,
     &unnecessary_map_to_list_in_comprehension::LINTER,
     &could_be_a_string_literal::LINTER,
+    &lists_reverse_append::LINTER,
 ];
 
 /// Generic linters

crates/ide/src/diagnostics/lists_reverse_append.rs

@@ -0,0 +1,187 @@
+/*
+ * 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.
+ */
+
+//! Lint: lists_reverse_append
+//!
+//! Detect patterns of the form `lists:reverse(_@L) ++ _@T` and suggest `lists:reverse(_@L, _@T)`
+
+use elp_ide_assists::Assist;
+use elp_ide_db::DiagnosticCode;
+use elp_ide_db::elp_base_db::FileId;
+use elp_ide_db::source_change::SourceChangeBuilder;
+use hir::Semantic;
+
+use crate::diagnostics::Linter;
+use crate::diagnostics::SsrPatternsLinter;
+use crate::fix;
+
+pub(crate) struct ListsReverseAppendLinter;
+
+impl Linter for ListsReverseAppendLinter {
+    fn id(&self) -> DiagnosticCode {
+        DiagnosticCode::ListsReverseAppend
+    }
+
+    fn description(&self) -> &'static str {
+        "Use `lists:reverse/2` instead of `lists:reverse/1 ++ Tail` for better performance."
+    }
+}
+
+impl SsrPatternsLinter for ListsReverseAppendLinter {
+    type Context = ();
+
+    fn patterns(&self) -> Vec<(String, Self::Context)> {
+        vec![(format!("ssr: lists:reverse({LIST_VAR}) ++ {TAIL_VAR}."), ())]
+    }
+
+    fn fixes(
+        &self,
+        _context: &Self::Context,
+        matched: &elp_ide_ssr::Match,
+        sema: &Semantic,
+        _file_id: FileId,
+    ) -> Option<Vec<Assist>> {
+        let list_match = matched.placeholder_text(sema, LIST_VAR)?;
+        let tail_match = matched.placeholder_text(sema, TAIL_VAR)?;
+        let mut builder = SourceChangeBuilder::new(matched.range.file_id);
+        let replacement = format!("lists:reverse({list_match}, {tail_match})");
+        let range = matched.range.range;
+        builder.replace(range, replacement);
+        let fixes = vec![fix(
+            "lists_reverse_append",
+            "Use lists:reverse/2",
+            builder.finish(),
+            range,
+        )];
+        Some(fixes)
+    }
+}
+
+pub(crate) static LINTER: ListsReverseAppendLinter = ListsReverseAppendLinter;
+
+static LIST_VAR: &str = "_@L";
+static TAIL_VAR: &str = "_@T";
+
+#[cfg(test)]
+mod tests {
+
+    use expect_test::Expect;
+    use expect_test::expect;
+
+    use crate::diagnostics::Diagnostic;
+    use crate::diagnostics::DiagnosticCode;
+    use crate::tests;
+
+    fn filter(d: &Diagnostic) -> bool {
+        d.code == DiagnosticCode::ListsReverseAppend
+    }
+
+    #[track_caller]
+    fn check_diagnostics(fixture: &str) {
+        tests::check_filtered_diagnostics(fixture, &filter)
+    }
+
+    #[track_caller]
+    fn check_fix(fixture_before: &str, fixture_after: Expect) {
+        tests::check_fix(fixture_before, fixture_after)
+    }
+
+    #[test]
+    fn detects_lists_reverse_append() {
+        check_diagnostics(
+            r#"
+        //- /src/lists_reverse_append.erl
+        -module(lists_reverse_append).
+
+        reverse_and_append(List, Tail) ->
+            lists:reverse(List) ++ Tail.
+        %%  ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 💡 warning: W0056: Use `lists:reverse/2` instead of `lists:reverse/1 ++ Tail` for better performance.
+           "#,
+        )
+    }
+
+    #[test]
+    fn detects_lists_reverse_append_with_variables() {
+        check_diagnostics(
+            r#"
+        //- /src/lists_reverse_append.erl
+        -module(lists_reverse_append).
+
+        process(Items, Acc) ->
+            lists:reverse(Items) ++ Acc.
+        %%  ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 💡 warning: W0056: Use `lists:reverse/2` instead of `lists:reverse/1 ++ Tail` for better performance.
+           "#,
+        )
+    }
+
+    #[test]
+    fn ignores_regular_reverse() {
+        check_diagnostics(
+            r#"
+        //- /src/lists_reverse_append.erl
+        -module(lists_reverse_append).
+
+        reverse_only(List) ->
+            lists:reverse(List).
+           "#,
+        )
+    }
+
+    #[test]
+    fn ignores_regular_append() {
+        check_diagnostics(
+            r#"
+        //- /src/lists_reverse_append.erl
+        -module(lists_reverse_append).
+
+        append_only(A, B) ->
+            A ++ B.
+           "#,
+        )
+    }
+
+    #[test]
+    fn fixes_lists_reverse_append() {
+        check_fix(
+            r#"
+        //- /src/lists_reverse_append.erl
+        -module(lists_reverse_append).
+
+        reverse_and_append(List, Tail) ->
+            lists:re~verse(List) ++ Tail.
+           "#,
+            expect![[r#"
+        -module(lists_reverse_append).
+
+        reverse_and_append(List, Tail) ->
+            lists:reverse(List, Tail).
+           "#]],
+        )
+    }
+
+    #[test]
+    fn fixes_lists_reverse_append_with_complex_expressions() {
+        check_fix(
+            r#"
+        //- /src/lists_reverse_append.erl
+        -module(lists_reverse_append).
+
+        process([H|T], Acc) ->
+            lists:rev~erse([H|T]) ++ [1, 2, 3].
+           "#,
+            expect![[r#"
+        -module(lists_reverse_append).
+
+        process([H|T], Acc) ->
+            lists:reverse([H|T], [1, 2, 3]).
+           "#]],
+        )
+    }
+}

crates/ide_db/src/diagnostic_code.rs

@@ -89,6 +89,7 @@ pub enum DiagnosticCode {
     NoErrorLogger,
     NoNoWarnSuppressions,
     CouldBeAStringLiteral,
+    ListsReverseAppend,
 
     // Wrapper for erlang service diagnostic codes
     ErlangService(String),
@@ -248,6 +249,7 @@ impl DiagnosticCode {
             DiagnosticCode::NoErrorLogger => "W0053".to_string(),
             DiagnosticCode::NoNoWarnSuppressions => "W0054".to_string(),
             DiagnosticCode::CouldBeAStringLiteral => "W0055".to_string(),
+            DiagnosticCode::ListsReverseAppend => "W0056".to_string(),
             DiagnosticCode::ErlangService(c) => c.to_string(),
             DiagnosticCode::Eqwalizer(c) => format!("eqwalizer: {c}"),
             DiagnosticCode::AdHoc(c) => format!("ad-hoc: {c}"),
@@ -344,6 +346,7 @@ impl DiagnosticCode {
             DiagnosticCode::NoErrorLogger => "no_error_logger".to_string(),
             DiagnosticCode::NoNoWarnSuppressions => "no_nowarn_suppressions".to_string(),
             DiagnosticCode::CouldBeAStringLiteral => "could_be_a_binary_string_literal".to_string(),
+            DiagnosticCode::ListsReverseAppend => "lists_reverse_append".to_string(),
 
             DiagnosticCode::ErlangService(c) => c.to_string(),
             DiagnosticCode::Eqwalizer(c) => c.to_string(),
@@ -520,6 +523,7 @@ impl DiagnosticCode {
             DiagnosticCode::NoCatch => false,
             DiagnosticCode::NoErrorLogger => false,
             DiagnosticCode::NoNoWarnSuppressions => false,
+            DiagnosticCode::ListsReverseAppend => false,
 
             DiagnosticCode::BinaryStringToSigil => false,
             DiagnosticCode::ErlangService(_) => false,

website/docs/erlang-error-index/w/W0056.md

@@ -0,0 +1,45 @@
+---
+sidebar_position: 56
+---
+
+# W0056 - Use `lists:reverse/2` instead of `lists:reverse/1 ++ Tail`
+
+## Warning
+
+```erlang
+reverse_and_append(List, Tail) ->
+    lists:reverse(List) ++ Tail.
+%%  ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 💡 warning: W0056: Use `lists:reverse/2` instead of `lists:reverse/1 ++ Tail` for better performance.
+```
+
+## Explanation
+
+The warning indicates that you are using the pattern `lists:reverse(List) ++ Tail`, which is inefficient. This pattern first reverses the list, creating an intermediate reversed list, and then appends the tail to it using the `++` operator.
+
+The Erlang standard library provides a more efficient function `lists:reverse/2` that performs both operations in a single pass without creating the intermediate reversed list.
+
+### Why This Matters
+
+- **Performance**: Using `lists:reverse/1` followed by `++` creates an unnecessary intermediate data structure
+- **Memory**: The intermediate reversed list consumes additional memory that is immediately discarded
+- **Idiomatic Erlang**: `lists:reverse/2` is the idiomatic way to reverse and prepend in Erlang
+
+### Fix
+
+Replace the pattern with `lists:reverse/2`:
+
+```erlang
+reverse_and_append(List, Tail) ->
+    lists:reverse(List, Tail).
+```
+
+### How lists:reverse/2 Works
+
+The second argument to `lists:reverse/2` acts as an accumulator that gets prepended to the reversed list:
+
+```erlang
+lists:reverse([1, 2, 3], [4, 5, 6]).
+% Returns: [3, 2, 1, 4, 5, 6]
+```
+
+This is equivalent to `lists:reverse([1, 2, 3]) ++ [4, 5, 6]` but significantly more efficient.