@putout/plugin-variables 1.2.0 → 1.3.0

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

@@ -0,0 +1,148 @@
+import {types} from 'putout';
+import getVars from './get-vars.js';
+import {
+    useParamsBeforeLastUsed,
+    useParamsBeforeAssign,
+    usePropertiesBeforeRest,
+} from './use-params.js';
+
+const {
+    isClassDeclaration,
+    isFunctionDeclaration,
+} = types;
+
+export default (ast, opts) => {
+    const vars = {};
+    const allParams = [];
+    
+    const {setPath, traverse} = opts;
+    const use = useVariable({
+        vars,
+    });
+    
+    const declare = declareVariable({
+        vars,
+        setPath,
+    });
+    
+    const isUsed = isUsedVariable({
+        vars,
+    });
+    
+    const addParams = addParamsVariable(allParams);
+    
+    traverse(ast, getVars({
+        use,
+        declare,
+        addParams,
+    }));
+    
+    allParams
+        .map(useParamsBeforeLastUsed({
+            use,
+            isUsed,
+        }))
+        .map(usePropertiesBeforeRest({
+            use,
+        }))
+        .map(useParamsBeforeAssign({
+            use,
+            isUsed,
+        }));
+    
+    return Object.values(vars);
+};
+
+const addParamsVariable = (allParams) => ({path, params}) => {
+    allParams.push({
+        path,
+        params,
+    });
+};
+
+function getScopeUID({name, scope}) {
+    if (scope.hasOwnBinding(name))
+        return scope.uid;
+    
+    while (scope.parent) {
+        scope = scope.parent;
+        
+        if (scope.hasOwnBinding(name))
+            return scope.uid;
+    }
+    
+    return scope.uid;
+}
+
+const isUsedVariable = ({vars}) => (path, name) => {
+    const {scope} = path;
+    
+    const uid = getScopeUID({
+        name,
+        scope,
+    });
+    
+    const current = vars[uid];
+    const {used} = current[name];
+    
+    return used;
+};
+
+function getScope(path) {
+    const {node, scope} = path;
+    
+    if (isFunctionDeclaration(node))
+        return path.parentPath.scope;
+    
+    if (isClassDeclaration(node))
+        return path.parentPath.scope;
+    
+    return scope;
+}
+
+const declareVariable = ({vars, setPath}) => (path, name) => {
+    const scope = getScope(path);
+    
+    const uid = getScopeUID({
+        name,
+        scope,
+    });
+    
+    if (!vars[uid])
+        vars[uid] = {};
+    
+    const current = vars[uid];
+    
+    if (current[name])
+        current[name].declared = true;
+    else
+        current[name] = {
+            declared: true,
+            used: false,
+        };
+    
+    if (setPath)
+        current[name].path = path;
+};
+
+const useVariable = ({vars}) => (path, name) => {
+    const {scope} = path;
+    
+    const uid = getScopeUID({
+        name,
+        scope,
+    });
+    
+    if (!vars[uid])
+        vars[uid] = {};
+    
+    const current = vars[uid];
+    
+    if (current[name])
+        current[name].used = true;
+    else
+        current[name] = {
+            declared: false,
+            used: true,
+        };
+};

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

@@ -0,0 +1,45 @@
+import {types} from 'putout';
+
+const {
+    isIdentifier,
+    isJSXIdentifier,
+} = types;
+
+export default (use) => ({
+    JSXOpeningElement(path) {
+        const {node} = path;
+        const {name} = node;
+        
+        if (/^[A-Z]/.test(name.name))
+            use(path, name.name);
+        
+        use(path, 'React');
+    },
+    
+    JSXFragment(path) {
+        use(path, 'React');
+    },
+    
+    JSXSpreadAttribute(path) {
+        const argPath = path.get('argument');
+        
+        if (argPath.isIdentifier())
+            return use(path, argPath.node.name);
+    },
+    
+    JSXMemberExpression(path) {
+        const {node} = path;
+        const {object} = node;
+        
+        if (isJSXIdentifier(object))
+            use(path, object.name);
+    },
+    
+    JSXExpressionContainer(path) {
+        const {node} = path;
+        const {expression} = node;
+        
+        if (isIdentifier(expression))
+            use(path, expression.name);
+    },
+});

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

