Is there an interpreter that returns an enlarged AST?

Question

I’m using an interpreter that returns a AST I don’t know how I’ll read.

{
    clauses: [
        {
            body: [/* ...*/],
            condition: {/* ...*/},
            type: "IfClause"
        }
    ],
    type: "IfStatement"
}

I have to make a unique loop to deal with this tree and a lot of conditions to memorize the property I went through inside, etc. I’m sure I’m doing it the wrong way, so I would like another kind of tree.

{
    type: "IfClause"
},
{
    type: "Literal",
    value: false
},
{
    type: "BlockStatement"
},
{
    type: "Endif"
}

Or has another solution?

Answer 1

Basically what you are wanting will hardly be supported natively since the very concept of tree is hierarchical by nature.

What is your goal? Is it just to "look" and see what you want more easily? Or is it to process the generated tree via code?

A list is simpler for you to see, but it is much more complicated to process, since you will have to recreate all the contexts of each block.

If you have difficulties with these blocks, you may just need to get a little more used to recursive algorithms, for example.

Transforming the list

If you really need a list flat can be generated by processing the AST.

Suppose you have the following fictitious tree:

var astTree = {
    type: "IfClause",
    base:
    {
        type: "Boolean",
        value: false
    },
    body: [
        { type: "Var" },
        { 
            type: "ForClause",
            body: [
                { type: "VarIncrement" }
            ]
        },
        { type: "Return" },
    ]
};

Then you can rely on a recursive function that runs through all subelements that have a body and add to an array. Example:

var flatten = function(node) {
    var list = [];
    function consume(node) {
        list.push(node);
        if ('body' in node) {
            var endNode = { type: node.type + 'End' }
            node.type += "Start";
            node.body.forEach(consume);
            list.push(endNode);
            delete node.body;
        }
    }
    consume(node);
    return list;
}

And the result is:

[
  {
    "type": "IfClauseStart",
    "base": {
      "type": "Boolean",
      "value": false
    }
  },
  {
    "type": "Var"
  },
  {
    "type": "ForClauseStart"
  },
  {
    "type": "VarIncrement"
  },
  {
    "type": "ForClauseEnd"
  },
  {
    "type": "Return"
  },
  {
    "type": "IfClauseEnd"
  }
]

See the functional example