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

package/types/transform/generators/resolveStaticOxcValues/staticExpressionDependencies.js

@@ -0,0 +1,304 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { collectLocalConstExpressions } from './programAnalysis';
+import { collectImportBindings, collectStaticExpressionReferences, isSafeLiteral, isSafeStaticExpression, unwrapExpression, } from './staticExpression';
+export const mutatingMethodNames = new Set([
+    'add',
+    'clear',
+    'copyWithin',
+    'delete',
+    'fill',
+    'pop',
+    'push',
+    'reverse',
+    'set',
+    'shift',
+    'sort',
+    'splice',
+    'unshift',
+]);
+export const rootIdentifierName = (expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type === 'Identifier') {
+        return unwrapped.name;
+    }
+    if (unwrapped.type === 'MemberExpression') {
+        return rootIdentifierName(unwrapped.object);
+    }
+    if (unwrapped.type === 'ChainExpression') {
+        return rootIdentifierName(unwrapped.expression);
+    }
+    return null;
+};
+export const staticMemberName = (expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type === 'Identifier') {
+        return unwrapped.name;
+    }
+    if (isSafeLiteral(unwrapped) && typeof unwrapped.value === 'string') {
+        return unwrapped.value;
+    }
+    return null;
+};
+export const expressionMayProduceMutableValue = (expr, locals, visiting) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type === 'ObjectExpression' ||
+        unwrapped.type === 'ArrayExpression') {
+        return true;
+    }
+    if (unwrapped.type === 'Identifier') {
+        const local = locals.get(unwrapped.name);
+        if (!local || visiting.has(unwrapped.name)) {
+            return true;
+        }
+        visiting.add(unwrapped.name);
+        const result = expressionMayProduceMutableValue(local, locals, visiting);
+        visiting.delete(unwrapped.name);
+        return result;
+    }
+    if (unwrapped.type === 'ConditionalExpression') {
+        return (expressionMayProduceMutableValue(unwrapped.consequent, locals, visiting) ||
+            expressionMayProduceMutableValue(unwrapped.alternate, locals, visiting));
+    }
+    if (unwrapped.type === 'LogicalExpression' ||
+        unwrapped.type === 'MemberExpression') {
+        return true;
+    }
+    return false;
+};
+export const collectExpressionMutationHints = (expr, mutatedNames, callArgumentNames) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type === 'AssignmentExpression') {
+        const rootName = rootIdentifierName(unwrapped.left);
+        if (rootName) {
+            mutatedNames.add(rootName);
+        }
+        collectExpressionMutationHints(unwrapped.right, mutatedNames, callArgumentNames);
+        return;
+    }
+    if (unwrapped.type === 'UpdateExpression') {
+        const rootName = rootIdentifierName(unwrapped.argument);
+        if (rootName) {
+            mutatedNames.add(rootName);
+        }
+        return;
+    }
+    if (unwrapped.type === 'UnaryExpression') {
+        if (unwrapped.operator === 'delete') {
+            const rootName = rootIdentifierName(unwrapped.argument);
+            if (rootName) {
+                mutatedNames.add(rootName);
+            }
+        }
+        collectExpressionMutationHints(unwrapped.argument, mutatedNames, callArgumentNames);
+        return;
+    }
+    if (unwrapped.type === 'CallExpression') {
+        const callee = unwrapExpression(unwrapped.callee);
+        if (callee.type === 'MemberExpression') {
+            const methodName = staticMemberName(callee.property);
+            const rootName = rootIdentifierName(callee.object);
+            if (rootName && methodName && mutatingMethodNames.has(methodName)) {
+                mutatedNames.add(rootName);
+            }
+            collectExpressionMutationHints(callee.object, mutatedNames, callArgumentNames);
+            if (callee.computed) {
+                collectExpressionMutationHints(callee.property, mutatedNames, callArgumentNames);
+            }
+        }
+        else {
+            collectExpressionMutationHints(unwrapped.callee, mutatedNames, callArgumentNames);
+        }
+        unwrapped.arguments.forEach((argument) => {
+            const argumentNode = argument.type === 'SpreadElement' ? argument.argument : argument;
+            const rootName = rootIdentifierName(argumentNode);
+            if (rootName) {
+                callArgumentNames.add(rootName);
+            }
+            collectExpressionMutationHints(argumentNode, mutatedNames, callArgumentNames);
+        });
+        return;
+    }
+    if (unwrapped.type === 'TaggedTemplateExpression') {
+        collectExpressionMutationHints(unwrapped.tag, mutatedNames, callArgumentNames);
+        unwrapped.quasi.expressions.forEach((item) => collectExpressionMutationHints(item, mutatedNames, callArgumentNames));
+        return;
+    }
+    if (unwrapped.type === 'ConditionalExpression') {
+        collectExpressionMutationHints(unwrapped.test, mutatedNames, callArgumentNames);
+        collectExpressionMutationHints(unwrapped.consequent, mutatedNames, callArgumentNames);
+        collectExpressionMutationHints(unwrapped.alternate, mutatedNames, callArgumentNames);
+        return;
+    }
+    if (unwrapped.type === 'BinaryExpression' ||
+        unwrapped.type === 'LogicalExpression') {
+        collectExpressionMutationHints(unwrapped.left, mutatedNames, callArgumentNames);
+        collectExpressionMutationHints(unwrapped.right, mutatedNames, callArgumentNames);
+        return;
+    }
+    if (unwrapped.type === 'MemberExpression') {
+        collectExpressionMutationHints(unwrapped.object, mutatedNames, callArgumentNames);
+        if (unwrapped.computed) {
+            collectExpressionMutationHints(unwrapped.property, mutatedNames, callArgumentNames);
+        }
+        return;
+    }
+    if (unwrapped.type === 'ArrayExpression') {
+        unwrapped.elements.forEach((item) => {
+            if (!item) {
+                return;
+            }
+            collectExpressionMutationHints(item.type === 'SpreadElement' ? item.argument : item, mutatedNames, callArgumentNames);
+        });
+        return;
+    }
+    if (unwrapped.type === 'ObjectExpression') {
+        unwrapped.properties.forEach((property) => {
+            if (property.type === 'SpreadElement') {
+                collectExpressionMutationHints(property.argument, mutatedNames, callArgumentNames);
+                return;
+            }
+            const propertyNode = property;
+            if (propertyNode.computed && propertyNode.key) {
+                collectExpressionMutationHints(propertyNode.key, mutatedNames, callArgumentNames);
+            }
+            if (propertyNode.value && typeof propertyNode.value === 'object') {
+                collectExpressionMutationHints(propertyNode.value, mutatedNames, callArgumentNames);
+            }
+        });
+    }
+};
+export const collectTopLevelMutationHints = (program, closureNames = null) => {
+    const callArgumentNames = new Set();
+    const mutatedNames = new Set();
+    const collectDeclaration = (declaration) => {
+        declaration.declarations.forEach((declarator) => {
+            if (closureNames) {
+                const declaredName = declarator.id.type === 'Identifier' ? declarator.id.name : null;
+                if (!declaredName || !closureNames.has(declaredName)) {
+                    return;
+                }
+            }
+            if (declarator.init) {
+                collectExpressionMutationHints(declarator.init, mutatedNames, callArgumentNames);
+            }
+        });
+    };
+    program.body.forEach((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            collectDeclaration(statement);
+            return;
+        }
+        if (statement.type === 'ExpressionStatement') {
+            collectExpressionMutationHints(statement.expression, mutatedNames, callArgumentNames);
+            return;
+        }
+        if (statement.type === 'ExportNamedDeclaration') {
+            if (statement.declaration?.type === 'VariableDeclaration') {
+                collectDeclaration(statement.declaration);
+            }
+            return;
+        }
+        if (statement.type === 'ExportDefaultDeclaration') {
+            if (statement.declaration.type !== 'FunctionDeclaration' &&
+                statement.declaration.type !== 'ClassDeclaration') {
+                collectExpressionMutationHints(statement.declaration, mutatedNames, callArgumentNames);
+            }
+        }
+    });
+    return { callArgumentNames, mutatedNames };
+};
+export const collectStaticExpressionDependencies = (program, target, options = {}) => {
+    const imports = collectImportBindings(program);
+    const locals = collectLocalConstExpressions(program);
+    const collectedImports = new Map();
+    const referencedNames = new Set();
+    const mutableReferencedNames = new Set();
+    const visitedLocals = new Set();
+    const visitingLocals = new Set();
+    const markMutable = (name, expression) => {
+        if (expressionMayProduceMutableValue(expression, locals, new Set())) {
+            mutableReferencedNames.add(name);
+        }
+    };
+    const collectLocal = (name) => {
+        // Pre-resolved locals (e.g. `const x = css\`\``) have a known value
+        // (the className string). Skip walking their init — its
+        // TaggedTemplateExpression isn't safe-static by itself, but the
+        // value is already determined.
+        if (options.preResolvedLocals?.has(name)) {
+            referencedNames.add(name);
+            visitedLocals.add(name);
+            return true;
+        }
+        const expression = locals.get(name);
+        if (!expression || visitingLocals.has(name)) {
+            return false;
+        }
+        referencedNames.add(name);
+        markMutable(name, expression);
+        if (visitedLocals.has(name)) {
+            return true;
+        }
+        visitingLocals.add(name);
+        const result = collectExpression(expression);
+        visitingLocals.delete(name);
+        if (result) {
+            visitedLocals.add(name);
+        }
+        return result;
+    };
+    const collectExpression = (expr) => {
+        if (!isSafeStaticExpression(expr, options)) {
+            return false;
+        }
+        const references = new Set();
+        if (!collectStaticExpressionReferences(expr, references, options)) {
+            return false;
+        }
+        for (const reference of references) {
+            referencedNames.add(reference);
+            const importBinding = imports.get(reference);
+            if (importBinding) {
+                collectedImports.set(`${importBinding.source}\0${importBinding.imported}\0${importBinding.local}`, importBinding);
+                mutableReferencedNames.add(reference);
+                continue;
+            }
+            if (!collectLocal(reference)) {
+                // Unknown identifier — neither an import nor a same-file local.
+                // Common case: undeclared globals like __DEV__ used in
+                // `typeof __DEV__ !== "undefined"` short-circuit guards. The
+                // evaluator returns undefined for unknowns, which the outer
+                // expression's logical short-circuits handle correctly. Don't
+                // reject the whole walk upfront — let the evaluator decide.
+                continue;
+            }
+        }
+        return true;
+    };
+    if (target.localName) {
+        referencedNames.add(target.localName);
+        markMutable(target.localName, target.expression);
+    }
+    if (!collectExpression(target.expression)) {
+        return null;
+    }
+    const closureNames = new Set(referencedNames);
+    if (target.localName) {
+        closureNames.add(target.localName);
+    }
+    const mutationHints = collectTopLevelMutationHints(program, closureNames);
+    for (const name of referencedNames) {
+        if (mutationHints.mutatedNames.has(name)) {
+            return null;
+        }
+    }
+    for (const name of mutableReferencedNames) {
+        if (mutationHints.callArgumentNames.has(name) &&
+            !options.ignoredMutableCallArgumentNames?.has(name)) {
+            return null;
+        }
+    }
+    return {
+        imports: [...collectedImports.values()],
+    };
+};