@@ -0,0 +1,179 @@
+import {types} from 'putout';
+
+const {
+    isIdentifier,
+    isObjectExpression,
+    isObjectPattern,
+    isTemplateLiteral,
+    isAssignmentPattern,
+} = types;
+
+export const traverseObjectPattern = ({use, declare}) => {
+    const traverseAssign = traverseAssignmentPattern({
+        use,
+    });
+    
+    return (propertiesPaths) => {
+        for (const path of propertiesPaths) {
+            if (path.isRestElement())
+                continue;
+            
+            const {key, value} = path.node;
+            const valuePath = path.get('value');
+            
+            switch(value.type) {
+            case 'Identifier':
+                declare(path, value.name);
+                break;
+            
+            case 'AssignmentPattern':
+                if (path.node.shorthand)
+                    declare(path, key.name);
+                else
+                    declare(path, valuePath.node.left.name);
+                
+                traverseAssign(valuePath);
+                break;
+            }
+        }
+    };
+};
+
+export const processObjectPattern = ({use, declare}) => (propertiesPaths) => {
+    for (const path of propertiesPaths) {
+        const {
+            key,
+            value,
+            computed,
+        } = path.node;
+        
+        if (computed && isIdentifier(key))
+            use(path, key.name);
+        
+        if (isIdentifier(value)) {
+            declare(path, value.name);
+            continue;
+        }
+        
+        if (isObjectPattern(value)) {
+            const process = processObjectPattern({
+                use,
+                declare,
+            });
+            
+            process(path.get('value.properties'));
+            continue;
+        }
+        
+        if (isAssignmentPattern(value)) {
+            const useAssignment = traverseAssignmentPattern({
+                use,
+            });
+            
+            useAssignment(path.get('value.right'));
+            
+            const leftPath = path.get('value.left');
+            
+            switch(leftPath.type) {
+            case 'Identifier':
+                declare(path, leftPath.node.name);
+                continue;
+            }
+        }
+    }
+};
+
+export const traverseObjectExpression = (use) => {
+    const traverseTmpl = traverseTemplateLiteral(use);
+    
+    return (propertiesPaths) => {
+        for (const path of propertiesPaths) {
+            const {node} = path;
+            
+            const {
+                key,
+                value,
+                computed,
+            } = node;
+            
+            if (computed && isIdentifier(key))
+                use(path, key.name);
+            
+            if (isIdentifier(value)) {
+                use(path, value.name);
+                continue;
+            }
+            
+            if (isTemplateLiteral(value)) {
+                traverseTmpl(path, value.expressions);
+                continue;
+            }
+            
+            if (isObjectExpression(value)) {
+                const traverseObj = traverseObjectExpression(use);
+                traverseObj(path.get('value.properties'));
+                continue;
+            }
+        }
+    };
+};
+
+export const traverseArrayExpression = (use) => {
+    const traverseObjExpression = traverseObjectExpression(use);
+    
+    return (elementsPaths) => {
+        for (const elementPath of elementsPaths) {
+            const {node} = elementPath;
+            
+            if (isObjectExpression(node))
+                traverseObjExpression(elementPath.get('properties'));
+        }
+    };
+};
+
+export const traverseAssignmentExpression = ({use, declare}) => {
+    const traverseObjPattern = traverseObjectPattern({
+        use,
+        declare,
+    });
+    
+    return (path) => {
+        const leftPath = path.get('left');
+        const rightPath = path.get('right');
+        
+        if (leftPath.isIdentifier()) {
+            const {parentPath} = leftPath.parentPath;
+            const {name} = leftPath.node;
+            
+            if (parentPath.isObjectProperty())
+                declare(parentPath, name);
+            
+            if (parentPath.isFunction())
+                declare(leftPath.parentPath, name);
+        }
+        
+        if (rightPath.isIdentifier())
+            use(rightPath, rightPath.node.name);
+        
+        if (leftPath.isObjectPattern())
+            traverseObjPattern(leftPath.get('properties'));
+    };
+};
+
+export const traverseTemplateLiteral = (use) => (path, expressions) => {
+    for (const exp of expressions) {
+        if (isIdentifier(exp))
+            use(path, exp.name);
+    }
+};
+
+export const traverseAssignmentPattern = ({use}) => (path) => {
+    const {node} = path;
+    const {right} = node;
+    
+    if (isIdentifier(node))
+        use(path.parentPath, node.name);
+    
+    if (isIdentifier(right))
+        use(path, right.name);
+};

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

