obj arr.js

function Node(kind) {
    this.kind = kind;
}

var node = new Node(0);

var node1 = new Node(1);
node1.expression = node;

var node2 = new Node(2);
node2.leftExpression = node;

var node3 = new Node(3);
node3.rightExpression = node;

var node4 = new Node(4);
node4.doExpression = node;

var node5 = new Node(5);
node5.whileExpression = node;

var node6 = new Node(6);
node6.ifExpression = node;

var node7 = new Node(7);
node7.elseExpression = node;

var node8 = new Node(8);
node8.functionExpression = node;

var node9 = new Node(9);
node9.binaryExpression = node;

var node10 = new Node(10);
node10.literalExpression = node;

var node11 = new Node(11);
node11.assignmentExpression = node;

var node12 = new Node(12);
node12.equalExpression = node;

var node13 = new Node(13);
node13.lessExpression = node;

var node14 = new Node(14);
node14.greaterExpression = node;


var anode = [1, [1, null]];
var anode1 = [1, anode];
var anode2 = [2, anode, 3];
var anode3 = [3, anode, 3, {}];
var anode4 = [4, anode, 3, {}, null];
var anode5 = [5, anode, 3, true, false];
var anode6 = [6, anode, 3, true, false];
var anode7 = [7, anode, 3, true, false];
var anode8 = [8, anode, node, node];
var anode9 = [9, anode, 3, node, true, true];
var anode10 = [10, anode, 3, {}];
var anode11 = [11, anode, 3, {}, null];
var anode12 = [12, anode, 3, node, false];
var anode13 = [13, anode, 3, true, false, node];
var anode14 = [14, anode, 3, true, 123, {id: 1}];

/*for (let i = 0; i < 1; i++) {
 sw(node1); // monomorphic
 sw(node2); // polymorphic
 sw(node3); // polymorphic
 sw(node4); // polymorphic
 sw(node5); // megamorphic
 }*/

/*


 for (let i = 0; i < 100; i++) {
 sw2(node1); // monomorphic
 sw2(node2); // polymorphic
 sw2(node3); // polymorphic
 sw2(node4); // polymorphic
 sw2(node5); // megamorphic
 }



 */

function sw(node) {
    switch (node.kind) {
        case 1:
            return node.name;
        case 2:
            return node.left + node.right;
        case 3:
            return node.expression + node.x;
        case 4:
            return node.flags + node.y;
        case 5:
            return node.symbol.id + node.value;
        case 6:
            return node.rightExpression;
    }
}


function perf(node, count) {
    console.time('perf');
    var ret;
    for (var i = 0; i < count; i++) {
        // to skip hoist expression by optimizer add condition
        ret = sw(i === -1 ? null : node);
        // ret = sw(i === -1 ? null : node2);
        // ret = sw(i === -1 ? null : node3);
        // ret = sw(i === -1 ? null : node4);
        // ret = sw(i === -1 ? null : node5);
    }
    console.timeEnd('perf');
    return ret;
}


function swX(node) {
    return node.kind;
}

function perfx(node, count) {
    console.time('perfx');

    var ret;
    for (var i = 0; i < count; i++) {
        // to skip hoist expression by optimizer add condition
        ret = swX(i === -1 ? null : node);
    }
    console.timeEnd('perfx');
    return ret;
}


function swA(node) {
    switch (node[0]) {
        case 1:
            return node[3];
        case 2:
            return node[3] + node[4];
        case 3:
            return node[3] + node[6];
        case 4:
            return node[3] + node[7];
        case 5:
            return node[3].id + node[8];
    }
}

function perfA(node, count) {
    console.time('perfA');
    var ret;
    for (var i = 0; i < count; i++) {
        // to skip hoist expression by optimizer add condition
        ret = swA(i === -1 ? null : node);
        // ret = swA(i === -1 ? null : anode2);
        // ret = swA(i === -1 ? null : anode3);
        // ret = swA(i === -1 ? null : anode4);
        // ret = swA(i === -1 ? null : anode5);
    }
    console.timeEnd('perfA');
    return ret;
}


function vn(node) {

}

function forEachChild(n) {
    switch (n.kind) {
        case 1:
            return vn(n.expression);
        case 2:
            return vn(n.leftExpression);
        case 3:
            return vn(n.rightExpression);
        case 4:
            return vn(n.doExpression);
        case 5:
            return vn(n.whileExpression);
        case 6:
            return vn(n.ifExpression);
        case 7:
            return vn(n.elseExpression);
        case 8:
            return vn(n.functionExpression);
        case 9:
            return vn(n.binaryExpression);
        case 10:
            return vn(n.literalExpression);
        case 11:
            return vn(n.assignmentExpression);
        case 12:
            return vn(n.equalExpression);
        case 13:
            return vn(n.lessExpression);
        case 14:
            return vn(n.greaterExpression);
    }
}

