rome · ematipico · Oct 17, 2022 · Oct 10, 2022 · Oct 11, 2022 · Oct 12, 2022
diff --git a/crates/rome_diagnostics_categories/src/categories.rs b/crates/rome_diagnostics_categories/src/categories.rs
@@ -59,6 +59,7 @@ define_dategories! {
     "lint/nursery/useValidAnchor": "https://rome.tools/docs/lint/rules/useValidAnchor",
     "lint/nursery/useKeyWithClickEvents": "https://rome.tools/docs/lint/rules/useKeyWithClickEvents",
     "lint/nursery/noRestrictedGlobals": "https://rome.tools/docs/lint/rules/noRestrictedGlobals",
+    "lint/nursery/useFlatMap": "https://rome.tools/docs/lint/rules/useFlatMap",
     "lint/nursery/noPositiveTabindex": "https://rome.tools/docs/lint/rules/noPositiveTabindex",
     "lint/nursery/noConstAssign": "https://rome.tools/docs/lint/rules/noConstAssign",
     "lint/nursery/noExplicitAny": "https://rome.tools/docs/lint/rules/noExplicitAny",

diff --git a/crates/rome_js_analyze/src/analyzers/nursery.rs b/crates/rome_js_analyze/src/analyzers/nursery.rs
diff --git a/crates/rome_js_analyze/src/analyzers/nursery/use_flat_map.rs b/crates/rome_js_analyze/src/analyzers/nursery/use_flat_map.rs
@@ -0,0 +1,142 @@
+use crate::JsRuleAction;
+use rome_analyze::context::RuleContext;
+use rome_analyze::{declare_rule, ActionCategory, Ast, Rule, RuleDiagnostic};
+use rome_console::markup;
+use rome_diagnostics::Applicability;
+use rome_js_factory::make::{ident, js_name};
+use rome_js_syntax::{JsAnyExpression, JsAnyName, JsCallExpression};
+use rome_rowan::{AstNode, AstSeparatedList, BatchMutationExt};
+
+declare_rule! {
+    /// Promotes the use of `.flatMap()` when `map().flat()` are used together.
+    ///
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```js,expect_diagnostic
+    /// const array = ["split", "the text", "into words"];
+    /// array.map(sentence => sentence.split(' ')).flat();
+    /// ```
+    ///
+    /// ```js,expect_diagnostic
+    /// const array = ["split", "the text", "into words"];
+    /// array.map(sentence => sentence.split(' ')).flat(1);
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```js
+    /// const array = ["split", "the text", "into words"];
+    /// array.map(sentence => sentence.split(' ')).flat(2);
+    /// ```
+    ///
+    pub(crate) UseFlatMap {
+        version: "10.0.0",
+        name: "useFlatMap",
+        recommended: false,
+    }
+}
+
+impl Rule for UseFlatMap {
+    type Query = Ast<JsCallExpression>;
+    type State = JsCallExpression;
+    type Signals = Option<Self::State>;
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let node = ctx.query();
+        let arguments = node.arguments().ok()?.args();
+        // Probably not a `flat` call.
+        if arguments.len() > 1 {
+            return None;
+        }
+        if let Some(first_argument) = arguments.first() {
+            let first_argument = first_argument.ok()?;
+            let first_argument = first_argument
+                .as_js_any_expression()?
+                .as_js_any_literal_expression()?
+                .as_js_number_literal_expression()?;
+
+            if first_argument.value_token().ok()?.text_trimmed() != "1" {
+                return None;
+            }
+        }
+        let static_member_expression = node.callee().ok()?;
+        let static_member_expression = static_member_expression.as_js_static_member_expression()?;
+        let flat_member_name = static_member_expression
+            .member()
+            .ok()?
+            .as_js_name()?
+            .value_token()
+            .ok()?;
+        if flat_member_name.text_trimmed() == "flat" {
+            let call_expression = static_member_expression.object().ok()?;
+            let call_expression = call_expression.as_js_call_expression()?;
+            let map_call_arguments = call_expression.arguments().ok()?.args();
+
+            // probably not a `.map` all coming from an array
+            if map_call_arguments.len() > 2 || map_call_arguments.len() < 1 {
+                return None;
+            }
+
+            let map_static_member_expression = call_expression.callee().ok()?;
+            let map_static_member_expression =
+                map_static_member_expression.as_js_static_member_expression()?;
+            let map_member_name = map_static_member_expression
+                .member()
+                .ok()?
+                .as_js_name()?
+                .value_token()
+                .ok()?;
+
+            if map_member_name.text_trimmed() == "map" {
+                return Some(call_expression.clone());
+            }
+        }
+
+        None
+    }
+
+    fn diagnostic(ctx: &RuleContext<Self>, _state: &Self::State) -> Option<RuleDiagnostic> {
+        let node = ctx.query();
+
+        Some(RuleDiagnostic::new(
+            rule_category!(),
+            node.syntax().text_trimmed_range(),
+            markup! {
+                "The call chain "<Emphasis>".map().flat()"</Emphasis>" can be replaced with a single "<Emphasis>".flatMap()"</Emphasis>" call."
+            },
+        ))
+    }
+
+    fn action(ctx: &RuleContext<Self>, flat_call: &Self::State) -> Option<JsRuleAction> {
+        let node = ctx.query();
+        let mut mutation = ctx.root().begin();
+
+        let flat_call = flat_call.clone();
+        let old_static_member_expression = flat_call.callee().ok()?;
+        let old_static_member_expression =
+            old_static_member_expression.as_js_static_member_expression()?;
+        let member = js_name(ident("flatMap"));
+
+        let flat_map_member_expression = old_static_member_expression
+            .clone()
+            .with_member(JsAnyName::JsName(member));
+
+        let flat_map_call = flat_call.with_callee(JsAnyExpression::JsStaticMemberExpression(
+            flat_map_member_expression,
+        ));
+
+        mutation.replace_node(node.clone(), flat_map_call);
+
+        Some(JsRuleAction {
+            mutation,
+            message: markup! {"Replace the chain with "<Emphasis>".flatMap()"</Emphasis>"."}
+                .to_owned(),
+            category: ActionCategory::QuickFix,
+            applicability: Applicability::Always,
+        })
+    }
+}
diff --git a/crates/rome_js_analyze/src/lib.rs b/crates/rome_js_analyze/src/lib.rs
@@ -128,10 +128,7 @@ mod tests {
     #[ignore]
     #[test]
     fn quick_test() {
-        const SOURCE: &str = r#"function f(event, error) {
-    console.log(event);
-    console.log(error);
-}
+        const SOURCE: &str = r#"[0, [12]].map(Number).flat()
         "#;
 
         let parsed = parse(SOURCE, FileId::zero(), SourceType::jsx());

diff --git a/crates/rome_js_analyze/tests/specs/nursery/useFlatMap.js b/crates/rome_js_analyze/tests/specs/nursery/useFlatMap.js
@@ -0,0 +1,12 @@
+// invalid
+[0, [12]].map(Number).flat();
+[0, [12], [[16]]].map(Number).flat(1);
+[0, [12], [[16]]].map((element) => {}).flat(1);
+[0, [12], [[16]]].map((element, index) => {}).flat(1);
+[0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+// valid
+[0, [12], [[16]]].map(Number).flat(2);
+array.flat().map(Number);
+array.map(Number).flat(customFn);
+MyObject.map(one, two, tree).flat();
+MyObject.map().flat(1, "test")
diff --git a/crates/rome_js_analyze/tests/specs/nursery/useFlatMap.js.snap b/crates/rome_js_analyze/tests/specs/nursery/useFlatMap.js.snap
@@ -0,0 +1,140 @@
+---
+source: crates/rome_js_analyze/tests/spec_tests.rs
+expression: useFlatMap.js
+---
+# Input
+```js
+// invalid
+[0, [12]].map(Number).flat();
+[0, [12], [[16]]].map(Number).flat(1);
+[0, [12], [[16]]].map((element) => {}).flat(1);
+[0, [12], [[16]]].map((element, index) => {}).flat(1);
+[0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+// valid
+[0, [12], [[16]]].map(Number).flat(2);
+array.flat().map(Number);
+array.map(Number).flat(customFn);
+MyObject.map(one, two, tree).flat();
+MyObject.map().flat(1, "test")
+```
+
+# Diagnostics
+```
+useFlatMap.js:2:1 lint/nursery/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The call chain .map().flat() can be replaced with a single .flatMap() call.
+
+    1 │ // invalid
+  > 2 │ [0, [12]].map(Number).flat();
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    3 │ [0, [12], [[16]]].map(Number).flat(1);
+    4 │ [0, [12], [[16]]].map((element) => {}).flat(1);
+
+  i Safe fix: Replace the chain with .flatMap().
+
+     1  1 │   // invalid
+     2    │ - [0,·[12]].map(Number).flat();
+        2 │ + [0,·[12]].flatMap(Number);
+     3  3 │   [0, [12], [[16]]].map(Number).flat(1);
+     4  4 │   [0, [12], [[16]]].map((element) => {}).flat(1);
+
+
+```
+
+```
+useFlatMap.js:3:1 lint/nursery/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The call chain .map().flat() can be replaced with a single .flatMap() call.
+
+    1 │ // invalid
+    2 │ [0, [12]].map(Number).flat();
+  > 3 │ [0, [12], [[16]]].map(Number).flat(1);
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    4 │ [0, [12], [[16]]].map((element) => {}).flat(1);
+    5 │ [0, [12], [[16]]].map((element, index) => {}).flat(1);
+
+  i Safe fix: Replace the chain with .flatMap().
+
+     1  1 │   // invalid
+     2  2 │   [0, [12]].map(Number).flat();
+     3    │ - [0,·[12],·[[16]]].map(Number).flat(1);
+        3 │ + [0,·[12],·[[16]]].flatMap(Number);
+     4  4 │   [0, [12], [[16]]].map((element) => {}).flat(1);
+     5  5 │   [0, [12], [[16]]].map((element, index) => {}).flat(1);
+
+
+```
+
+```
+useFlatMap.js:4:1 lint/nursery/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The call chain .map().flat() can be replaced with a single .flatMap() call.
+
+    2 │ [0, [12]].map(Number).flat();
+    3 │ [0, [12], [[16]]].map(Number).flat(1);
+  > 4 │ [0, [12], [[16]]].map((element) => {}).flat(1);
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    5 │ [0, [12], [[16]]].map((element, index) => {}).flat(1);
+    6 │ [0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+
+  i Safe fix: Replace the chain with .flatMap().
+
+     2  2 │   [0, [12]].map(Number).flat();
+     3  3 │   [0, [12], [[16]]].map(Number).flat(1);
+     4    │ - [0,·[12],·[[16]]].map((element)·=>·{}).flat(1);
+        4 │ + [0,·[12],·[[16]]].flatMap((element)·=>·{});
+     5  5 │   [0, [12], [[16]]].map((element, index) => {}).flat(1);
+     6  6 │   [0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+
+
+```
+
+```
+useFlatMap.js:5:1 lint/nursery/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The call chain .map().flat() can be replaced with a single .flatMap() call.
+
+    3 │ [0, [12], [[16]]].map(Number).flat(1);
+    4 │ [0, [12], [[16]]].map((element) => {}).flat(1);
+  > 5 │ [0, [12], [[16]]].map((element, index) => {}).flat(1);
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    6 │ [0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+    7 │ // valid
+
+  i Safe fix: Replace the chain with .flatMap().
+
+     3  3 │   [0, [12], [[16]]].map(Number).flat(1);
+     4  4 │   [0, [12], [[16]]].map((element) => {}).flat(1);
+     5    │ - [0,·[12],·[[16]]].map((element,·index)·=>·{}).flat(1);
+        5 │ + [0,·[12],·[[16]]].flatMap((element,·index)·=>·{});
+     6  6 │   [0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+     7  7 │   // valid
+
+
+```
+
+```
+useFlatMap.js:6:1 lint/nursery/useFlatMap  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The call chain .map().flat() can be replaced with a single .flatMap() call.
+
+    4 │ [0, [12], [[16]]].map((element) => {}).flat(1);
+    5 │ [0, [12], [[16]]].map((element, index) => {}).flat(1);
+  > 6 │ [0, [12], [[16]]].map((element, index, array) => {}).flat(1);
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    7 │ // valid
+    8 │ [0, [12], [[16]]].map(Number).flat(2);
+
+  i Safe fix: Replace the chain with .flatMap().
+
+     4  4 │   [0, [12], [[16]]].map((element) => {}).flat(1);
+     5  5 │   [0, [12], [[16]]].map((element, index) => {}).flat(1);
+     6    │ - [0,·[12],·[[16]]].map((element,·index,·array)·=>·{}).flat(1);
+        6 │ + [0,·[12],·[[16]]].flatMap((element,·index,·array)·=>·{});
+     7  7 │   // valid
+     8  8 │   [0, [12], [[16]]].map(Number).flat(2);
+
+
+```
+
+
diff --git a/crates/rome_service/src/configuration/linter/rules.rs b/crates/rome_service/src/configuration/linter/rules.rs
diff --git a/editors/vscode/configuration_schema.json b/editors/vscode/configuration_schema.json
@@ -688,6 +688,16 @@
             }
           ]
         },
+        "useFlatMap": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "useFragmentSyntax": {
           "anyOf": [
             {

diff --git a/npm/backend-jsonrpc/src/workspace.ts b/npm/backend-jsonrpc/src/workspace.ts
diff --git a/website/src/docs/lint/rules/index.md b/website/src/docs/lint/rules/index.md