@putout/plugin-return 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# @putout/plugin-return [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-return.svg?style=flat&longCache=true
+[NPMURL]: https://npmjs.org/package/@putout/plugin-return "npm"
+
+> The `return` statement ends function execution and specifies a value to be returned to the function caller.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return)
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to transform to new **Node.js** API and apply best practices.
+
+## Install
+
+```
+npm i putout @putout/plugin-return -D
+```
+
+## Rules
+
+- ✅ [apply-early-return](#apply-early-return);
+- ✅ [convert-from-continue](#convert-from-continue);
+- ✅ [convert-from-break](#convert-from-continue);
+- ✅ [merge-with-next-sibling](#merge-with-next-sibling);
+- ✅ [remove-useless](#remove-useless);
+- ✅ [simplify-boolean](#simplify-boolean);
+
+## Config
+
+```json
+{
+    "rules": {
+        "return/apply-early-return": "on",
+        "return/convert-from-continue": "on",
+        "return/convert-from-break": "on",
+        "return/merge-with-next-sibling": "on",
+        "return/remove-useless": "on",
+        "return/simplify-boolean": "on"
+    }
+}
+```
+
+## apply-early-return
+
+> In short, an **early return** provides functionality so the result of a conditional statement can be returned as soon as a result is available, rather than wait until the rest of the function is run.
+>
+> (c) [dev.to](https://dev.to/jenniferlynparsons/early-returns-in-javascript-5hfb)
+
+### ❌ Example of incorrect code
+
+```js
+function get(a) {
+    const b = 0;
+    
+    {
+        if (a > 0)
+            return 5;
+        
+        return 7;
+    }
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function get(a) {
+    if (a > 0)
+        return 5;
+    
+    return 7;
+}
+```
+
+## convert-from-continue
+
+> The `continue` statement terminates execution of the statements in the current iteration of the current or labeled loop, and continues execution of the loop with the next iteration.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/continue)
+
+> `SyntaxError: Illegal continue statement: no surrounding iteration statement`
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Bad_continue)
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/a321ee4d76a066c17835b4aa50f91499/e0d161c7bd8b0d63ebf8d5a5026529c2fb8e0cb3).
+
+### ❌ Example of incorrect code
+
+```ts
+function x() {
+    if (a)
+        continue;
+    
+    return b;
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function x() {
+    if (a)
+        return;
+    
+    return b;
+}
+```
+
+## convert-from-break
+
+> The `break` statement terminates the current loop or switch statement and transfers program control to the statement following the terminated statement.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax)
+
+> `SyntaxError: unlabeled break must be inside loop or switch`
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Bad_break)
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/a321ee4d76a066c17835b4aa50f91499/10646f7383b8d58cda02417485d5281955da95be).
+
+### ❌ Example of incorrect code
+
+```ts
+function x() {
+    if (a)
+        break;
+
+    return false;
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function x() {
+    if (a)
+        return;
+    
+    return false;
+}
+```
+
+## merge-with-next-sibling
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/2cb7e8836ce0adb6009f21859f8a0c15/9eea5b36a4f6664b05f2f9f0abd271a62a4dbbbe).
+
+### ❌ Example of incorrect code
+
+```js
+function x() {
+    return;
+    {
+        hello: 'world';
+    }
+
+    return;
+    5;
+
+    return;
+    a ? 2 : 3;
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function x() {
+    return {
+        hello: 'world',
+    };
+    
+    return 5;
+    
+    return a ? 2 : 3;
+}
+```
+
+### remove-useless
+
+### ❌ Example of incorrect code
+
+```js
+const traverse = ({push}) => {
+    return {
+        ObjectExpression(path) {
+            push(path);
+        },
+    };
+};
+```
+
+### ✅ Example of correct code
+
+```js
+const traverse = ({push}) => ({
+    ObjectExpression(path) {
+        push(path);
+    },
+});
+```
+
+## simplify-boolean
+
+Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/304035b9529830cf20e76e9a1f35f14c/39c743921c6bfad3984a3989f25c2986ab51e8c8).
+
+### ❌ Example of incorrect code
+
+```js
+function isA(a, b) {
+    if (a.length === b.length)
+        return true;
+
+    return false;
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function isA(a, b) {
+    return a.length !== b.length;
+}
+```
+
+## License
+
+MIT

