@putout/plugin-variables 1.2.0 → 1.3.0

package/README.md

@@ -17,6 +17,8 @@ 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);
@@ -29,6 +31,8 @@ npm i @putout/plugin-variables -D
 ```json
 {
     "rules": {
+        "variables/convert-const-to-let": "on",
+        "variables/extract-keywords": "on",
         "variables/remove-useless-assignment": "on",
         "variables/remove-useless-declaration": ["on", {
             "maxLength": 20
@@ -240,6 +244,68 @@ 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/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,19 +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-unused/get-unused.js

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