package/types/transform/generators/resolveStaticOxcValues/types.d.ts

@@ -0,0 +1,99 @@
+import type { Expression, Node, Program } from 'oxc-parser';
+import type { OxcTextReplacement } from '../../../utils/oxc/replacements';
+import type { runOxcPreevalStage } from '../../../utils/oxcPreevalStage';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+export type AnyNode = Node & Record<string, unknown>;
+export type ImportBinding = {
+    imported: '*' | 'default' | string;
+    local: string;
+    source: string;
+};
+export type CollectImportBindingsOptions = {
+    includeNamespace?: boolean;
+};
+export type ExportTarget = {
+    expression: Expression;
+    kind: 'expression';
+    localName?: string;
+} | {
+    imported: 'default' | string;
+    kind: 'import';
+    source: string;
+};
+export type StaticExportResult = {
+    callable?: 'zero-arg';
+    dependencies: string[];
+    runtimeOnly?: boolean;
+    sideEffectDependencies?: string[];
+    sideEffectImportLocals?: string[];
+    value: unknown;
+};
+export type StaticFileAnalysis = {
+    code: string;
+    codeHash: string;
+    program: Program;
+};
+export type StaticFileHashCacheEntry = {
+    hash: string;
+    mtimeMs: number;
+    size: number;
+};
+export type StaticMetadataPreevalCacheEntry = {
+    result: null;
+} | {
+    result: ReturnType<typeof runOxcPreevalStage>;
+};
+export type StaticExportCacheEntry = {
+    attempts: number;
+    result: null;
+} | {
+    dependencyHashes: Map<string, string>;
+    result: StaticExportResult;
+};
+export declare const STATIC_EXPORT_MAX_NULL_ATTEMPTS = 2;
+export declare const GENERATED_HELPER_NAME_RE: RegExp;
+export type StaticExpressionOptions = {
+    allowMetadataCalls?: boolean;
+    ignoredMutableCallArgumentNames?: Set<string>;
+    preResolvedLocals?: ReadonlySet<string>;
+    staticHelperLocals?: ReadonlySet<string>;
+};
+export type StaticResolveDebugPhase = 'candidate' | 'entrypoint' | 'export' | 'import' | 'processor-metadata';
+export type StaticResolveDebugStatus = 'rejected' | 'resolved' | 'skipped';
+export type StaticResolveDebugEvent = {
+    candidate?: string;
+    dependency?: string;
+    exported?: string;
+    filename: string;
+    imported?: string;
+    importer?: string;
+    phase: StaticResolveDebugPhase;
+    reason?: string;
+    source?: string;
+    status: StaticResolveDebugStatus;
+};
+export type Range = {
+    end: number;
+    start: number;
+};
+export type Replacement = Range & OxcTextReplacement;
+export type StaticExpressionDependencies = {
+    imports: ImportBinding[];
+};
+export type PreparedProcessorTarget = {
+    dependencies: StaticExpressionDependencies;
+    evaluationCode?: string;
+    evaluationSpan?: Range;
+    expression: Expression;
+    opaqueRuntimeBase: boolean;
+};
+export type OpaqueRuntimeImportProof = {
+    dependencies: string[];
+    names: Set<string>;
+};
+export type ResolveStaticImportValue = (action: ITransformAction, importer: string, binding: Pick<ImportBinding, 'imported' | 'source'>, stack: Set<string>, memo: Map<string, StaticExportResult | null>) => SyncScenarioFor<StaticExportResult | null>;
+export type ResolveStaticExportValue = (action: ITransformAction, filename: string, exportedName: string, stack: Set<string>, memo: Map<string, StaticExportResult | null>) => SyncScenarioFor<StaticExportResult | null>;
+export type StaticExportResolverContext = {
+    resolveImportValue: ResolveStaticImportValue;
+    resolveStaticExport: ResolveStaticExportValue;
+};