package/lib/apply-early/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const {operator, types} = require('putout');
+
+const {isIdentifier} = types;
+const {compare, remove} = operator;
+
+module.exports.report = () => `Apply early return`;
+
+const FROM = `
+    if (__a)
+        __b = __c;
+    else
+        __b = __e;
+`;
+
+const TO = `{
+    if (__a)
+        return __c;
+    
+    return __e;
+}`;
+
+module.exports.match = () => ({
+    [FROM]: ({__b}, path) => {
+        if (!isIdentifier(__b))
+            return;
+        
+        const nextNode = path.getNextSibling();
+        
+        return compare(nextNode, `return ${__b.name}`);
+    },
+});
+
+module.exports.replace = () => ({
+    [FROM]: (vars, path) => {
+        remove(path.getNextSibling());
+        
+        return TO;
+    },
+});

package/lib/convert-from-break/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const {types, operator} = require('putout');
+const {replaceWith} = operator;
+const {
+    isLabeledStatement,
+    ReturnStatement,
+} = types;
+
+module.exports.report = () => `Use 'return' instead of 'break'`;
+
+module.exports.fix = (path) => {
+    replaceWith(path, ReturnStatement());
+};
+
+module.exports.traverse = ({push}) => ({
+    BreakStatement(path) {
+        if (path.node.label) {
+            const {name} = path.node.label;
+            
+            const labeledPath = path.find(isLabeledStatement);
+            
+            if (labeledPath && name === labeledPath.node.label.name)
+                return;
+        }
+        
+        const upperPath = path.find(isUpperScope);
+        
+        if (upperPath.isLoop())
+            return;
+        
+        if (upperPath.isSwitchStatement())
+            return;
+        
+        push(path);
+    },
+});
+
+const isUpperScope = (path) => {
+    if (path.isLoop())
+        return true;
+    
+    if (path.isProgram())
+        return true;
+    
+    if (path.isSwitchStatement())
+        return true;
+    
+    return path.isFunction();
+};

package/lib/convert-from-continue/index.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const {types, operator} = require('putout');
+const {
+    isLabeledStatement,
+    ReturnStatement,
+} = types;
+
+const {replaceWith} = operator;
+
+module.exports.report = () => `Use 'return' instead of 'continue'`;
+
+module.exports.fix = (path) => {
+    replaceWith(path, ReturnStatement());
+};
+
+module.exports.traverse = ({push}) => ({
+    ContinueStatement(path) {
+        if (path.node.label) {
+            const {name} = path.node.label;
+            const labeledPath = path.find(isLabeledStatement);
+            
+            if (labeledPath && name === labeledPath.node.label.name)
+                return;
+        }
+        
+        const upperPath = path.find(isUpperScope);
+        
+        if (upperPath.isLoop())
+            return;
+        
+        push(path);
+    },
+});
+
+const isUpperScope = (path) => {
+    if (path.isProgram())
+        return true;
+    
+    if (path.isLoop())
+        return true;
+    
+    return path.isFunction();
+};

package/lib/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const applyEarly = require('./apply-early');
+const convertFromContinue = require('./convert-from-continue');
+const convertFromBreak = require('./convert-from-break');
+const mergeWithNextSibling = require('./merge-with-next-sibling');
+const simplifyBoolean = require('./simplify-boolean');
+
+module.exports.rules = {
+    'apply-early': applyEarly,
+    'convert-from-continue': convertFromContinue,
+    'convert-from-break': convertFromBreak,
+    'merge-with-next-sibling': mergeWithNextSibling,
+    'simplify-boolean': simplifyBoolean,
+};

package/lib/merge-with-next-sibling/index.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const {types, operator} = require('putout');
+const {remove} = operator;
+const {
+    ObjectExpression,
+    ObjectProperty,
+} = types;
+
+module.exports.report = () => `Merge 'return' with next sibling`;
+
+module.exports.fix = ({path, nextPath}) => {
+    let {node} = nextPath;
+    
+    if (!nextPath.isBlockStatement()) {
+        node = node.expression;
+    } else {
+        const properties = [];
+        
+        for (const {label, body} of nextPath.node.body) {
+            const property = ObjectProperty(label, body.expression);
+            properties.push(property);
+        }
+        
+        node = ObjectExpression(properties);
+    }
+    
+    path.node.argument = node;
+    remove(nextPath);
+};
+module.exports.traverse = ({push}) => ({
+    ReturnStatement(path) {
+        if (path.node.argument)
+            return false;
+        
+        const nextPath = path.getNextSibling();
+        
+        if (!nextPath.isExpressionStatement() && !nextPath.isBlockStatement())
+            return;
+        
+        push({
+            path,
+            nextPath,
+        });
+    },
+});

