Add prefer-flat-map rule (#284)

Author: MrHen

docs/rules/prefer-flat-map.md

@@ -0,0 +1,19 @@
+# Prefer `.flatMap(…)` over `.map(…).flat()`
+
+[`Array#flatMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap) performs [`Array#map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) and [`Array#flat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat) in one step.
+
+This rule is fixable.
+
+
+## Fail
+
+```js
+[1, 2, 3].map(i => [i]).flat();
+```
+
+## Pass
+
+```js
+[1, 2, 3].flatMap(i => [i]);
+[1, 2, 3].map(i => [i]).foo().flat();
+```

index.js

@@ -40,6 +40,7 @@ module.exports = {
 				'unicorn/number-literal-case': 'error',
 				'unicorn/prefer-add-event-listener': 'error',
 				'unicorn/prefer-exponentiation-operator': 'error',
+				'unicorn/prefer-flat-map': 'error',
 				'unicorn/prefer-includes': 'error',
 				'unicorn/prefer-node-append': 'error',
 				'unicorn/prefer-node-remove': 'error',

readme.md

@@ -58,6 +58,7 @@ Configure it in `package.json`.
 			"unicorn/number-literal-case": "error",
 			"unicorn/prefer-add-event-listener": "error",
 			"unicorn/prefer-exponentiation-operator": "error",
+			"unicorn/prefer-flat-map": "error",
 			"unicorn/prefer-includes": "error",
 			"unicorn/prefer-node-append": "error",
 			"unicorn/prefer-node-remove": "error",
@@ -100,6 +101,7 @@ Configure it in `package.json`.
 - [number-literal-case](docs/rules/number-literal-case.md) - Enforce lowercase identifier and uppercase value for number literals. *(fixable)*
 - [prefer-add-event-listener](docs/rules/prefer-add-event-listener.md) - Prefer `addEventListener` over `on`-functions. *(fixable)*
 - [prefer-exponentiation-operator](docs/rules/prefer-exponentiation-operator.md) - Prefer the exponentiation operator over `Math.pow()` *(fixable)*
+- [prefer-flat-map](docs/rules/prefer-flat-map.md) - Prefer `.flatMap(…)` over `.map(…).flat()`. *(fixable)*
 - [prefer-includes](docs/rules/prefer-includes.md) - Prefer `.includes()` over `.indexOf()` when checking for existence or non-existence. *(fixable)*
 - [prefer-node-append](docs/rules/prefer-node-append.md) - Prefer `append` over `appendChild`. *(fixable)*
 - [prefer-node-remove](docs/rules/prefer-node-remove.md) - Prefer `remove` over `parentNode.removeChild` and `parentElement.removeChild`. *(fixable)*

rules/prefer-flat-map.js

@@ -0,0 +1,123 @@
+'use strict';
+const getDocsUrl = require('./utils/get-docs-url');
+const isMethodNamed = require('./utils/is-method-named');
+
+const MESSAGE_ID = 'preferFlatMap';
+
+const report = (context, nodeFlat, nodeMap) => {
+	const source = context.getSourceCode();
+
+	// Node covers:
+	//   map(…).flat();
+	//          ^^^^
+	//   (map(…)).flat();
+	//            ^^^^
+	const flatIdentifer = nodeFlat.callee.property;
+
+	// Location will be:
+	//   map(…).flat();
+	//         ^
+	//   (map(…)).flat();
+	//           ^
+	const dot = source.getTokenBefore(flatIdentifer);
+
+	// Location will be:
+	//   map(…).flat();
+	//                ^
+	//   (map(…)).flat();
+	//                  ^
+	const maybeSemicolon = source.getTokenAfter(nodeFlat);
+	const hasSemicolon = Boolean(maybeSemicolon) && maybeSemicolon.value === ';';
+
+	// Location will be:
+	//   (map(…)).flat();
+	//          ^
+	const tokenBetween = source.getLastTokenBetween(nodeMap, dot);
+
+	// Location will be:
+	//   map(…).flat();
+	//        ^
+	//   (map(…)).flat();
+	//          ^
+	const beforeSemicolon = tokenBetween || nodeMap;
+
+	// Location will be:
+	//   map(…).flat();
+	//               ^
+	//   (map(…)).flat();
+	//                 ^
+	const fixEnd = nodeFlat.end;
+
+	// Location will be:
+	//   map(…).flat();
+	//         ^
+	//   (map(…)).flat();
+	//           ^
+	const fixStart = dot.start;
+
+	const mapProperty = nodeMap.callee.property;
+
+	context.report({
+		node: nodeFlat,
+		messageId: MESSAGE_ID,
+		fix: fixer => {
+			const fixings = [
+				// Removes:
+				//   map(…).flat();
+				//         ^^^^^^^
+				//   (map(…)).flat();
+				//           ^^^^^^^
+				fixer.removeRange([fixStart, fixEnd]),
+
+				// Renames:
+				//   map(…).flat();
+				//   ^^^
+				//   (map(…)).flat();
+				//    ^^^
+				fixer.replaceText(mapProperty, 'flatMap')
+			];
+
+			if (hasSemicolon) {
+				// Moves semicolon to:
+				//   map(…).flat();
+				//         ^
+				//   (map(…)).flat();
+				//           ^
+				fixings.push(fixer.insertTextAfter(beforeSemicolon, ';'));
+				fixings.push(fixer.remove(maybeSemicolon));
+			}
+
+			return fixings;
+		}
+	});
+};
+
+const create = context => ({
+	CallExpression: node => {
+		if (!isMethodNamed(node, 'flat')) {
+			return;
+		}
+
+		const parent = node.callee.object;
+
+		if (!isMethodNamed(parent, 'map')) {
+			return;
+		}
+
+		report(context, node, parent);
+	}
+});
+
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			url: getDocsUrl(__filename)
+		},
+		fixable: 'code',
+		messages: {
+			[MESSAGE_ID]: 'Prefer `.flatMap(…)` over `.map(…).flat()`.'
+		}
+	}
+};

