@wyw-in-js/transform 2.0.0-alpha.0 → 2.0.0

package/types/utils/applyOxcProcessors/cleanupBindings.js

@@ -0,0 +1,189 @@
+/* eslint-disable no-restricted-syntax */
+import { isNotNull } from '../isNotNull';
+import { getOxcNodeChildren, isOxcNode, walkOxc } from '../oxc/ast';
+export const collectUsedNames = (program) => {
+    const names = new Set();
+    walkOxc(program, (node) => {
+        if (node.type === 'Identifier') {
+            names.add(node.name);
+        }
+    });
+    return names;
+};
+export const isNodeReference = (node, parent) => {
+    if (node.type === 'Identifier') {
+        const parentRecord = parent;
+        if (!parentRecord) {
+            return true;
+        }
+        if (parent?.type === 'ImportDeclaration' ||
+            parent?.type === 'ImportSpecifier' ||
+            parent?.type === 'ImportDefaultSpecifier' ||
+            parent?.type === 'ImportNamespaceSpecifier') {
+            return false;
+        }
+        if (parent?.type === 'MemberExpression' &&
+            parentRecord.property === node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        if ((parent?.type === 'VariableDeclarator' ||
+            parent?.type === 'FunctionDeclaration' ||
+            parent?.type === 'ClassDeclaration' ||
+            parent?.type === 'ClassExpression') &&
+            parentRecord.id === node) {
+            return false;
+        }
+        if ((parent?.type === 'PropertyDefinition' ||
+            parent?.type === 'MethodDefinition') &&
+            parentRecord.key === node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        if (parent?.type === 'Property' &&
+            parentRecord.key === node &&
+            parentRecord.value !== node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        return true;
+    }
+    if (node.type === 'JSXIdentifier') {
+        const parentRecord = parent;
+        if (parent?.type === 'JSXAttribute' && parentRecord?.name === node) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+};
+export const collectReferencedNames = (root) => {
+    const names = new Set();
+    const walk = (node, parent = null) => {
+        if (node.type === 'ImportDeclaration') {
+            return;
+        }
+        if (isNodeReference(node, parent) &&
+            'name' in node &&
+            typeof node.name === 'string') {
+            names.add(node.name);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(root);
+    return names;
+};
+export const collectImportLocalNames = (node) => {
+    if (node.type !== 'ImportDeclaration') {
+        return [];
+    }
+    const { specifiers } = node;
+    if (!Array.isArray(specifiers)) {
+        return [];
+    }
+    return specifiers
+        .map((specifier) => {
+        const { local } = specifier;
+        return isOxcNode(local) &&
+            'name' in local &&
+            typeof local.name === 'string'
+            ? local.name
+            : null;
+    })
+        .filter(isNotNull);
+};
+export const getImportSpecifierLocalName = (node) => {
+    const { local } = node;
+    return isOxcNode(local) && 'name' in local && typeof local.name === 'string'
+        ? local.name
+        : null;
+};
+export const collectDeclaredNames = (node) => {
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectDeclaredNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectDeclaredNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectDeclaredNames(property.argument)
+            : collectDeclaredNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => element ? collectDeclaredNames(element) : []);
+    }
+    if (node.type === 'TSParameterProperty') {
+        return collectDeclaredNames(node.parameter);
+    }
+    return [];
+};
+export const collectTopLevelBindings = (statement) => {
+    const bindings = new Set();
+    if (statement.type === 'ImportDeclaration') {
+        collectImportLocalNames(statement).forEach((name) => bindings.add(name));
+        return bindings;
+    }
+    if (statement.type === 'VariableDeclaration') {
+        const { declarations } = statement;
+        if (!Array.isArray(declarations)) {
+            return bindings;
+        }
+        declarations.forEach((declarator) => {
+            const { id } = declarator;
+            if (isOxcNode(id)) {
+                collectDeclaredNames(id).forEach((name) => bindings.add(name));
+            }
+        });
+        return bindings;
+    }
+    if ((statement.type === 'FunctionDeclaration' ||
+        statement.type === 'ClassDeclaration' ||
+        statement.type === 'TSEnumDeclaration') &&
+        'id' in statement) {
+        const { id } = statement;
+        if (isOxcNode(id) && id.type === 'Identifier') {
+            bindings.add(id.name);
+        }
+        return bindings;
+    }
+    if (statement.type === 'ExportNamedDeclaration') {
+        const { declaration } = statement;
+        return isOxcNode(declaration)
+            ? collectTopLevelBindings(declaration)
+            : bindings;
+    }
+    return bindings;
+};
+export const collectTopLevelStatementInfos = (program) => program.body.map((statement) => ({
+    bindings: collectTopLevelBindings(statement),
+    node: statement,
+    references: collectReferencedNames(statement),
+}));
+export const collectTopLevelBindingsFromStatements = (statements) => new Set(statements.flatMap((statement) => [...statement.bindings]));
+export const collectRemovableNamesFromStatements = (statements, initialNames) => {
+    const removable = new Set(initialNames);
+    const bindingToStatement = new Map();
+    statements.forEach((statement) => {
+        statement.bindings.forEach((name) => {
+            bindingToStatement.set(name, statement);
+        });
+    });
+    const queue = [...removable];
+    while (queue.length > 0) {
+        const name = queue.shift();
+        const statement = bindingToStatement.get(name);
+        if (statement) {
+            statement.references.forEach((reference) => {
+                if (bindingToStatement.has(reference) && !removable.has(reference)) {
+                    removable.add(reference);
+                    queue.push(reference);
+                }
+            });
+        }
+    }
+    return removable;
+};

package/types/utils/applyOxcProcessors/cleanupRemovals.d.ts

@@ -0,0 +1,16 @@
+import type { Program } from 'oxc-parser';
+import type { Replacement, ScopedBindingInfo, ScopedCleanupScope, TopLevelStatementInfo } from './types';
+export declare const createScopedCleanupScope: (parent: ScopedCleanupScope | null) => ScopedCleanupScope;
+export declare const resolveScopedBinding: (scope: ScopedCleanupScope, name: string) => string | null;
+export declare const collectScopedBindingInfos: (program: Program) => Map<string, ScopedBindingInfo>;
+export declare const collectScopedRemovableBindingIds: (bindings: Map<string, ScopedBindingInfo>, initialNames: Set<string>) => Set<string>;
+export declare function expandImportRemovalRange(code: string, start: number, end: number): Replacement;
+export declare const collectUnusedScopedDeclarationRemovals: (code: string, bindings: Map<string, ScopedBindingInfo>, initialRemovableNames: Set<string>) => Replacement[];
+export declare const expandImportSpecifierRemovalRange: (code: string, start: number, end: number) => Replacement;
+export declare const mergeEmptyRemovalRanges: (removals: Replacement[]) => Replacement[];
+export declare const collectUnusedImportRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>, preserveSideEffectImportLocals: Set<string>, preserveSideEffectImportOrderLocals?: Set<string>) => Replacement[];
+export declare const collectUnusedTopLevelDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>) => Replacement[];
+export declare const collectUnusedGeneratedHelperDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>) => Replacement[];
+export declare const collectTopLevelExpressionStatementRemovals: (code: string, statements: TopLevelStatementInfo[], topLevelBindings: Set<string>, removableExpressionRefs: Set<string>) => Replacement[];
+export declare const collectEmptyTopLevelBlockRemovals: (code: string, program: Program) => Replacement[];
+export declare const removeUnusedAfterReplacement: (code: string, filename: string, initialRemovableNames: Set<string>, removableExpressionRefs: Set<string>, preserveSideEffectImportLocals: Set<string>, preserveSideEffectImportOrderLocals?: Set<string>) => string;