js-slang/dist/utils/statementSeqTransform.js

Javascript-based implementations of Source, written in Typescript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.transform = void 0;
const ast = require("./ast/astCreator");
function hasDeclarations(node) {
    for (const statement of node.body) {
        if (statement.type === 'VariableDeclaration' || statement.type === 'FunctionDeclaration') {
            return true;
        }
    }
    return false;
}
function hasImportDeclarations(node) {
    for (const statement of node.body) {
        if (statement.type === 'ImportDeclaration') {
            return true;
        }
    }
    return false;
}
const transformers = new Map([
    [
        'Program',
        (node) => {
            if (hasDeclarations(node) || hasImportDeclarations(node)) {
                return node;
            }
            else {
                return ast.statementSequence(node.body, node.loc);
            }
        }
    ],
    [
        'BlockStatement',
        (node) => {
            node.body = node.body.map(x => transform(x));
            if (hasDeclarations(node)) {
                return node;
            }
            else {
                return ast.statementSequence(node.body, node.loc);
            }
        }
    ],
    [
        'StatementSequence',
        (node) => {
            node.body = node.body.map(x => transform(x));
            return node;
        }
    ],
    [
        'ExpressionStatement',
        (node) => {
            node.expression = transform(node.expression);
            return node;
        }
    ],
    [
        'IfStatement',
        (node) => {
            node.test = transform(node.test);
            node.consequent = transform(node.consequent);
            if (node.alternate) {
                node.alternate = transform(node.alternate);
            }
            return node;
        }
    ],
    [
        'FunctionDeclaration',
        (node) => {
            node.params = node.params.map(x => transform(x));
            node.body = transform(node.body);
            if (node.id) {
                node.id = transform(node.id);
            }
            return node;
        }
    ],
    [
        'VariableDeclarator',
        (node) => {
            node.id = transform(node.id);
            if (node.init) {
                node.init = transform(node.init);
            }
            return node;
        }
    ],
    [
        'VariableDeclaration',
        (node) => {
            node.declarations = node.declarations.map(x => transform(x));
            return node;
        }
    ],
    [
        'ReturnStatement',
        (node) => {
            if (node.argument) {
                node.argument = transform(node.argument);
            }
            return node;
        }
    ],
    [
        'CallExpression',
        (node) => {
            node.callee = transform(node.callee);
            node.arguments = node.arguments.map(x => transform(x));
            return node;
        }
    ],
    [
        'UnaryExpression',
        (node) => {
            node.argument = transform(node.argument);
            return node;
        }
    ],
    [
        'BinaryExpression',
        (node) => {
            node.left = transform(node.left);
            node.right = transform(node.right);
            return node;
        }
    ],
    [
        'LogicalExpression',
        (node) => {
            node.left = transform(node.left);
            node.right = transform(node.right);
            return node;
        }
    ],
    [
        'ConditionalExpression',
        (node) => {
            node.test = transform(node.test);
            node.consequent = transform(node.consequent);
            node.alternate = transform(node.alternate);
            return node;
        }
    ],
    [
        'ArrowFunctionExpression',
        (node) => {
            node.params = node.params.map(x => transform(x));
            node.body = transform(node.body);
            return node;
        }
    ],
    [
        'Identifier',
        (node) => {
            return node;
        }
    ],
    [
        'Literal',
        (node) => {
            return node;
        }
    ],
    [
        'ArrayExpression',
        (node) => {
            node.elements = node.elements.map(x => (x ? transform(x) : null));
            return node;
        }
    ],
    [
        'AssignmentExpression',
        (node) => {
            node.left = transform(node.left);
            node.right = transform(node.right);
            return node;
        }
    ],
    [
        'ForStatement',
        (node) => {
            if (node.init) {
                node.init = transform(node.init);
            }
            if (node.test) {
                node.test = transform(node.test);
            }
            if (node.update) {
                node.update = transform(node.update);
            }
            node.body = transform(node.body);
            return node;
        }
    ],
    [
        'WhileStatement',
        (node) => {
            node.test = transform(node.test);
            node.body = transform(node.body);
            return node;
        }
    ],
    [
        'BreakStatement',
        (node) => {
            if (node.label) {
                node.label = transform(node.label);
            }
            return node;
        }
    ],
    [
        'ContinueStatement',
        (node) => {
            if (node.label) {
                node.label = transform(node.label);
            }
            return node;
        }
    ],
    [
        'ObjectExpression',
        (node) => {
            node.properties = node.properties.map(x => transform(x));
            return node;
        }
    ],
    [
        'MemberExpression',
        (node) => {
            node.object = transform(node.object);
            node.property = transform(node.property);
            return node;
        }
    ],
    [
        'Property',
        (node) => {
            node.key = transform(node.key);
            node.value = transform(node.value);
            return node;
        }
    ],
    [
        'ImportDeclaration',
        (node) => {
            node.specifiers = node.specifiers.map(x => transform(x));
            node.source = transform(node.source);
            return node;
        }
    ],
    [
        'ImportSpecifier',
        (node) => {
            node.local = transform(node.local);
            node.imported = transform(node.imported);
            return node;
        }
    ],
    [
        'ImportDefaultSpecifier',
        (node) => {
            node.local = transform(node.local);
            return node;
        }
    ],
    [
        'ExportNamedDeclaration',
        (node) => {
            if (node.declaration) {
                node.declaration = transform(node.declaration);
            }
            node.specifiers = node.specifiers.map(x => transform(x));
            if (node.source) {
                transform(node.source);
            }
            return node;
        }
    ],
    [
        'ExportDefaultDeclaration',
        (node) => {
            node.declaration = transform(node.declaration);
            return node;
        }
    ],
    [
        'ExportSpecifier',
        (node) => {
            node.local = transform(node.local);
            node.exported = transform(node.exported);
            return node;
        }
    ],
    [
        'ClassDeclaration',
        (node) => {
            if (node.id) {
                node.id = transform(node.id);
            }
            if (node.superClass) {
                node.superClass = transform(node.superClass);
            }
            node.body = transform(node.body);
            return node;
        }
    ],
    [
        'NewExpression',
        (node) => {
            node.arguments = node.arguments.map(x => transform(x));
            return node;
        }
    ],
    [
        'MethodDefinition',
        (node) => {
            node.key = transform(node.key);
            node.value = transform(node.value);
            return node;
        }
    ],
    [
        'FunctionExpression',
        (node) => {
            if (node.id) {
                node.id = transform(node.id);
            }
            node.params = node.params.map(x => transform(x));
            node.body = transform(node.body);
            return node;
        }
    ],
    [
        'ThisExpression',
        (_node) => {
            return _node;
        }
    ],
    [
        'Super',
        (_node) => {
            return _node;
        }
    ],
    [
        'TryStatement',
        (node) => {
            node.block = transform(node.block);
            if (node.handler) {
                node.handler = transform(node.handler);
            }
            if (node.finalizer) {
                node.finalizer = transform(node.finalizer);
            }
            return node;
        }
    ],
    [
        'ThrowStatement',
        (node) => {
            node.argument = transform(node.argument);
            return node;
        }
    ],
    [
        'SpreadElement',
        (node) => {
            node.argument = transform(node.argument);
            return node;
        }
    ],
    [
        'RestElement',
        (node) => {
            node.argument = transform(node.argument);
            return node;
        }
    ]
]);
function transform(node) {
    if (transformers.has(node.type)) {
        const transformer = transformers.get(node.type);
        const transformed = transformer(node);
        return transformed;
    }
    else {
        return node;
    }
}
exports.transform = transform;
//# sourceMappingURL=statementSeqTransform.js.map