rules/prefer-includes.js

@@ -1,14 +1,6 @@
 'use strict';
 const getDocsUrl = require('./utils/get-docs-url');
-
-const isIndexOf = node => {
-	return (
-		node.type === 'CallExpression' &&
-		node.callee.type === 'MemberExpression' &&
-		node.callee.property.type === 'Identifier' &&
-		node.callee.property.name === 'indexOf'
-	);
-};
+const isMethodNamed = require('./utils/is-method-named');
 
 const isNegativeOne = (operator, value) => operator === '-' && value === 1;
 
@@ -33,7 +25,7 @@ const create = context => ({
 	BinaryExpression: node => {
 		const {left, right} = node;
 
-		if (isIndexOf(left)) {
+		if (isMethodNamed(left, 'indexOf')) {
 			const target = left.callee.object;
 			const pattern = left.arguments[0];
 

rules/utils/is-method-named.js

@@ -0,0 +1,10 @@
+const isMethodNamed = (node, name) => {
+	return (
+		node.type === 'CallExpression' &&
+		node.callee.type === 'MemberExpression' &&
+		node.callee.property.type === 'Identifier' &&
+		node.callee.property.name === name
+	);
+};
+
+module.exports = isMethodNamed;

test/prefer-flat-map.js

@@ -0,0 +1,120 @@
+import test from 'ava';
+import avaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../rules/prefer-flat-map';
+
+const ruleTester = avaRuleTester(test, {
+	env: {
+		es6: true
+	}
+});
+
+const error = {
+	ruleId: 'prefer-flat-map',
+	messageId: 'preferFlatMap'
+};
+
+ruleTester.run('prefer-flat-map', rule, {
+	valid: [
+		'const bar = [1,2,3].map()',
+		'const bar = [1,2,3].map(i => i)',
+		'const bar = [1,2,3].map((i) => i)',
+		'const bar = [1,2,3].map((i) => { return i; })',
+		'const bar = foo.map(i => i)',
+		'const bar = [[1],[2],[3]].flat()',
+		'const bar = [1,2,3].map(i => [i]).sort().flat()',
+		`
+			let bar = [1,2,3].map(i => [i]);
+			bar = bar.flat();
+		`
+	],
+	invalid: [
+		{
+			code: 'const bar = [1,2,3].map(i => [i]).flat()',
+			output: 'const bar = [1,2,3].flatMap(i => [i])',
+			errors: [error]
+		},
+		{
+			code: 'const bar = [1,2,3].map((i) => [i]).flat()',
+			output: 'const bar = [1,2,3].flatMap((i) => [i])',
+			errors: [error]
+		},
+		{
+			code: 'const bar = [1,2,3].map((i) => { return [i]; }).flat()',
+			output: 'const bar = [1,2,3].flatMap((i) => { return [i]; })',
+			errors: [error]
+		},
+		{
+			code: 'const bar = [1,2,3].map(foo).flat()',
+			output: 'const bar = [1,2,3].flatMap(foo)',
+			errors: [error]
+		},
+		{
+			code: 'const bar = foo.map(i => [i]).flat()',
+			output: 'const bar = foo.flatMap(i => [i])',
+			errors: [error]
+		},
+		{
+			code: 'const bar = { map: () => {} }.map(i => [i]).flat()',
+			output: 'const bar = { map: () => {} }.flatMap(i => [i])',
+			errors: [error]
+		},
+		{
+			code: 'const bar = [1,2,3].map(i => i).map(i => [i]).flat()',
+			output: 'const bar = [1,2,3].map(i => i).flatMap(i => [i])',
+			errors: [error]
+		},
+		{
+			code: 'const bar = [1,2,3].sort().map(i => [i]).flat()',
+			output: 'const bar = [1,2,3].sort().flatMap(i => [i])',
+			errors: [error]
+		},
+		{
+			code: 'const bar = (([1,2,3].map(i => [i]))).flat()',
+			output: 'const bar = (([1,2,3].flatMap(i => [i])))',
+			errors: [error]
+		},
+		{
+			code: `
+				let bar = [1,2,3].map(i => {
+					return [i];
+				}).flat();
+			`,
+			output: `
+				let bar = [1,2,3].flatMap(i => {
+					return [i];
+				});
+			`,
+			errors: [error]
+		},
+		{
+			code: 'let bar = [1,2,3].map(i => {\nreturn [i];\n})\n.flat();',
+			output: 'let bar = [1,2,3].flatMap(i => {\nreturn [i];\n});\n',
+			errors: [error]
+		},
+		{
+			code: 'let bar = [1,2,3].map(i => {\nreturn [i];\n}) // comment\n.flat();',
+			output: 'let bar = [1,2,3].flatMap(i => {\nreturn [i];\n}); // comment\n',
+			errors: [error]
+		},
+		{
+			code: 'let bar = [1,2,3].map(i => {\nreturn [i];\n}) // comment\n.flat(); // other',
+			output: 'let bar = [1,2,3].flatMap(i => {\nreturn [i];\n}); // comment\n // other',
+			errors: [error]
+		},
+		{
+			code: 'let bar = [1,2,3]\n  .map(i => { return [i]; })\n  .flat();',
+			output: 'let bar = [1,2,3]\n  .flatMap(i => { return [i]; });\n  ',
+			errors: [error]
+		},
+		{
+			code: 'let bar = [1,2,3].map(i => { return [i]; })\n  .flat();',
+			output: 'let bar = [1,2,3].flatMap(i => { return [i]; });\n  ',
+			errors: [error]
+		},
+		{
+			code: 'let bar = [1,2,3] . map( x => y ) . flat () // 🤪',
+			output: 'let bar = [1,2,3] . flatMap( x => y )  // 🤪',
+			errors: [error]
+		}
+	]
+});