@@ -0,0 +1,134 @@
+import {types} from 'putout';
+
+const {
+    isIdentifier,
+    isTSModuleDeclaration,
+} = types;
+
+export default ({use, declare}) => ({
+    'TSClassImplements|TSInterfaceHeritage'(path) {
+        const {expression} = path.node;
+        const {type} = expression;
+        
+        switch(type) {
+        case 'Identifier':
+            use(path, expression.name);
+        }
+    },
+    
+    TSFunctionType(path) {
+        const {node} = path;
+        const {params} = node;
+        
+        for (const param of params) {
+            const {type} = param;
+            
+            switch(type) {
+            case 'Identifier':
+                declare(path, param.name);
+                use(path, param.name);
+                break;
+            
+            case 'RestElement':
+                if (isIdentifier(param.argument)) {
+                    declare(path, param.argument.name);
+                    use(path, param.argument.name);
+                }
+            }
+        }
+    },
+    
+    TSTypeReference(path) {
+        const {node} = path;
+        const {typeName} = node;
+        const {type} = typeName;
+        
+        switch(type) {
+        case 'Identifier':
+            use(path, typeName.name);
+        }
+    },
+    
+    TSTypeAliasDeclaration(path) {
+        const {node} = path;
+        const {id} = node;
+        const {type} = id;
+        
+        switch(type) {
+        case 'Identifier':
+            declare(path, id.name);
+        }
+    },
+    
+    TSTypeQuery(path) {
+        const {node} = path;
+        const {exprName} = node;
+        const {type} = exprName;
+        
+        switch(type) {
+        case 'Identifier':
+            use(path, exprName.name);
+        }
+    },
+    
+    TSAsExpression(path) {
+        const {node} = path;
+        const {expression} = node;
+        const {type} = expression;
+        
+        switch(type) {
+        case 'Identifier':
+            use(path, expression.name);
+        }
+    },
+    
+    TSQualifiedName(path) {
+        const {node} = path;
+        const {left} = node;
+        const {type} = left;
+        
+        switch(type) {
+        case 'Identifier':
+            use(path, left.name);
+        }
+    },
+    
+    TSInterfaceDeclaration(path) {
+        declare(path, path.node.id.name);
+        
+        if (path.findParent(isTSModuleDeclaration))
+            use(path, path.node.id.name);
+    },
+    
+    TSMethodSignature(path) {
+        const params = path.get('params');
+        
+        for (const paramPath of params) {
+            if (paramPath.isIdentifier()) {
+                declare(paramPath, paramPath.node.name);
+                use(paramPath, paramPath.node.name);
+                continue;
+            }
+            
+            const {type} = paramPath;
+            
+            switch(type) {
+            case 'RestElement':
+                declare(paramPath, paramPath.node.argument.name);
+                use(paramPath, paramPath.node.argument.name);
+                continue;
+            }
+        }
+    },
+    TSDeclareFunction(path) {
+        const params = path.get('params');
+        
+        if (!params.length)
+            return;
+        
+        const [firstPath] = path.get('params');
+        
+        if (firstPath.isRestElement())
+            use(firstPath, firstPath.node.argument.name);
+    },
+});

package/lib/remove-unused/get-vars/use-params.js

