@putout/plugin-destructuring 1.0.2 → 1.2.0

package/README.md

@@ -19,8 +19,10 @@ npm i @putout/plugin-destructuring
 
 - ✅ [apply-object](#apply-object);
 - ✅ [apply-array](#apply-array);
-- ✅ [remove-useless-object](#remove-useless-object);
 - ✅ [convert-object-to-array](#convert-object-to-array);
+- ✅ [remove-useless-object](#remove-useless-object);
+- ✅ [remove-useless-arguments](#remove-useless-arguments);
+- ✅ [remove-useless-variables](#remove-useless-variables);
 - ✅ [split-nested](#split-nested);
 - ✅ [split-call](#split-call);
 - ✅ [merge-properties](#merge-properties);
@@ -32,8 +34,10 @@ npm i @putout/plugin-destructuring
     "rules": {
         "destructuring/apply-object": "on",
         "destructuring/apply-array": "on",
-        "destructuring/remove-useless-object": "on",
         "destructuring/convert-object-to-array": "on",
+        "destructuring/remove-useless-object": "on",
+        "destructuring/remove-useless-arguments": "on",
+        "destructuring/remove-useless-variables": "on",
         "destructuring/split-nested": "on",
         "destructuring/split-call": "on",
         "destructuring/merge-properties": "on"
@@ -192,6 +196,47 @@ const {one, two} = require('numbers');
 } = data);
 ```
 
+### remove-useless-arguments
+
+### ❌ Example of incorrect code
+
+```js
+onIfStatement({
+    push,
+    generate,
+    abc,
+    helloworld,
+});
+
+function onIfStatement({push}) {}
+```
+
+### ✅ Example of correct code
+
+```js
+onIfStatement({
+    push,
+});
+
+function onIfStatement({push}) {}
+```
+
+## remove-useless-variables
+
+### ❌ Example of incorrect code
+
+```js
+function hi(c) {
+    const {a, b} = c;
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function hi({a, b}) {}
+```
+
 ## License
 
 MIT

package/lib/index.js

@@ -2,6 +2,8 @@ import * as convertObjectToArray from './convert-object-to-array/index.js';
 import * as applyObject from './apply-object/index.js';
 import * as applyArray from './apply-array/index.js';
 import * as removeUselessObject from './remove-useless-object/index.js';
+import * as removeUselessArguments from './remove-useless-arguments/index.js';
+import * as removeUselessVariables from './remove-useless-variables/index.js';
 import * as splitNested from './split-nested/index.js';
 import * as splitCall from './split-call/index.js';
 import * as mergeProperties from './merge-properties/index.js';
@@ -10,6 +12,8 @@ export const rules = {
     'apply-object': applyObject,
     'apply-array': applyArray,
     'remove-useless-object': removeUselessObject,
+    'remove-useless-arguments': removeUselessArguments,
+    'remove-useless-variables': removeUselessVariables,
     'convert-object-to-array': convertObjectToArray,
     'split-nested': splitNested,
     'split-call': splitCall,

package/lib/remove-useless-arguments/index.js

@@ -0,0 +1,132 @@
+import {types, operator} from 'putout';
+
+const {
+    isIdentifier,
+    isObjectProperty,
+} = types;
+
+const {findBinding, remove} = operator;
+
+const getKey = ({key}) => key;
+
+export const report = ({path, name}) => {
+    const {key} = path.node;
+    
+    return `Avoid useless argument '${key.name}' of a function '${name}()'`;
+};
+
+export const fix = ({path}) => {
+    remove(path);
+};
+
+export const traverse = ({push}) => ({
+    '__(__object)': processUseless({
+        push,
+        index: 0,
+    }),
+    '__(__, __object)': processUseless({
+        push,
+        index: 1,
+    }),
+});
+
+const processUseless = ({push, index}) => (path) => {
+    const {
+        is,
+        name,
+        argProps,
+        param,
+    } = getUseless({
+        path,
+        index,
+    });
+    
+    if (!is)
+        return;
+    
+    removeUseless({
+        push,
+        name,
+        param,
+        argProps,
+    });
+};
+
+function getUseless({path, index}) {
+    const NOT_OK = {
+        is: false,
+    };
+    
+    const {name} = path.node.callee;
+    
+    const argument = path.get('arguments').at(index);
+    const argProps = argument.get('properties').filter(isObjectProperty);
+    
+    const refPath = findBinding(path, name);
+    
+    if (!refPath)
+        return NOT_OK;
+    
+    const binding = refPath.scope.bindings[name];
+    const params = getParams(binding.path);
+    
+    if (!params.length)
+        return NOT_OK;
+    
+    if (params.length <= index)
+        return NOT_OK;
+    
+    const param = params.at(index);
+    
+    return {
+        is: true,
+        name,
+        param,
+        argProps,
+    };
+}
+
+function removeUseless({push, name, param, argProps}) {
+    if (!param.isObjectPattern())
+        return;
+    
+    const {properties} = param.node;
+    
+    for (const prop of properties) {
+        if (!isIdentifier(prop.value))
+            return;
+    }
+    
+    const propKeys = properties.map(getKey);
+    
+    for (const propPath of argProps) {
+        let is = false;
+        
+        const {key} = propPath.node;
+        
+        for (const {name} of propKeys) {
+            if (name === key.name) {
+                is = true;
+                break;
+            }
+        }
+        
+        if (!is)
+            push({
+                name,
+                path: propPath,
+            });
+    }
+}
+
+function getParams(path) {
+    if (path.isFunction())
+        return path.get('params');
+    
+    const fnPath = path.get('init');
+    
+    if (!fnPath.isFunction())
+        return [];
+    
+    return fnPath.get('params');
+}

package/lib/remove-useless-variables/index.js

@@ -0,0 +1,78 @@
+import {types, operator} from 'putout';
+
+const {
+    isIdentifier,
+    isRestElement,
+    isAssignmentPattern,
+} = types;
+
+const {replaceWith} = operator;
+
+const MAX_LENGTH = 20;
+
+const getKeyLength = (a) => {
+    const {key, value} = a;
+    
+    if (!isAssignmentPattern(value) && isIdentifier(key))
+        return a.key.name.length;
+    
+    if (isRestElement(a) && isIdentifier(a.argument))
+        return a.argument.name.length + 3;
+    
+    return MAX_LENGTH;
+};
+
+const sum = (a, b) => a + getKeyLength(b);
+
+export const report = (path) => {
+    return `Avoid useless variable '${path.node.declarations[0].init.name}'`;
+};
+
+export const match = () => ({
+    'const __object = __a': ({__a, __object}, path) => {
+        const {parentPath} = path.parentPath;
+        
+        if (!parentPath)
+            return false;
+        
+        if (!parentPath.isFunction())
+            return false;
+        
+        if (path.node !== parentPath.node.body.body[0])
+            return false;
+        
+        const {params} = parentPath.node;
+        
+        if (params.length !== 1)
+            return false;
+        
+        const [first] = params;
+        
+        if (__object.properties.length > 3)
+            return false;
+        
+        if (!isIdentifier(first))
+            return false;
+        
+        if (__a.name !== first.name)
+            return false;
+        
+        const binding = path.scope.bindings[first.name];
+        
+        if (binding.path.node.typeAnnotation)
+            return false;
+        
+        if (binding.references > 1)
+            return false;
+        
+        const namesLength = __object.properties.reduce(sum, 0);
+        
+        return namesLength < MAX_LENGTH;
+    },
+});
+
+export const replace = () => ({
+    'const __object = __a': ({__object}, path) => {
+        replaceWith(path.parentPath.parentPath.get('params.0'), __object);
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-destructuring",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to transform destructuring",