Can I prevent Babel from traversing code inserted by a plugin?

Question

I'm building a plugin that inserts enterFunction() in front of every existing function call by calling path.insertBefore. So my code is transformed from:

myFunction(); 

To:

enterFunction(); myFunction(); 

The problem is that when I insert the node Babel once again traverses the inserted node. Here's the logging output:

'CallExpression', 'myFunction'
'CallExpression', 'enterFunction'

How can I prevent Babel from entering the enterFunction call expression and its children?

This is the code I'm currently using for my Babel plugin:

function(babel) {     return {         visitor: {             CallExpression: function(path) {                 console.log("CallExpression", path.node.callee.name)                 if (path.node.ignore) {                     return;                 }                 path.node.ignore = true                  var enterCall = babel.types.callExpression(                     babel.types.identifier("enterFunction"), []                 )                 enterCall.ignore = true;                 path.insertBefore(enterCall)             }         }     } } 

Answer 1

The Babel Handbook mentions the following section:

If your plugin needs to not run in a certain situation, the simpliest thing to do is to write an early return.

BinaryExpression(path) {   if (path.node.operator !== '**') return; } 

If you are doing a sub-traversal in a top level path, you can use 2 provided API methods:

path.skip() skips traversing the children of the current path. path.stop() stops traversal entirely.

outerPath.traverse({   Function(innerPath) {     innerPath.skip(); // if checking the children is irrelevant   },   ReferencedIdentifier(innerPath, state) {     state.iife = true;     innerPath.stop(); // if you want to save some state and then stop traversal, or deopt   } }); 

In short, use path.skip() to skip traversing the children of the current path. One application of this method is illustrated in this snippet using Visitors, CallExpression and skip():

export default function (babel) {   const { types: t } = babel;    return {     name: "ast-transform", // not required     visitor: {       CallExpression(path) {         path.replaceWith(t.blockStatement([           t.expressionStatement(t.yieldExpression(path.node))         ]));         path.skip();       }     }   }; }