function vna(node) {
    return node[1];
    // if (node[0] === 1) {
    //     return node[1];
    // }
}

for (let i = 0; i < 100000; i++) {
    // vna(anode1);
    // vna(anode2);
    // vna(anode3);
    // vna(anode4);
    // vna(anode5);
}

// vna(anode1);
// vna(anode2);
// vna(anode3);

function forEachChildArr(n) {
    switch (n[0]) {
case 1:return vna(n[1]);
case 2:return vna(n[1]);
case 3:return vna(n[1]);
case 4:return vna(n[1]);
case 5:return vna(n[1]);
case 6:return vna(n[1]);
case 7:return vna(n[1]);
case 8:return vna(n[1]);
case 9:return vna(n[1]);
case 10:return vna(n[1]);
case 11:return vna(n[1]);
case 12:return vna(n[1]);
case 13:return vna(n[1]);
case 14:return vna(n[1]);
    }
}


function swAX(node) {
    return node[0] + node[1] + node[2];
}

function perfAX(node, count) {
    console.time('perfAX');
    var ret;
    for (var i = 0; i < count; i++) {
        // to skip hoist expression by optimizer add condition
        ret = swAX(i === -1 ? null : node);
    }
    console.timeEnd('perfAX');
    return ret;
}


function perfForEachChild(node) {
    console.time('ForEachChild');
    for (let i = 0; i < 1e7; i++) {
        forEachChild(i === -1 ? null : node)
    }
    console.timeEnd('ForEachChild');
}

function perfForEachChildArr(node) {
    console.time('perfForEachChildArr');
    for (let i = 0; i < 1e7; i++) {
        forEachChildArr(i === -1 ? null : node)
    }
    console.timeEnd('perfForEachChildArr');
}


/*function sw2(node) {
 if (node.kind === 1) return node.name;
 else if (node.kind === 2) return node.left + node.right;
 else if (node.kind === 3) return node.expression;
 else if (node.kind === 4) return node.flags;
 else if (node.kind === 5) return node.symbol;
 }*/


/*for (let i = 0; i < 1e7; i++) {
 sw(i === -1 ? null : node1);
 }*/


// sw(node2);

/*for (let i = 0; i < 1e7; i++) {
 sw(i === -1 ? null : node1);
 sw(i === -1 ? null : node2);
 sw(i === -1 ? null : node3);
 sw(i === -1 ? null : node4);
 sw(i === -1 ? null : node5);
 }*/


// swA(anode1);
// swA(anode2);
// swA(anode3);
// swA(anode4);
// swA(anode5);

for (let i = 0; i < 0; i++) {
    sw(node1);
    sw(node2);
    sw(node3);
    sw(node4);
    sw(node5);
    sw(node6);
}


for (let i = 0; i < 0; i++) {
    swAX(node1);
    swAX(node2);
    swAX(node3);
    swAX(node4);
    swAX(node5);
}

for (let i = 0; i < 10; i++) {
    forEachChild(node1);
    forEachChild(node2);
    forEachChild(node3);
    forEachChild(node4);
    forEachChild(node5);
    forEachChild(node6);
    forEachChild(node7);
    forEachChild(node8);
    forEachChild(node9);
    forEachChild(node10);
    forEachChild(node11);
    forEachChild(node12);
    forEachChild(node13);
    forEachChild(node14);
}

// perfForEachChild(node1);
// perfForEachChild(node2);
// perfForEachChild(node3);
// perfForEachChild(node4);
// perfForEachChild(node5);
// perfForEachChild(node6);
// perfForEachChild(node7);
// perfForEachChild(node8);
// perfForEachChild(node9);
// perfForEachChild(node10);
// perfForEachChild(node11);
// perfForEachChild(node12);
// perfForEachChild(node13);
// perfForEachChild(node14);


for (let i = 0; i < 100; i++) {
    forEachChildArr(anode1);
    forEachChildArr(anode2);
    forEachChildArr(anode3);
    forEachChildArr(anode4);
    forEachChildArr(anode5);
    forEachChildArr(anode6);
    forEachChildArr(anode7);
    forEachChildArr(anode8);
    forEachChildArr(anode9);
    forEachChildArr(anode10);
    forEachChildArr(anode11);
    forEachChildArr(anode12);
    forEachChildArr(anode13);
    forEachChildArr(anode14);
}



perfForEachChildArr(anode1);
// perfForEachChildArr(anode2);

/*for (let i = 0; i < 1e7; i++) {
 sw(i === -1 ? null : node1);
 }*/
// perf(node5, 1e7);
// perfx(node1, 1e7);
// perfAX(node1, 1e7);
// forEachChild();
// perfForEachChild(node1);
// perfA(anode5, 1e7);