Traversion of AST (acorn parser) in Nodejs

ast-traverse.js

async function iterator(node) {
    if (node) {
        switch (node.type) {
            case "AssignmentExpression":
                iterator(node.right)
                break;

            case "ArrayExpression":
                for (var i = 0, i_bound = node.elements.length; i < i_bound; i++) iterator(node.elements[i])
                break;

            case "ArrowFunctionExpression": case "FunctionDeclaration": case "FunctionExpression":
                iterator(node.body)
                break;

            case "AwaitExpression":
                iterator(node.argument)
                break;

            case "BinaryExpression": case "LogicalExpression":
                iterator(node.left)
                iterator(node.right)
                break;

            case "BlockStatement": case "ClassBody": case "Program":
                for (var i = 0, i_bound = node.body.length; i < i_bound; i++) iterator(node.body[i]);
                break;

            case "CallExpression":
                iterator(node.callee)
                for (var i = 0, i_bound = node.arguments.length; i < i_bound; i++) iterator(node.arguments[i])
                break;

            case "CatchClause":
                iterator(node.body)
                break;

            case "ClassDeclaration":
                iterator(node.superClass)
                iterator(node.body)
                break;

            case "ClassExpression":
                iterator(node.superClass);
                iterator(node.body);
                break;

            case "ConditionalExpression": case "IfStatement":
                iterator(node.test)
                iterator(node.consequent)
                iterator(node.alternate)
                break;

            case "DoWhileStatement": case "WhileStatement":
                iterator(node.test)
                iterator(node.body)
                break;

            case "ExportDefaultDeclaration":
                iterator(node.declaration);
                break;

            case "ExportNamedDeclaration":
                if (node.declaration === "FunctionDeclaration") this.iterator(node.declaration)
                break;

            case "ExpressionStatement":
                iterator(node.callee)
                iterator(node.expression);
                break;

            case "ForStatement":
                iterator(node.init)
                iterator(node.test)
                iterator(node.update)
                iterator(node.body)
                break;

            case "ForOfStatement": case "ForInStatement":
                iterator(node.left)
                iterator(node.right)
                iterator(node.body)
                break;

            case "Identifier":
                break;

            case "ImportExpression":
                break;

            case "Literal":
                break;

            case "MethodDefinition":
                iterator(node.value)
                break;

            case "MemberExpression":
                iterator(node.object)
                iterator(node.property)
                break;

            case "NewExpression":
                iterator(node.callee)
                for (var i = 0, i_bound = node.arguments.length; i < i_bound; i++) iterator(node.arguments[i])
                break;

            case "ObjectExpression":
                for (var i = 0, i_bound = node.properties.length; i < i_bound; i++) iterator(node.properties[i].value)
                break;

            case "ReturnStatement": case "SpreadElement":
                iterator(node.argument)
                break;

            case "SequenceExpression":
                for (var i = 0, i_bound = node.expressions.length; i < i_bound; i++) iterator(node.expressions[i])
                break;

            case "SwitchCase":
                for (var i = 0, i_bound = node.consequent.length; i < i_bound; i++) iterator(node.consequent[i])
                break;

            case "SwitchStatement":
                iterator(node.disciminant)
                for (var i = 0, i_bound = node.cases.length; i < i_bound; i++) iterator(node.cases[i])
                break;

            case "TemplateLiteral":
                for (var i = 0, i_bound = node.expressions.length; i < i_bound; i++) iterator(node.expressions[i])
                break;

            case "ThrowStatement":
                iterator(node.argument)
                break;

            case "TryStatement":
                iterator(node.block)
                iterator(node.handler)
                break;

            case "UnaryExpression":
                iterator(node.argument)
                break;

            case "UpdateExpression":
                iterator(node.argument)
                break;

            case "VariableDeclaration":
                //traverse declarator
                break;

            case "YieldExpression":
                iterator(node.argument);
                break;
        }
    }
}