feat(biome_js_analyze): implement useArraySortCompare (#8065)

Author: Netail

.changeset/sad-adults-enjoy.md

@@ -0,0 +1,17 @@
+---
+"@biomejs/biome": patch
+---
+
+Added the nursery rule [`useArraySortCompare`](https://biomejs.dev/linter/rules/use-array-sort-compare/). Require Array#sort and Array#toSorted calls to always provide a compareFunction.
+
+**Invalid:**
+```js
+const array = [];
+array.sort();
+```
+
+**Valid:**
+```js
+const array = [];
+array.sort((a, b) => a - b);
+```

crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs

@@ -193,6 +193,7 @@ define_categories! {
     "lint/nursery/noVueReservedKeys": "https://biomejs.dev/linter/rules/no-vue-reserved-keys",
     "lint/nursery/noVueReservedProps": "https://biomejs.dev/linter/rules/no-vue-reserved-props",
     "lint/nursery/useAnchorHref": "https://biomejs.dev/linter/rules/use-anchor-href",
+    "lint/nursery/useArraySortCompare": "https://biomejs.dev/linter/rules/use-array-sort-compare",
     "lint/nursery/useBiomeSuppressionComment": "https://biomejs.dev/linter/rules/use-biome-suppression-comment",
     "lint/nursery/useConsistentArrowReturn": "https://biomejs.dev/linter/rules/use-consistent-arrow-return",
     "lint/nursery/useConsistentObjectDefinition": "https://biomejs.dev/linter/rules/use-consistent-object-definition",

crates/biome_configuration/src/analyzer/linter/rules.rs

@@ -25,6 +25,7 @@ pub mod no_vue_data_object_declaration;
 pub mod no_vue_duplicate_keys;
 pub mod no_vue_reserved_keys;
 pub mod no_vue_reserved_props;
+pub mod use_array_sort_compare;
 pub mod use_consistent_arrow_return;
 pub mod use_exhaustive_switch_cases;
 pub mod use_explicit_type;
@@ -34,4 +35,4 @@ pub mod use_qwik_valid_lexical_scope;
 pub mod use_sorted_classes;
 pub mod use_vue_define_macros_order;
 pub mod use_vue_multi_word_component_names;
-declare_lint_group! { pub Nursery { name : "nursery" , rules : [self :: no_continue :: NoContinue , self :: no_deprecated_imports :: NoDeprecatedImports , self :: no_empty_source :: NoEmptySource , self :: no_floating_promises :: NoFloatingPromises , self :: no_import_cycles :: NoImportCycles , self :: no_increment_decrement :: NoIncrementDecrement , self :: no_jsx_literals :: NoJsxLiterals , self :: no_misused_promises :: NoMisusedPromises , self :: no_next_async_client_component :: NoNextAsyncClientComponent , self :: no_parameters_only_used_in_recursion :: NoParametersOnlyUsedInRecursion , self :: no_react_forward_ref :: NoReactForwardRef , self :: no_shadow :: NoShadow , self :: no_unknown_attribute :: NoUnknownAttribute , self :: no_unnecessary_conditions :: NoUnnecessaryConditions , self :: no_unresolved_imports :: NoUnresolvedImports , self :: no_unused_expressions :: NoUnusedExpressions , self :: no_useless_catch_binding :: NoUselessCatchBinding , self :: no_useless_undefined :: NoUselessUndefined , self :: no_vue_data_object_declaration :: NoVueDataObjectDeclaration , self :: no_vue_duplicate_keys :: NoVueDuplicateKeys , self :: no_vue_reserved_keys :: NoVueReservedKeys , self :: no_vue_reserved_props :: NoVueReservedProps , self :: use_consistent_arrow_return :: UseConsistentArrowReturn , self :: use_exhaustive_switch_cases :: UseExhaustiveSwitchCases , self :: use_explicit_type :: UseExplicitType , self :: use_max_params :: UseMaxParams , self :: use_qwik_method_usage :: UseQwikMethodUsage , self :: use_qwik_valid_lexical_scope :: UseQwikValidLexicalScope , self :: use_sorted_classes :: UseSortedClasses , self :: use_vue_define_macros_order :: UseVueDefineMacrosOrder , self :: use_vue_multi_word_component_names :: UseVueMultiWordComponentNames ,] } }
+declare_lint_group! { pub Nursery { name : "nursery" , rules : [self :: no_continue :: NoContinue , self :: no_deprecated_imports :: NoDeprecatedImports , self :: no_empty_source :: NoEmptySource , self :: no_floating_promises :: NoFloatingPromises , self :: no_import_cycles :: NoImportCycles , self :: no_increment_decrement :: NoIncrementDecrement , self :: no_jsx_literals :: NoJsxLiterals , self :: no_misused_promises :: NoMisusedPromises , self :: no_next_async_client_component :: NoNextAsyncClientComponent , self :: no_parameters_only_used_in_recursion :: NoParametersOnlyUsedInRecursion , self :: no_react_forward_ref :: NoReactForwardRef , self :: no_shadow :: NoShadow , self :: no_unknown_attribute :: NoUnknownAttribute , self :: no_unnecessary_conditions :: NoUnnecessaryConditions , self :: no_unresolved_imports :: NoUnresolvedImports , self :: no_unused_expressions :: NoUnusedExpressions , self :: no_useless_catch_binding :: NoUselessCatchBinding , self :: no_useless_undefined :: NoUselessUndefined , self :: no_vue_data_object_declaration :: NoVueDataObjectDeclaration , self :: no_vue_duplicate_keys :: NoVueDuplicateKeys , self :: no_vue_reserved_keys :: NoVueReservedKeys , self :: no_vue_reserved_props :: NoVueReservedProps , self :: use_array_sort_compare :: UseArraySortCompare , self :: use_consistent_arrow_return :: UseConsistentArrowReturn , self :: use_exhaustive_switch_cases :: UseExhaustiveSwitchCases , self :: use_explicit_type :: UseExplicitType , self :: use_max_params :: UseMaxParams , self :: use_qwik_method_usage :: UseQwikMethodUsage , self :: use_qwik_valid_lexical_scope :: UseQwikValidLexicalScope , self :: use_sorted_classes :: UseSortedClasses , self :: use_vue_define_macros_order :: UseVueDefineMacrosOrder , self :: use_vue_multi_word_component_names :: UseVueMultiWordComponentNames ,] } }

crates/biome_configuration/src/generated/domain_selector.rs

@@ -0,0 +1,106 @@
+use biome_analyze::{
+    Rule, RuleDiagnostic, RuleDomain, RuleSource, context::RuleContext, declare_lint_rule,
+};
+use biome_console::markup;
+use biome_js_syntax::JsCallExpression;
+use biome_rowan::{AstNode, AstSeparatedList};
+use biome_rule_options::use_array_sort_compare::UseArraySortCompareOptions;
+
+use crate::services::typed::Typed;
+
+declare_lint_rule! {
+    /// Require Array#sort and Array#toSorted calls to always provide a compareFunction.
+    ///
+    /// When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units [ECMA specification](https://262.ecma-international.org/9.0/#sec-sortcompare).
+    ///
+    /// The result is that elements are sorted alphabetically, regardless of their type. For example, when sorting numbers, this results in a "10 before 2" order:
+    ///
+    /// ```ts,file=example.ts,ignore
+    /// [1, 2, 3, 10, 20, 30].sort(); //→ [1, 10, 2, 20, 3, 30]
+    /// ```
+    ///
+    /// This rule reports on any call to the sort methods that do not provide a compare argument.
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```ts,file=invalid.ts,expect_diagnostic
+    /// const array: any[] = [];
+    /// array.sort();
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```ts,file=valid.ts
+    /// const array: any[] = [];
+    /// array.sort((a, b) => a - b);
+    /// ```
+    ///
+    pub UseArraySortCompare {
+        version: "next",
+        name: "useArraySortCompare",
+        language: "js",
+        recommended: false,
+        sources: &[RuleSource::EslintTypeScript("require-array-sort-compare").same()],
+        domains: &[RuleDomain::Project],
+    }
+}
+
+impl Rule for UseArraySortCompare {
+    type Query = Typed<JsCallExpression>;
+    type State = ();
+    type Signals = Option<Self::State>;
+    type Options = UseArraySortCompareOptions;
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let node = ctx.query();
+
+        let binding = node.callee().ok()?.omit_parentheses();
+        let callee = binding.as_js_static_member_expression()?;
+
+        let call_object = callee.object().ok()?;
+        let ty = ctx.type_of_expression(&call_object);
+        if !ty.is_array_of(|_ty| true) {
+            return None;
+        }
+
+        let call_name = callee.member().ok()?.as_js_name()?.to_trimmed_text();
+        if call_name != "sort" && call_name != "toSorted" {
+            return None;
+        }
+
+        let arguments = node.arguments().ok()?.args();
+        if arguments.is_empty() {
+            return Some(());
+        }
+
+        let binding = arguments.first()?.ok()?;
+        let first_arg = binding.as_any_js_expression()?;
+        let ty = ctx.type_of_expression(first_arg);
+        if ty.is_undefined() || ty.is_null() {
+            return Some(());
+        }
+
+        None
+    }
+
+    fn diagnostic(ctx: &RuleContext<Self>, _state: &Self::State) -> Option<RuleDiagnostic> {
+        let node = ctx.query();
+        Some(
+            RuleDiagnostic::new(
+                rule_category!(),
+                node.range(),
+                markup! {
+                    "Compare function missing."
+                },
+            )
+            .note(markup! {
+                "When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units."
+            })
+            .note(markup! {
+                "Add a compare function to prevent unexpected sorting."
+            }),
+        )
+    }
+}

crates/biome_diagnostics_categories/src/categories.rs

@@ -0,0 +1,10 @@
+const anyArray: any[] = [];
+anyArray.sort();
+anyArray.toSorted();
+
+anyArray.sort(undefined);
+anyArray.toSorted(undefined);
+
+const stringArray: string[] = [];
+stringArray.sort();
+stringArray.toSorted();

crates/biome_js_analyze/src/lint/nursery.rs

@@ -0,0 +1,129 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalid.ts
+---
+# Input
+```ts
+const anyArray: any[] = [];
+anyArray.sort();
+anyArray.toSorted();
+
+anyArray.sort(undefined);
+anyArray.toSorted(undefined);
+
+const stringArray: string[] = [];
+stringArray.sort();
+stringArray.toSorted();
+
+```
+
+# Diagnostics
+```
+invalid.ts:2:1 lint/nursery/useArraySortCompare ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Compare function missing.
+  
+    1 │ const anyArray: any[] = [];
+  > 2 │ anyArray.sort();
+      │ ^^^^^^^^^^^^^^^
+    3 │ anyArray.toSorted();
+    4 │ 
+  
+  i When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
+  
+  i Add a compare function to prevent unexpected sorting.
+  
+
+```
+
+```
+invalid.ts:3:1 lint/nursery/useArraySortCompare ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Compare function missing.
+  
+    1 │ const anyArray: any[] = [];
+    2 │ anyArray.sort();
+  > 3 │ anyArray.toSorted();
+      │ ^^^^^^^^^^^^^^^^^^^
+    4 │ 
+    5 │ anyArray.sort(undefined);
+  
+  i When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
+  
+  i Add a compare function to prevent unexpected sorting.
+  
+
+```
+
+```
+invalid.ts:5:1 lint/nursery/useArraySortCompare ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Compare function missing.
+  
+    3 │ anyArray.toSorted();
+    4 │ 
+  > 5 │ anyArray.sort(undefined);
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^
+    6 │ anyArray.toSorted(undefined);
+    7 │ 
+  
+  i When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
+  
+  i Add a compare function to prevent unexpected sorting.
+  
+
+```
+
+```
+invalid.ts:6:1 lint/nursery/useArraySortCompare ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Compare function missing.
+  
+    5 │ anyArray.sort(undefined);
+  > 6 │ anyArray.toSorted(undefined);
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    7 │ 
+    8 │ const stringArray: string[] = [];
+  
+  i When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
+  
+  i Add a compare function to prevent unexpected sorting.
+  
+
+```
+
+```
+invalid.ts:9:1 lint/nursery/useArraySortCompare ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Compare function missing.
+  
+     8 │ const stringArray: string[] = [];
+   > 9 │ stringArray.sort();
+       │ ^^^^^^^^^^^^^^^^^^
+    10 │ stringArray.toSorted();
+    11 │ 
+  
+  i When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
+  
+  i Add a compare function to prevent unexpected sorting.
+  
+
+```
+
+```
+invalid.ts:10:1 lint/nursery/useArraySortCompare ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Compare function missing.
+  
+     8 │ const stringArray: string[] = [];
+     9 │ stringArray.sort();
+  > 10 │ stringArray.toSorted();
+       │ ^^^^^^^^^^^^^^^^^^^^^^
+    11 │ 
+  
+  i When called without a compare function, Array#sort() and Array#toSorted() converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
+  
+  i Add a compare function to prevent unexpected sorting.
+  
+
+```

crates/biome_js_analyze/src/lint/nursery/use_array_sort_compare.rs

@@ -0,0 +1,10 @@
+/* should not generate diagnostics */
+const array: any[] = [];
+array.sort((a, b) => a - b);
+array.sort((a, b) => a.localeCompare(b));
+array.toSorted((a, b) => a - b);
+
+const userDefinedType = {
+	sort: () => { }
+};
+userDefinedType.sort();