@putout/plugin-variables 1.0.0 → 1.2.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
 
@@ -18,6 +22,7 @@ npm i @putout/plugin-variables -D
 - ✅ [remove-useless-duplicate](#remove-useless-duplicate);
 - ✅ [remove-useless-variables](#remove-useless-variables);
 - ✅ [remove-useless-rename](#remove-useless-rename);
+- ✅ [split-declarations](#split-declarations);
 
 ## Config
 
@@ -30,7 +35,8 @@ npm i @putout/plugin-variables -D
         }],
         "variables/remove-useless-duplicate": "on",
         "variables/remove-useless-rename": "on",
-        "variables/remove-useless-remove": "on"
+        "variables/remove-useless-remove": "on",
+        "variables/split-declarations": "on"
     }
 }
 ```
@@ -155,6 +161,85 @@ function DestructuringErrors(a, b) {
 bc = b.c.replace('x', 'y');
 ```
 
+## remove-unreferenced
+
+### ❌ Example of incorrect code
+
+```js
+let a;
+let b;
+
+a = 5;
+b = 6;
+
+console.log(a);
+```
+
+### ✅ Example of correct code
+
+```js
+let a;
+
+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;
+```
+
 ## 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/index.js

@@ -1,13 +1,19 @@
+import * as convertConstToLet from './convert-const-to-let/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 splitDeclarations from './split-declarations/index.js';
 
 export const rules = {
+    'convert-const-to-let': convertConstToLet,
     'remove-useless': removeUseless,
     'remove-useless-assignment': removeUselessAssignment,
     'remove-useless-declarations': removeUselessDeclarations,
     'remove-useless-duplicates': removeUselessDuplicates,
     'remove-useless-rename': removeUselessRename,
+    'remove-unreferenced': removeUnreferenced,
+    'split-declarations': splitDeclarations,
 };

package/lib/remove-unreferenced/index.js

@@ -0,0 +1,105 @@
+import {operator} from 'putout';
+
+const {remove} = operator;
+
+export const report = () => 'Avoid unreferenced variables';
+
+export const fix = (path) => {
+    remove(path);
+};
+
+export const traverse = ({push}) => ({
+    'return __a'(path) {
+        const arg = path.get('argument');
+        
+        if (!arg.isIdentifier())
+            return false;
+        
+        const binding = path.scope.bindings[arg.node.name];
+        
+        if (!binding)
+            return false;
+        
+        if (binding.constantViolations.length)
+            return false;
+        
+        if (binding.referencePaths.length !== 1)
+            return false;
+        
+        if (!binding.path.isVariableDeclarator())
+            return false;
+        
+        if (binding.path.node.init)
+            return false;
+        
+        push(path);
+    },
+    '__identifier = __a'(path) {
+        const {parentPath} = path;
+        
+        if (parentPath.isMemberExpression())
+            return;
+        
+        if (parentPath.isConditionalExpression())
+            return;
+        
+        const {name} = path.node.left;
+        const binding = path.scope.getAllBindings()[name];
+        
+        if (!binding)
+            return;
+        
+        if (path.find(isInsideForOf))
+            return;
+        
+        const {referenced} = binding;
+        
+        if (referenced)
+            return;
+        
+        if (binding.path.isObjectPattern()) {
+            const propPath = getPropertyPath(binding.path, name);
+            
+            push(path);
+            push(propPath);
+            
+            return;
+        }
+        
+        const idPath = binding.path.get('id');
+        
+        if (binding.path.isVariableDeclarator() && idPath.isObjectPattern()) {
+            const propPath = getPropertyPath(idPath, name);
+            
+            push(path);
+            push(propPath);
+            
+            return;
+        }
+        
+        push(path);
+        push(binding.path);
+    },
+});
+
+function getPropertyPath(path, name) {
+    let propPath;
+    
+    for (propPath of path.get('properties')) {
+        const {key, shorthand} = propPath.node;
+        
+        if (shorthand && key.name !== name)
+            continue;
+        
+        break;
+    }
+    
+    return propPath;
+}
+
+function isInsideForOf(path) {
+    if (path.isForOfStatement())
+        return true;
+    
+    return path.__putout_for_of_reduce;
+}

package/lib/split-declarations/index.js

@@ -0,0 +1,67 @@
+import {types, operator} from 'putout';
+
+const {
+    isForStatement,
+    variableDeclaration,
+} = types;
+
+const {
+    replaceWithMultiple,
+    isKeyword,
+} = operator;
+
+export const report = () => 'Variables should be declared separately';
+
+export const fix = (path) => {
+    const {node} = path;
+    const varNodes = getVarNodes(node);
+    
+    replaceWithMultiple(path, varNodes);
+};
+
+export const traverse = ({push}) => ({
+    VariableDeclaration(path) {
+        const {
+            node,
+            parent,
+            parentPath,
+        } = path;
+        
+        const {declarations} = node;
+        
+        if (parentPath.isExportDeclaration())
+            return;
+        
+        if (declarations.length === 1)
+            return;
+        
+        for (const declaration of declarations) {
+            const {name} = declaration.id;
+            
+            if (isKeyword(name))
+                return;
+        }
+        
+        const init = node;
+        
+        if (isForStatement(parent, {init}))
+            return;
+        
+        push(path);
+    },
+});
+
+function getVarNodes({kind, declarations}) {
+    const result = [];
+    
+    for (const declaration of declarations) {
+        const declarations = [declaration];
+        
+        result.push(variableDeclaration(
+            kind,
+            declarations,
+        ));
+    }
+    
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-variables",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to find and remove useless",
@@ -37,7 +37,10 @@
   "devDependencies": {
     "@putout/eslint-flat": "^3.0.0",
     "@putout/plugin-declare": "*",
+    "@putout/plugin-for-of": "*",
     "@putout/plugin-maybe": "*",
+    "@putout/plugin-minify": "*",
+    "@putout/plugin-remove-unused-variables": "*",
     "@putout/plugin-remove-useless-array-from": "*",
     "@putout/plugin-reuse-duplicate-init": "*",
     "@putout/test": "^14.0.0",