@@ -0,0 +1,123 @@
+import {types} from 'putout';
+
+const {
+    isIdentifier,
+    isObjectPattern,
+    isRestElement,
+    isAssignmentPattern,
+} = types;
+
+export const usePropertiesBeforeRest = ({use}) => ({path, params}) => {
+    for (const param of params) {
+        if (!isObjectPattern(param))
+            continue;
+        
+        traverseProperties(use, path, param.properties);
+    }
+    
+    return {
+        path,
+        params,
+    };
+};
+
+export const useParamsBeforeAssign = ({use}) => ({path, params}) => {
+    const last = params.at(-1);
+    const usedParams = params.slice(0, -1);
+    
+    if (!isAssignmentPattern(last))
+        return;
+    
+    for (const param of usedParams) {
+        if (isIdentifier(param))
+            use(path, param.name);
+    }
+    
+    return {
+        path,
+        params,
+    };
+};
+
+function traverseProperties(use, path, properties) {
+    const {length} = properties;
+    const last = properties.at(-1);
+    
+    if (!isRestElement(last))
+        return;
+    
+    for (let i = 0; i < length - 1; i++) {
+        const {value} = properties[i];
+        const {type} = value;
+        
+        switch(type) {
+        case 'Identifier':
+            use(path, value.name);
+            continue;
+        }
+    }
+}
+
+export const useParamsBeforeLastUsed = ({use, isUsed}) => ({path, params}) => {
+    let i = params.length;
+    
+    while (--i > 0) {
+        const param = params[i];
+        
+        if (traverseIsUsed(isUsed, path, param))
+            break;
+    }
+    
+    while (--i >= 0) {
+        if (!isIdentifier(params[i]))
+            continue;
+        
+        use(path, params[i].name);
+    }
+    
+    return {
+        path,
+        params,
+    };
+};
+
+const traverseIsUsed = (isUsed, path, node) => {
+    const {type} = node;
+    
+    switch(type) {
+    case 'Identifier':
+        return isUsed(path, node.name);
+    
+    case 'ObjectPattern':
+        return isUsedObjectPattern(isUsed, path, node);
+    
+    case 'AssignmentPattern':
+        return isUsedAssignmentPattern(isUsed, path, node);
+    }
+};
+
+const isUsedAssignmentPattern = (isUsed, path, node) => {
+    const {left} = node;
+    const {type} = left;
+    
+    switch(type) {
+    case 'Identifier':
+        return isUsed(path, left.name);
+    
+    case 'ObjectPattern':
+        return isUsedObjectPattern(isUsed, path, left);
+    }
+};
+
+const isUsedObjectPattern = (isUsed, path, node) => {
+    for (const {value} of node.properties) {
+        if (isIdentifier(value)) {
+            if (isUsed(path, value.name))
+                return true;
+            
+            continue;
+        }
+    }
+    
+    return false;
+};

package/lib/remove-unused/get-vars/visitors/export-named-declaration.js

@@ -0,0 +1,61 @@
+import {types} from 'putout';
+
+const {
+    isArrayPattern,
+    isRestElement,
+    isObjectPattern,
+    isIdentifier,
+    isVariableDeclaration,
+} = types;
+
+export const createExportNamedDeclaration = ({use}) => (path) => {
+    const declarationPath = path.get('declaration');
+    const {declaration, specifiers} = path.node;
+    
+    if (declarationPath.isFunctionDeclaration())
+        return use(path, declaration.id.name);
+    
+    if (declarationPath.isClassDeclaration())
+        return use(path, declaration.id.name);
+    
+    // typescript
+    if (declarationPath.isTSInterfaceDeclaration())
+        return use(path, declaration.id.name);
+    
+    if (declarationPath.isTSTypeAliasDeclaration())
+        return use(path, declaration.id.name);
+    
+    if (isVariableDeclaration(declaration)) {
+        const {declarations} = declaration;
+        
+        for (const {id} of declarations) {
+            /* istanbul ignore else */
+            if (isIdentifier(id))
+                use(path, id.name);
+            
+            if (isObjectPattern(id))
+                for (const property of id.properties) {
+                    if (isRestElement(property) && isIdentifier(property.argument)) {
+                        use(path, property.argument.name);
+                        continue;
+                    }
+                    
+                    if (isIdentifier(property.value))
+                        use(path, property.value.name);
+                }
+            
+            if (isArrayPattern(id))
+                for (const element of id.elements)
+                    if (isIdentifier(element))
+                        use(path, element.name);
+        }
+        
+        return;
+    }
+    
+    for (const {local} of specifiers) {
+        /* istanbul ignore else */
+        if (isIdentifier(local))
+            use(path, local.name);
+    }
+};