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

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

@@ -0,0 +1,391 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { createOxcStaticCallableValue } from '../../../utils/collectOxcTemplateDependencies';
+import { getOxcNodeChildren } from '../../../utils/oxc/ast';
+import { parseProgram } from './environment';
+export const moduleExportName = (node) => node.type === 'Literal' ? String(node.value) : node.name;
+export const unwrapExpression = (expr) => {
+    let current = expr;
+    for (;;) {
+        if (current.type === 'TSAsExpression' ||
+            current.type === 'TSSatisfiesExpression' ||
+            current.type === 'TSNonNullExpression' ||
+            current.type === 'TSInstantiationExpression' ||
+            current.type === 'TSTypeAssertion' ||
+            current.type === 'ParenthesizedExpression') {
+            current = current.expression;
+            continue;
+        }
+        return current;
+    }
+};
+export const isProcessEnvMember = (node) => {
+    if (node.type !== 'MemberExpression' || node.computed) {
+        return false;
+    }
+    if (node.property.type !== 'Identifier' || node.property.name !== 'env') {
+        return false;
+    }
+    return node.object.type === 'Identifier' && node.object.name === 'process';
+};
+export const isSafeLiteral = (node) => {
+    if (node.type !== 'Literal') {
+        return false;
+    }
+    const { value } = node;
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+};
+export const isSafeStaticExpression = (expr, options = {}) => {
+    const unwrapped = unwrapExpression(expr);
+    if (isSafeLiteral(unwrapped)) {
+        return true;
+    }
+    if (unwrapped.type === 'Identifier') {
+        return true;
+    }
+    if (unwrapped.type === 'TemplateLiteral') {
+        return unwrapped.expressions.every((item) => isSafeStaticExpression(item, options));
+    }
+    if (unwrapped.type === 'UnaryExpression') {
+        return isSafeStaticExpression(unwrapped.argument, options);
+    }
+    if (unwrapped.type === 'BinaryExpression' ||
+        unwrapped.type === 'LogicalExpression') {
+        return (isSafeStaticExpression(unwrapped.left, options) &&
+            isSafeStaticExpression(unwrapped.right, options));
+    }
+    if (unwrapped.type === 'ConditionalExpression') {
+        return (isSafeStaticExpression(unwrapped.test, options) &&
+            isSafeStaticExpression(unwrapped.consequent, options) &&
+            isSafeStaticExpression(unwrapped.alternate, options));
+    }
+    if (unwrapped.type === 'MemberExpression') {
+        return (isSafeStaticExpression(unwrapped.object, options) &&
+            (unwrapped.computed
+                ? isSafeStaticExpression(unwrapped.property, options)
+                : unwrapped.property.type === 'Identifier'));
+    }
+    if (options.allowMetadataCalls && unwrapped.type === 'CallExpression') {
+        return (unwrapped.callee.type === 'Identifier' && unwrapped.arguments.length === 0);
+    }
+    if (unwrapped.type === 'CallExpression' &&
+        options.staticHelperLocals &&
+        unwrapped.callee.type === 'Identifier' &&
+        options.staticHelperLocals.has(unwrapped.callee.name)) {
+        return unwrapped.arguments.every((argument) => argument.type === 'SpreadElement'
+            ? isSafeStaticExpression(argument.argument, options)
+            : isSafeStaticExpression(argument, options));
+    }
+    if (options.allowMetadataCalls &&
+        (unwrapped.type === 'ArrowFunctionExpression' ||
+            unwrapped.type === 'FunctionExpression')) {
+        return (!unwrapped.async &&
+            unwrapped.params.length === 0 &&
+            !!unwrapped.body &&
+            isSafeFunctionBodyExpression(unwrapped.body, options));
+    }
+    if (unwrapped.type === 'ArrayExpression') {
+        return unwrapped.elements.every((item) => {
+            if (!item) {
+                return false;
+            }
+            return item.type === 'SpreadElement'
+                ? isSafeStaticExpression(item.argument, options)
+                : isSafeStaticExpression(item, options);
+        });
+    }
+    if (unwrapped.type === 'ObjectExpression') {
+        return unwrapped.properties.every((property) => {
+            if (property.type === 'SpreadElement') {
+                return isSafeStaticExpression(property.argument);
+            }
+            const propertyNode = property;
+            if (propertyNode.method) {
+                return false;
+            }
+            // Computed keys are admissible as long as the key expression
+            // itself is safe-static — the downstream evaluator already folds
+            // them against the env. Common shape: `[\`${imp} &\`]: { ... }`.
+            if (propertyNode.computed &&
+                (!propertyNode.key ||
+                    typeof propertyNode.key !== 'object' ||
+                    !isSafeStaticExpression(propertyNode.key, options))) {
+                return false;
+            }
+            return (propertyNode.value &&
+                typeof propertyNode.value === 'object' &&
+                isSafeStaticExpression(propertyNode.value, options));
+        });
+    }
+    return false;
+};
+export const isTypeOnlyImport = (statement) => {
+    if (statement.importKind === 'type') {
+        return true;
+    }
+    return statement.specifiers.every((specifier) => specifier.type === 'ImportSpecifier' &&
+        specifier.importKind === 'type');
+};
+export const getImportBinding = (statement, specifier, options = {}) => {
+    const local = specifier.local?.name;
+    if (!local) {
+        return null;
+    }
+    if (specifier.type === 'ImportNamespaceSpecifier') {
+        return options.includeNamespace
+            ? {
+                imported: '*',
+                local,
+                source: statement.source.value,
+            }
+            : null;
+    }
+    if (specifier.type === 'ImportDefaultSpecifier') {
+        return {
+            imported: 'default',
+            local,
+            source: statement.source.value,
+        };
+    }
+    if (specifier.type !== 'ImportSpecifier') {
+        return null;
+    }
+    if (statement.importKind === 'type' ||
+        specifier.importKind === 'type') {
+        return null;
+    }
+    return {
+        imported: moduleExportName(specifier.imported),
+        local,
+        source: statement.source.value,
+    };
+};
+export const collectImportBindings = (program, options = {}) => {
+    const result = new Map();
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration' || isTypeOnlyImport(statement)) {
+            return;
+        }
+        statement.specifiers.forEach((specifier) => {
+            const binding = getImportBinding(statement, specifier, options);
+            if (binding) {
+                result.set(binding.local, binding);
+            }
+        });
+    });
+    return result;
+};
+export const parseStaticExpressionSource = (source, filename) => {
+    try {
+        const program = parseProgram(`const __wyw_static_value = ${source};`, filename);
+        const declaration = program.body[0];
+        if (declaration?.type !== 'VariableDeclaration') {
+            return null;
+        }
+        const [declarator] = declaration.declarations;
+        return declarator?.init ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+export const isRuntimeCallbackExpression = (expression) => {
+    const unwrapped = expression ? unwrapExpression(expression) : null;
+    return (unwrapped?.type === 'ArrowFunctionExpression' ||
+        unwrapped?.type === 'FunctionExpression');
+};
+export const runtimeCallbackPlaceholder = () => undefined;
+export const isIdentifierBindingPosition = (node, parent) => {
+    if (node.type !== 'Identifier' || !parent) {
+        return false;
+    }
+    if ((parent.type === 'VariableDeclarator' && parent.id === node) ||
+        (parent.type === 'FunctionDeclaration' && parent.id === node) ||
+        (parent.type === 'FunctionExpression' && parent.id === node) ||
+        (parent.type === 'ClassDeclaration' && parent.id === node) ||
+        (parent.type === 'ClassExpression' && parent.id === node)) {
+        return true;
+    }
+    if ((parent.type === 'ArrowFunctionExpression' ||
+        parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression') &&
+        parent.params.some((param) => param === node)) {
+        return true;
+    }
+    return ((parent.type === 'ImportSpecifier' && parent.local === node) ||
+        (parent.type === 'ImportDefaultSpecifier' && parent.local === node) ||
+        (parent.type === 'ImportNamespaceSpecifier' && parent.local === node));
+};
+export const isPropertyKeyOnlyIdentifier = (node, parent) => node.type === 'Identifier' &&
+    !!parent &&
+    ((parent.type === 'MemberExpression' &&
+        parent.property === node &&
+        !parent.computed) ||
+        (parent.type === 'Property' &&
+            parent.key === node &&
+            !parent.computed &&
+            !parent.shorthand));
+export const expressionUsesNameOnlyAsZeroArgCalls = (expression, name) => {
+    let seen = false;
+    let valid = true;
+    const walk = (node, parent) => {
+        if (!valid) {
+            return;
+        }
+        if (node.type === 'Identifier' &&
+            node.name === name &&
+            !isIdentifierBindingPosition(node, parent) &&
+            !isPropertyKeyOnlyIdentifier(node, parent)) {
+            if (parent?.type === 'CallExpression' &&
+                parent.callee === node &&
+                parent.arguments.length === 0) {
+                seen = true;
+            }
+            else {
+                valid = false;
+                return;
+            }
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(expression, null);
+    return seen && valid;
+};
+export const bindStaticResolvedValue = (env, expression, local, resolved, options = {}) => {
+    if (resolved.callable === 'zero-arg') {
+        if (!expressionUsesNameOnlyAsZeroArgCalls(expression, local)) {
+            return false;
+        }
+        env.set(local, createOxcStaticCallableValue(resolved.value));
+        return true;
+    }
+    env.set(local, options.wrapNonCallable
+        ? createOxcStaticCallableValue(resolved.value)
+        : resolved.value);
+    return true;
+};
+export const isSafeFunctionBodyExpression = (body, options) => {
+    if (body.type !== 'BlockStatement') {
+        return isSafeStaticExpression(body, options);
+    }
+    return body.body.every((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            return (statement.kind === 'const' &&
+                statement.declarations.every((declarator) => declarator.init &&
+                    declarator.id.type === 'Identifier' &&
+                    isSafeStaticExpression(declarator.init, options)));
+        }
+        return (statement.type === 'ReturnStatement' &&
+            !!statement.argument &&
+            isSafeStaticExpression(statement.argument, options));
+    });
+};
+export const collectStaticFunctionBodyReferences = (body, references, options) => {
+    if (body.type !== 'BlockStatement') {
+        return collectStaticExpressionReferences(body, references, options);
+    }
+    return body.body.every((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            return (statement.kind === 'const' &&
+                statement.declarations.every((declarator) => declarator.init &&
+                    declarator.id.type === 'Identifier' &&
+                    collectStaticExpressionReferences(declarator.init, references, options)));
+        }
+        return (statement.type === 'ReturnStatement' &&
+            !!statement.argument &&
+            collectStaticExpressionReferences(statement.argument, references, options));
+    });
+};
+export const collectStaticExpressionReferences = (expr, references, options = {}) => {
+    const unwrapped = unwrapExpression(expr);
+    if (isSafeLiteral(unwrapped)) {
+        return true;
+    }
+    if (unwrapped.type === 'Identifier') {
+        references.add(unwrapped.name);
+        return true;
+    }
+    if (unwrapped.type === 'TemplateLiteral') {
+        return unwrapped.expressions.every((item) => collectStaticExpressionReferences(item, references, options));
+    }
+    if (unwrapped.type === 'UnaryExpression') {
+        return collectStaticExpressionReferences(unwrapped.argument, references, options);
+    }
+    if (unwrapped.type === 'BinaryExpression' ||
+        unwrapped.type === 'LogicalExpression') {
+        return (collectStaticExpressionReferences(unwrapped.left, references, options) &&
+            collectStaticExpressionReferences(unwrapped.right, references, options));
+    }
+    if (unwrapped.type === 'ConditionalExpression') {
+        return (collectStaticExpressionReferences(unwrapped.test, references, options) &&
+            collectStaticExpressionReferences(unwrapped.consequent, references, options) &&
+            collectStaticExpressionReferences(unwrapped.alternate, references, options));
+    }
+    if (unwrapped.type === 'MemberExpression') {
+        if (isProcessEnvMember(unwrapped) || isProcessEnvMember(unwrapped.object)) {
+            // process.env / process.env.X is an opaque build-time global —
+            // don't treat `process` as an unresolved local reference.
+            return true;
+        }
+        return (collectStaticExpressionReferences(unwrapped.object, references, options) &&
+            (!unwrapped.computed ||
+                collectStaticExpressionReferences(unwrapped.property, references, options)));
+    }
+    if (options.allowMetadataCalls && unwrapped.type === 'CallExpression') {
+        if (unwrapped.callee.type !== 'Identifier' ||
+            unwrapped.arguments.length !== 0) {
+            return false;
+        }
+        references.add(unwrapped.callee.name);
+        return true;
+    }
+    if (unwrapped.type === 'CallExpression' &&
+        options.staticHelperLocals &&
+        unwrapped.callee.type === 'Identifier' &&
+        options.staticHelperLocals.has(unwrapped.callee.name)) {
+        references.add(unwrapped.callee.name);
+        return unwrapped.arguments.every((argument) => argument.type === 'SpreadElement'
+            ? collectStaticExpressionReferences(argument.argument, references, options)
+            : collectStaticExpressionReferences(argument, references, options));
+    }
+    if (options.allowMetadataCalls &&
+        (unwrapped.type === 'ArrowFunctionExpression' ||
+            unwrapped.type === 'FunctionExpression')) {
+        if (unwrapped.async || unwrapped.params.length !== 0) {
+            return false;
+        }
+        return (!!unwrapped.body &&
+            collectStaticFunctionBodyReferences(unwrapped.body, references, options));
+    }
+    if (unwrapped.type === 'ArrayExpression') {
+        return unwrapped.elements.every((item) => {
+            if (!item) {
+                return false;
+            }
+            return item.type === 'SpreadElement'
+                ? collectStaticExpressionReferences(item.argument, references, options)
+                : collectStaticExpressionReferences(item, references, options);
+        });
+    }
+    if (unwrapped.type === 'ObjectExpression') {
+        return unwrapped.properties.every((property) => {
+            if (property.type === 'SpreadElement') {
+                return collectStaticExpressionReferences(property.argument, references, options);
+            }
+            const propertyNode = property;
+            if (!propertyNode.value || typeof propertyNode.value !== 'object') {
+                return false;
+            }
+            if (propertyNode.computed &&
+                (!propertyNode.key ||
+                    typeof propertyNode.key !== 'object' ||
+                    !collectStaticExpressionReferences(propertyNode.key, references, options))) {
+                return false;
+            }
+            return collectStaticExpressionReferences(propertyNode.value, references, options);
+        });
+    }
+    return false;
+};

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

@@ -0,0 +1,14 @@
+import type { Expression, Node, Program } from 'oxc-parser';
+import type { ExportTarget, StaticExpressionDependencies, StaticExpressionOptions } from './types';
+export declare const mutatingMethodNames: Set<string>;
+export declare const rootIdentifierName: (expr: Node) => string | null;
+export declare const staticMemberName: (expr: Node) => string | null;
+export declare const expressionMayProduceMutableValue: (expr: Node, locals: Map<string, Expression>, visiting: Set<string>) => boolean;
+export declare const collectExpressionMutationHints: (expr: Node, mutatedNames: Set<string>, callArgumentNames: Set<string>) => void;
+export declare const collectTopLevelMutationHints: (program: Program, closureNames?: ReadonlySet<string> | null) => {
+    callArgumentNames: Set<string>;
+    mutatedNames: Set<string>;
+};
+export declare const collectStaticExpressionDependencies: (program: Program, target: Extract<ExportTarget, {
+    kind: "expression";
+}>, options?: StaticExpressionOptions) => StaticExpressionDependencies | null;