feat(linter): add unicorn/no-array-sort rule

crates/oxc_linter/src/generated/rule_runner_impls.rs

@@ -2344,6 +2344,11 @@ impl RuleRunner for crate::rules::unicorn::no_array_reverse::NoArrayReverse {
         Some(&AstTypesBitset::from_types(&[AstType::CallExpression]));
 }
 
+impl RuleRunner for crate::rules::unicorn::no_array_sort::NoArraySort {
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression]));
+}
+
 impl RuleRunner for crate::rules::unicorn::no_await_expression_member::NoAwaitExpressionMember {
     const NODE_TYPES: Option<&AstTypesBitset> = None;
 }

crates/oxc_linter/src/rules.rs

@@ -403,6 +403,7 @@ pub(crate) mod unicorn {
     pub mod no_array_method_this_argument;
     pub mod no_array_reduce;
     pub mod no_array_reverse;
+    pub mod no_array_sort;
     pub mod no_await_expression_member;
     pub mod no_await_in_promise_methods;
     pub mod no_console_spaces;
@@ -1120,6 +1121,7 @@ oxc_macros::declare_all_lint_rules! {
     unicorn::explicit_length_check,
     unicorn::filename_case,
     unicorn::new_for_builtins,
+    unicorn::no_array_sort,
     unicorn::no_array_reverse,
     unicorn::no_instanceof_builtins,
     unicorn::no_array_method_this_argument,

crates/oxc_linter/src/rules/unicorn/no_array_sort.rs

@@ -0,0 +1,182 @@
+use oxc_ast::{
+    AstKind,
+    ast::{Argument, ArrayExpressionElement, Expression},
+};
+use oxc_diagnostics::OxcDiagnostic;
+use oxc_macros::declare_oxc_lint;
+use oxc_span::Span;
+use serde_json::Value;
+
+use crate::{AstNode, context::LintContext, rule::Rule};
+
+fn no_array_sort_diagnostic(span: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warn("Use `Array#toSorted()` instead of `Array#sort()`.")
+        .with_help("`Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.")
+        .with_label(span)
+}
+
+#[derive(Debug, Clone)]
+pub struct NoArraySort {
+    allow_expression_statement: bool,
+}
+
+impl Default for NoArraySort {
+    fn default() -> Self {
+        Self { allow_expression_statement: true }
+    }
+}
+
+declare_oxc_lint!(
+    /// ### What it does
+    ///
+    /// Prefer using `Array#toSorted()` over `Array#sort()`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// `Array#sort()` modifies the original array in place, which can lead to unintended side effects—especially
+    /// when the original array is used elsewhere in the code.
+    ///
+    /// ### Examples
+    ///
+    /// Examples of **incorrect** code for this rule:
+    /// ```js
+    /// const sorted = [...array].sort();
+    /// ```
+    ///
+    /// Examples of **correct** code for this rule:
+    /// ```js
+    /// const sorted = [...array].toSorted();
+    /// ```
+    ///
+    /// ### Options
+    ///
+    /// #### allowExpressionStatement
+    ///
+    /// `{ type: boolean, default: true }`
+    ///
+    /// This rule allows `array.sort()` as an expression statement by default,
+    /// Pass allowExpressionStatement: false to forbid `Array#sort()` even if it's an expression statement.
+    ///
+    /// Examples of **incorrect** code for this rule with the `{ "allowExpressionStatement": false }` option:
+    /// ```js
+    /// array.sort();
+    /// ```
+    NoArraySort,
+    unicorn,
+    suspicious,
+    fix,
+);
+
+impl Rule for NoArraySort {
+    fn from_configuration(value: Value) -> Self {
+        Self {
+            allow_expression_statement: value
+                .get(0)
+                .and_then(|v| v.get("allowExpressionStatement"))
+                .and_then(Value::as_bool)
+                .unwrap_or(true),
+        }
+    }
+
+    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
+        if call_expr.optional {
+            return;
+        }
+        if call_expr.arguments.len() > 1 {
+            return;
+        }
+        if call_expr.arguments.len() == 1
+            && matches!(call_expr.arguments[0], Argument::SpreadElement(_))
+        {
+            return;
+        }
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
+        let Some((span, static_property_name)) = member_expr.static_property_info() else {
+            return;
+        };
+        if static_property_name != "sort" {
+            return;
+        }
+
+        let is_spread = match member_expr.object() {
+            Expression::ArrayExpression(array) => {
+                array.elements.len() == 1
+                    && matches!(array.elements[0], ArrayExpressionElement::SpreadElement(_))
+            }
+            _ => false,
+        };
+
+        if self.allow_expression_statement && !is_spread {
+            let parent = ctx.nodes().parent_node(node.id());
+            let parent_is_expression_statement = match parent.kind() {
+                AstKind::ExpressionStatement(_) => true,
+                AstKind::ChainExpression(_) => {
+                    let grand_parent = ctx.nodes().parent_node(parent.id());
+                    matches!(grand_parent.kind(), AstKind::ExpressionStatement(_))
+                }
+                _ => false,
+            };
+            if parent_is_expression_statement {
+                return;
+            }
+        }
+
+        ctx.diagnostic_with_fix(no_array_sort_diagnostic(span), |fixer| {
+            fixer.replace(span, "toSorted")
+        });
+    }
+}
+
+#[test]
+fn test() {
+    use crate::tester::Tester;
+
+    let pass = vec![
+        ("sorted = [...array].toSorted()", None),
+        ("sorted = array.toSorted()", None),
+        ("sorted = [...array].sort", None),
+        ("sorted = [...array].sort?.()", None),
+        ("array.sort()", None),
+        ("array.sort?.()", None),
+        ("array?.sort()", None),
+        ("if (true) array.sort()", None),
+        ("sorted = array.sort(...[])", None),
+        ("sorted = array.sort(...[compareFn])", None),
+        ("sorted = array.sort(compareFn, extraArgument)", None),
+    ];
+
+    let fail = vec![
+        ("sorted = [...array].sort()", None),
+        ("sorted = [...array]?.sort()", None),
+        ("sorted = array.sort()", None),
+        ("sorted = array?.sort()", None),
+        ("sorted = [...array].sort(compareFn)", None),
+        ("sorted = [...array]?.sort(compareFn)", None),
+        ("sorted = array.sort(compareFn)", None),
+        ("sorted = array?.sort(compareFn)", None),
+        ("array.sort()", Some(serde_json::json!([{"allowExpressionStatement": false}]))),
+        ("array?.sort()", Some(serde_json::json!([{"allowExpressionStatement": false}]))),
+        ("[...array].sort()", Some(serde_json::json!([{"allowExpressionStatement": false}]))),
+        ("sorted = [...(0, array)].sort()", None),
+    ];
+
+    let fix = vec![
+        ("sorted = [...array].sort()", "sorted = [...array].toSorted()", None),
+        ("sorted = [...array]?.sort()", "sorted = [...array]?.toSorted()", None),
+        (
+            "a.sort()",
+            "a.toSorted()",
+            Some(serde_json::json!([{"allowExpressionStatement": false}])),
+        ),
+        ("sorted = array?.sort()", "sorted = array?.toSorted()", None),
+    ];
+
+    Tester::new(NoArraySort::NAME, NoArraySort::PLUGIN, pass, fail)
+        .expect_fix(fix)
+        .test_and_snapshot();
+}

crates/oxc_linter/src/snapshots/unicorn_no_array_sort.snap

@@ -0,0 +1,86 @@
+---
+source: crates/oxc_linter/src/tester.rs
+---
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:21]
+ 1 │ sorted = [...array].sort()
+   ·                     ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:22]
+ 1 │ sorted = [...array]?.sort()
+   ·                      ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:16]
+ 1 │ sorted = array.sort()
+   ·                ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:17]
+ 1 │ sorted = array?.sort()
+   ·                 ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:21]
+ 1 │ sorted = [...array].sort(compareFn)
+   ·                     ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:22]
+ 1 │ sorted = [...array]?.sort(compareFn)
+   ·                      ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:16]
+ 1 │ sorted = array.sort(compareFn)
+   ·                ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:17]
+ 1 │ sorted = array?.sort(compareFn)
+   ·                 ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:7]
+ 1 │ array.sort()
+   ·       ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:8]
+ 1 │ array?.sort()
+   ·        ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:12]
+ 1 │ [...array].sort()
+   ·            ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.
+
+  ⚠ eslint-plugin-unicorn(no-array-sort): Use `Array#toSorted()` instead of `Array#sort()`.
+   ╭─[no_array_sort.tsx:1:26]
+ 1 │ sorted = [...(0, array)].sort()
+   ·                          ────
+   ╰────
+  help: `Array#sort()` mutates the original array. Use `Array#toSorted()` to return a new sorted array without modifying the original.