@putout/plugin-variables 1.1.0 → 1.3.0

package/README.md

@@ -3,7 +3,11 @@
 [NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-variables.svg?style=flat&longCache=true
 [NPMURL]: https://npmjs.org/package/@putout/plugin-variables "npm"
 
-🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to find and remove `useless variables`.
+> A **variable** is a named reference to a **value**.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Glossary/Variable)
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to transform `variables`.
 
 ## Install
 
@@ -13,24 +17,30 @@ npm i @putout/plugin-variables -D
 
 ## Rules
 
+- ✅ [convert-const-to-let](#convert-const-to-let');
+- ✅ [extract-keywords](#extract-keywords');
 - ✅ [remove-useless-assignment](#remove-useless-assignmenn);
 - ✅ [remove-useless-declaration](#remove-useless-declaration);
 - ✅ [remove-useless-duplicate](#remove-useless-duplicate);
 - ✅ [remove-useless-variables](#remove-useless-variables);
 - ✅ [remove-useless-rename](#remove-useless-rename);
+- ✅ [split-declarations](#split-declarations);
 
 ## Config
 
 ```json
 {
     "rules": {
+        "variables/convert-const-to-let": "on",
+        "variables/extract-keywords": "on",
         "variables/remove-useless-assignment": "on",
         "variables/remove-useless-declaration": ["on", {
             "maxLength": 20
         }],
         "variables/remove-useless-duplicate": "on",
         "variables/remove-useless-rename": "on",
-        "variables/remove-useless-remove": "on"
+        "variables/remove-useless-remove": "on",
+        "variables/split-declarations": "on"
     }
 }
 ```
@@ -157,10 +167,6 @@ bc = b.c.replace('x', 'y');
 
 ## remove-unreferenced
 
-> A **variable** is a named reference to a **value**.
->
-> (c) [MDN](https://developer.mozilla.org/en-US/docs/Glossary/Variable)
-
 ### ❌ Example of incorrect code
 
 ```js
@@ -183,6 +189,123 @@ a = 5;
 console.log(a);
 ```
 
+## split-declarations
+
+> - The [`let`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) statement declares a block-scoped local variable, optionally initializing it to a value.
+> - [`const`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statements are also block-scoped. The value of a constant can't be changed through reassignment, and it can't be redeclared. However, if a constant is an **object** or **array** its properties or items can be updated or removed.
+>
+> (c) MDN
+
+Add ability to find and split variable declarations because (re)moving a line is simpler and less error prone then changing coma (`,`) to colon (`;`).
+For the same reason, **diff** of changed declarations are more comfortable to read.
+
+### ❌ Example of incorrect code
+
+```js
+let a, b;
+```
+
+### ✅ Example of correct code
+
+```js
+let a;
+let b;
+```
+
+### Comparison
+
+Linter | Rule | Fix
+--------|-------|------------|
+🐊 **Putout** | [`remove-debugger`](https://github.com/coderaiser/putout/tree/master/packages/plugin-split-variable-declarations#readme) | ✅
+⏣ **ESLint** | [`no-var`](https://eslint.org/docs/latest/rules/one-var) | ✅
+
+## convert-const-to-let
+
+> The `TypeError` object represents an error when attempting to modify a value that cannot be changed.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError)
+
+Convert `const` to `let` to avoid `TypeError`.
+Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/61ffff64a356c47e66af4ea17a9a755d/e7f5fa455c208a7faa9319d94130996d39afcbf7).
+
+### ❌ Example of incorrect code
+
+```js
+let a = 5;
+
+a = 3;
+```
+
+### ✅ Example of correct code
+
+```js
+let a = 5;
+
+a = 3;
+```
+
+## remove-unused
+
+> A variable is a container for a value, like a `number` we might use in a sum, or a `string` that we might use as part of a sentence.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/First_steps/Variables)
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to find and remove the variables that are declared, but:
+
+- not passed as **argument** to a **function**;
+- not used as **operand** in **expression**;
+
+That is **unused variables**. Most likely it is a leftovers due to incomplete transforming of the code. Such variables take up space and gives no value so they must be removed.
+
+☝️*Remember, when you [writing a transform](https://github.com/coderaiser/putout/tree/master/packages/engine-runner#readme) you can skip all parts related to **removing unused variables** and just reuse current **plugin** it will make your code simpler and less error prone.*
+
+☝️*No, you cannot just look at [`referenced` and `constant` fields](https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md#user-content-bindings) to determine if you can remove variable and [here is why](https://putout.cloudcmd.io/#/gist/4277392f74b56b74911b779c9624af8d/cfec476f857dfb4f4c7a6247bdcc6b521fed8e70) one of the biggest plugins exists*.
+
+### ❌ Example of incorrect code
+
+```js
+const a = 'hello';
+const b = 'world';
+
+console.log(a);
+```
+
+### ✅ Example of correct code
+
+```js
+const a = 'hello';
+console.log(a);
+```
+
+## Comparison
+
+Linter | Rule | Fix
+--------|-------|------------|
+🐊 **Putout**| [`remove-unused-variables`](https://github.com/coderaiser/putout/tree/master/packages/plugin-remove-unused-variables#readme)| ✅
+⏣ **ESLint** | [`no-unused-vars`](https://eslint.org/docs/rules/no-unused-vars) | ❌
+
+## extract-keywords
+
+> The JavaScript exceptions "unexpected token" occur when the parser does not see a token it recognizes at the given position, so it cannot make sense of the structure of the program. This might be a simple typo.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Unexpected_token)
+
+Extract `keywords` from variables. Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/fcaedaa9daf7f3a771274aca0da9ab1b/00850a5d28aec86b1b4083ba2ef9f81bd49aaaac).
+
+```diff
+-export const isTemplateMiddle = (a) => a?.type === 'TemplateMiddle',
++export const isTemplateMiddle = (a) => a?.type === 'TemplateMiddle';
+export const isTemplateTail = (a) => a?.type === 'TemplateTail';
+
+-const a 5;
++const a = 5;
+
+-export const packContent = (content) {
++export const packContent = (content) => {
+    console.log(a);
+}
+```
+
 ## License
 
 MIT

package/lib/convert-const-to-let/index.js

@@ -0,0 +1,69 @@
+import {types} from 'putout';
+
+const {
+    isBlockStatement,
+    isProgram,
+} = types;
+
+const {values} = Object;
+
+const isKeyword = (a) => [
+    'export',
+    'const',
+    'let',
+    'var',
+].includes(a);
+
+const isInsideBlock = ({parentPath}) => isProgram(parentPath) || isBlockStatement(parentPath);
+
+export const report = () => `Use 'let' when reassign`;
+
+export const fix = (path) => {
+    path.node.kind = 'let';
+};
+
+export const traverse = ({push}) => ({
+    VariableDeclaration: (path) => {
+        if (path.parentPath.isTSModuleBlock())
+            return;
+        
+        const {scope} = path;
+        const {declare} = path.node;
+        
+        if (declare)
+            return;
+        
+        for (const binding of values(scope.bindings)) {
+            const {parentPath, node} = binding.path;
+            const {init} = node;
+            
+            if (init && binding.constant)
+                continue;
+            
+            if (isLoop(parentPath) && binding.constant)
+                continue;
+            
+            if (!binding.path.isVariableDeclarator())
+                continue;
+            
+            if (isKeyword(binding.path.node.id.name))
+                continue;
+            
+            if (!binding.path.node.init && isInsideBlock(binding.path.parentPath))
+                continue;
+            
+            if (parentPath.node.kind === 'const')
+                push(binding.path.parentPath);
+        }
+    },
+});
+
+const isLoop = ({parentPath}) => {
+    if (!parentPath)
+        return false;
+    
+    if (parentPath.isForOfStatement())
+        return true;
+    
+    return parentPath.isForInStatement();
+};

package/lib/extract-keywords/index.js

@@ -0,0 +1,178 @@
+import {types, operator} from 'putout';
+
+const {
+    ifStatement,
+    importDefaultSpecifier,
+    importDeclaration,
+    exportNamedDeclaration,
+    variableDeclarator,
+    variableDeclaration,
+    isExportDeclaration,
+    isArrowFunctionExpression,
+    isLiteral,
+    isAssignmentExpression,
+    isExportNamedDeclaration,
+    isIdentifier,
+    isImportDeclaration,
+    isMemberExpression,
+    isBlockStatement,
+    arrowFunctionExpression,
+} = types;
+
+const {
+    removeParens,
+    remove,
+    replaceWith,
+    isDeclarationKeyword,
+    isConditionKeyword,
+    isModuleDeclarationKeyword,
+} = operator;
+
+const isInit = (a) => isIdentifier(a) || isLiteral(a) || isMemberExpression(a) || isArrowFunctionExpression(a);
+
+const buildDeclaration = (type) => (nextPath, path) => {
+    const {expression} = nextPath.node;
+    let left;
+    let right;
+    
+    if (isBlockStatement(nextPath)) {
+        left = path.node.id;
+        const {node: init} = removeParens(path.get('init'));
+        const params = [init];
+        
+        right = arrowFunctionExpression(params, nextPath.node);
+    } else if (isAssignmentExpression(expression)) {
+        ({
+            left,
+            right,
+        } = expression);
+    } else {
+        left = path.node.id;
+        right = nextPath.node.expression;
+    }
+    
+    replaceWith(nextPath, variableDeclaration(type, [variableDeclarator(left, right)]));
+    
+    const {name} = path.node.id;
+    
+    if (isDeclarationKeyword(name))
+        return;
+    
+    if (isExportNamedDeclaration(path.parentPath.parentPath))
+        replaceWith(nextPath, exportNamedDeclaration(nextPath.node));
+};
+
+const builders = {
+    const: buildDeclaration('const'),
+    var: buildDeclaration('var'),
+    let: buildDeclaration('let'),
+    import: buildImport,
+    export: buildExport,
+    if: buildIf,
+};
+
+export const report = ({name}) => `Extract '${name}' from variable`;
+
+export const fix = ({name, path, nextPath}) => {
+    builders[name](nextPath, path);
+    remove(path);
+};
+
+export const traverse = ({push}) => ({
+    VariableDeclarator(path) {
+        const {name} = path.node.id;
+        
+        if (isDeclarationKeyword(name) || isConditionKeyword(name) || isModuleDeclarationKeyword(name)) {
+            const topPath = getTopPath(path);
+            const nextPath = topPath.getNextSibling();
+            
+            if (nextPath.isVariableDeclaration())
+                push({
+                    name,
+                    path,
+                    nextPath,
+                });
+            
+            if (nextPath.isExpressionStatement())
+                push({
+                    name,
+                    path,
+                    nextPath,
+                });
+            
+            return;
+        }
+        
+        const {kind} = path.parentPath.node;
+        
+        if (!path.node.init) {
+            const topPath = getTopPath(path);
+            const nextPath = topPath.getNextSibling();
+            
+            if (!nextPath.isExpressionStatement())
+                return;
+            
+            const {expression} = nextPath.node;
+            
+            if (isInit(expression))
+                push({
+                    name: kind,
+                    path,
+                    nextPath,
+                });
+            
+            return;
+        }
+        
+        if (isExportDeclaration(path.parentPath.parentPath)) {
+            const nextPath = path.parentPath.parentPath.getNextSibling();
+            
+            if (!isBlockStatement(nextPath))
+                return;
+            
+            if (!nextPath.node.body.length)
+                return;
+            
+            const count = nextPath.node.body.filter(isImportDeclaration).length;
+            
+            if (!count)
+                push({
+                    name: kind,
+                    path,
+                    nextPath,
+                });
+        }
+    },
+});
+
+function getTopPath(path) {
+    if (path.parentPath.parentPath.isExportDeclaration())
+        return path.parentPath.parentPath;
+    
+    return path.parentPath;
+}
+
+function buildExport(path) {
+    replaceWith(path, exportNamedDeclaration(path.node));
+}
+
+function buildImport(path) {
+    const fromPath = path.getNextSibling();
+    const sourcePath = fromPath.getNextSibling();
+    const source = sourcePath.node.expression;
+    const local = path.node.expression;
+    
+    replaceWith(path, importDeclaration([importDefaultSpecifier(local, local)], source));
+    remove(sourcePath);
+    remove(fromPath);
+}
+
+function buildIf(path) {
+    const {expression} = path.node;
+    delete expression.extra.parenthesized;
+    const nextPath = path.getNextSibling();
+    const next = nextPath.node;
+    
+    remove(nextPath);
+    replaceWith(path, ifStatement(expression, next));
+}

package/lib/index.js

@@ -1,15 +1,23 @@
+import * as convertConstToLet from './convert-const-to-let/index.js';
+import * as extractKeywords from './extract-keywords/index.js';
 import * as removeUseless from './remove-useless/index.js';
 import * as removeUselessAssignment from './remove-useless-assignment/index.js';
 import * as removeUselessDeclarations from './remove-useless-declarations/index.js';
 import * as removeUselessDuplicates from './remove-useless-duplicates/index.js';
 import * as removeUselessRename from './remove-useless-rename/index.js';
 import * as removeUnreferenced from './remove-unreferenced/index.js';
+import * as removeUnused from './remove-unused/index.js';
+import * as splitDeclarations from './split-declarations/index.js';
 
 export const rules = {
+    'convert-const-to-let': convertConstToLet,
+    'extract-keywords': extractKeywords,
     'remove-useless': removeUseless,
     'remove-useless-assignment': removeUselessAssignment,
     'remove-useless-declarations': removeUselessDeclarations,
     'remove-useless-duplicates': removeUselessDuplicates,
     'remove-useless-rename': removeUselessRename,
     'remove-unreferenced': removeUnreferenced,
+    'remove-unused': removeUnused,
+    'split-declarations': splitDeclarations,
 };

package/lib/remove-unreferenced/index.js

@@ -4,7 +4,9 @@ const {remove} = operator;
 
 export const report = () => 'Avoid unreferenced variables';
 
-export const fix = (path) => remove(path);
+export const fix = (path) => {
+    remove(path);
+};
 
 export const traverse = ({push}) => ({
     'return __a'(path) {
@@ -95,4 +97,9 @@ function getPropertyPath(path, name) {
     return propPath;
 }
 
-const isInsideForOf = (path) => path.__putout_for_of_reduce;
+function isInsideForOf(path) {
+    if (path.isForOfStatement())
+        return true;
+    
+    return path.__putout_for_of_reduce;
+}

package/lib/remove-unused/get-unused.js

@@ -0,0 +1,5 @@
+const onlyDeclared = ({declared, used}) => declared && !used;
+
+export default (items) => {
+    return items.filter(onlyDeclared);
+};