package/types/transform/generators/resolveStaticOxcValues/types.js

@@ -0,0 +1,2 @@
+export const STATIC_EXPORT_MAX_NULL_ATTEMPTS = 2;
+export const GENERATED_HELPER_NAME_RE = /^_exp\d*$/;

package/types/transform/generators/resolveStaticOxcValues/zeroArgFunctionStaticExport.d.ts

@@ -0,0 +1,7 @@
+import type { Expression, Program } from 'oxc-parser';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { ExportTarget, ResolveStaticImportValue, StaticExportResult } from './types';
+export declare const zeroArgFunctionReturnExpression: (expression: Expression) => Expression | null;
+export declare function resolveZeroArgFunctionStaticExport(action: ITransformAction, filename: string, code: string, program: Program, target: Extract<ExportTarget, {
+    kind: 'expression';
+}>, stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolveImportValue: ResolveStaticImportValue): SyncScenarioFor<StaticExportResult | null>;

package/types/transform/generators/resolveStaticOxcValues/zeroArgFunctionStaticExport.js

@@ -0,0 +1,64 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpressionAt, isOxcStaticSerializableValue, } from '../../../utils/collectOxcTemplateDependencies';
+import { getStaticBindings } from './environment';
+import { bindStaticResolvedValue, unwrapExpression } from './staticExpression';
+import { collectStaticExpressionDependencies } from './staticExpressionDependencies';
+export const zeroArgFunctionReturnExpression = (expression) => {
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type !== 'ArrowFunctionExpression' &&
+        unwrapped.type !== 'FunctionExpression') {
+        return null;
+    }
+    if (unwrapped.async || unwrapped.params.length !== 0 || !unwrapped.body) {
+        return null;
+    }
+    if (unwrapped.body.type !== 'BlockStatement') {
+        return unwrapped.body;
+    }
+    if (unwrapped.body.body.length !== 1) {
+        return null;
+    }
+    const [statement] = unwrapped.body.body;
+    return statement?.type === 'ReturnStatement' && statement.argument
+        ? statement.argument
+        : null;
+};
+export function* resolveZeroArgFunctionStaticExport(action, filename, code, program, target, stack, memo, resolveImportValue) {
+    const returnExpression = zeroArgFunctionReturnExpression(target.expression);
+    if (!returnExpression) {
+        return null;
+    }
+    const staticDependencies = collectStaticExpressionDependencies(program, {
+        ...target,
+        expression: returnExpression,
+    }, { allowMetadataCalls: true });
+    if (!staticDependencies) {
+        return null;
+    }
+    const env = new Map();
+    const dependencies = new Set([filename]);
+    const sideEffectDependencies = new Set();
+    for (const binding of staticDependencies.imports) {
+        const resolved = yield* resolveImportValue(action, filename, binding, stack, memo);
+        if (!resolved) {
+            return null;
+        }
+        if (!bindStaticResolvedValue(env, returnExpression, binding.local, resolved)) {
+            return null;
+        }
+        resolved.dependencies.forEach((item) => dependencies.add(item));
+        resolved.sideEffectDependencies?.forEach((item) => sideEffectDependencies.add(item));
+    }
+    const value = evaluateOxcStaticExpressionAt(code, filename, {
+        end: returnExpression.end,
+        start: returnExpression.start,
+    }, env, getStaticBindings(action));
+    return isOxcStaticSerializableValue(value)
+        ? {
+            callable: 'zero-arg',
+            dependencies: [...dependencies],
+            sideEffectDependencies: [...sideEffectDependencies],
+            value,
+        }
+        : null;
+}

package/types/transform/generators/resolveStaticOxcValues.d.ts

@@ -1,2 +1 @@
-import type { ITransformAction, SyncScenarioFor } from '../types';
-export declare function resolveStaticOxcPreevalValues(this: ITransformAction): SyncScenarioFor<boolean>;
+export { resolveStaticOxcPreevalValues } from './resolveStaticOxcValues/resolveStaticOxcPreevalValues';