package/lib/remove-useless/index.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const {types, operator} = require('putout');
+const {replaceWith} = operator;
+const {
+    isIdentifier,
+    isLiteral,
+    isAssignmentPattern,
+} = types;
+
+module.exports.report = () => `Avoid useless 'return'`;
+
+module.exports.include = () => [
+    'ArrowFunctionExpression',
+];
+
+module.exports.fix = (path) => {
+    const bodyPath = path.get('body');
+    const returnPath = bodyPath.get('body.0');
+    
+    replaceWith(bodyPath, returnPath.node.argument);
+};
+
+module.exports.filter = (path) => {
+    const bodyPath = path.get('body');
+    
+    if (!bodyPath.isBlockStatement())
+        return false;
+    
+    if (hasComplexParams(path))
+        return false;
+    
+    const first = bodyPath.get('body.0');
+    
+    if (!first)
+        return false;
+    
+    if (!first.isReturnStatement())
+        return false;
+    
+    if (hasComments(first))
+        return false;
+    
+    const argPath = first.get('argument');
+    
+    if (!argPath.node)
+        return false;
+    
+    if (isChainCall(argPath))
+        return false;
+    
+    if (!isSimpleArgs(argPath))
+        return false;
+    
+    if (argPath.isNewExpression())
+        return false;
+    
+    if (argPath.isAwaitExpression())
+        return false;
+    
+    if (argPath.isTemplateLiteral())
+        return false;
+    
+    return !argPath.isLogicalExpression();
+};
+
+const isChainCall = (path) => {
+    if (!path.isCallExpression())
+        return false;
+    
+    const calleePath = path.get('callee');
+    
+    if (calleePath.isMemberExpression())
+        return true;
+    
+    const objectPath = calleePath.get('object');
+    
+    return objectPath.isCallExpression();
+};
+
+const isSimpleArgs = (path) => {
+    if (!path.isCallExpression())
+        return true;
+    
+    for (const arg of path.node.arguments) {
+        if (isIdentifier(arg))
+            continue;
+        
+        if (isLiteral(arg))
+            continue;
+        
+        return false;
+    }
+    
+    return true;
+};
+
+function hasComments(path) {
+    const {leadingComments} = path.node;
+    return leadingComments?.length;
+}
+
+function hasComplexParams(path) {
+    for (const param of path.get('params')) {
+        if (isAssignmentPattern(param))
+            return true;
+    }
+    
+    return false;
+}

package/lib/simplify-boolean/index.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const {operator, types} = require('putout');
+
+const {
+    compareAny,
+    replaceWith,
+    remove,
+} = operator;
+
+const {
+    UnaryExpression,
+    isUnaryExpression,
+    ReturnStatement,
+} = types;
+
+module.exports.report = () => `Simplify boolean return`;
+
+module.exports.match = () => ({
+    'if (__a) return __bool__a;': checkNext,
+});
+
+module.exports.replace = () => ({
+    'if (__a) return __bool__a;'({__a, __bool__a}, path) {
+        const next = path.getNextSibling();
+        
+        remove(next);
+        
+        if (__bool__a.value)
+            return 'return __a';
+        
+        if (isUnaryExpression(__a, {operator: '!'})) {
+            const {argument} = __a;
+            return ReturnStatement(argument);
+        }
+        
+        const unary = UnaryExpression('!', __a);
+        replaceWith(path.get('test'), unary);
+        
+        return 'return !(__a)';
+    },
+});
+
+function checkNext(vars, path) {
+    const next = path.getNextSibling();
+    return compareAny(next, ['return true', 'return false']);
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@putout/plugin-return",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "🐊Putout plugin adds ability to transform code related to return",
+  "homepage": "https://github.com/coderaiser/putout/tree/master/packages/plugin-return#readme",
+  "main": "lib/index.js",
+  "release": false,
+  "tag": false,
+  "changelog": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coderaiser/putout.git"
+  },
+  "scripts": {
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "dependencies": {},
+  "keywords": [
+    "putout",
+    "putout-plugin",
+    "plugin",
+    "return"
+  ],
+  "devDependencies": {
+    "@putout/plugin-declare": "*",
+    "@putout/plugin-declare-before-reference": "*",
+    "@putout/plugin-putout": "*",
+    "@putout/plugin-remove-unused-variables": "*",
+    "@putout/plugin-reuse-duplicate-init": "*",
+    "@putout/plugin-typescript": "*",
+    "@putout/test": "^11.0.0",
+    "c8": "^10.0.0",
+    "eslint": "^9.0.0",
+    "eslint-plugin-n": "^17.0.0",
+    "eslint-plugin-putout": "^23.0.0",
+    "lerna": "^6.0.1",
+    "madrun": "^10.0.0",
+    "montag": "^1.2.1",
+    "nodemon": "^3.0.1"
+  },
+  "peerDependencies": {
+    "putout": ">=37"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}