babel-plugin-transform-adana
Version:
559 lines (479 loc) • 61.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.skip = skip;
exports.key = key;
exports.default = instrumenter;
var types = _interopRequireWildcard(require("@babel/types"));
var _micromatch = _interopRequireDefault(require("micromatch"));
var _path = require("path");
var _prelude = _interopRequireDefault(require("./prelude"));
var _meta = _interopRequireDefault(require("./meta"));
var _tags = require("./tags");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
function skip(_ref, file) {
var ignore = _ref.ignore,
only = _ref.only;
if (only) {
return (0, _micromatch.default)([file], Array.isArray(only) ? only : [only], {
nocase: true
}).length <= 0;
}
if (ignore) {
return (0, _micromatch.default)([file], Array.isArray(ignore) ? ignore : [ignore], {
nocase: true
}).length > 0;
}
return false;
}
/**
* Create an opaque, unique key for a given node. Useful for tagging the node
* in separate places.
* @param {Object} path Babel path to derive key from.
* @returns {String} String key.
*/
function key(path) {
var node = path.node;
if (node.loc) {
var location = node.loc.start;
return `${location.line}:${location.column}`;
}
throw new TypeError('Path must have valid location.');
}
/**
* Some nodes need to marked as non-instrumentable; since babel will apply
* our plugin to nodes we create, we have to be careful to not put ourselves
* into an infinite loop.
* @param {Object} node Babel AST node.
* @returns {Object} Babel AST node that won't be instrumented.
*/
function X(node) {
node.__adana = true;
return node;
}
function ignore(path) {
return !path.node || !path.node.loc || path.node.__adana;
}
function standardize(listener) {
return function (path, state) {
return ignore(path) ? undefined : listener(path, state);
};
}
/**
* Create the transform-adana babel plugin.
* @returns {Object} `babel` plugin object.
*/
function instrumenter() {
/**
* Create a chunk of code that marks the specified node as having
* been executed.
* @param {Object} state `babel` state for the path that's being walked.
* @param {Object} options Configure how the marker behaves.
* @returns {Object} AST node for marking coverage.
*/
function createMarker(state, options) {
var tags = options.tags,
loc = options.loc,
name = options.name,
group = options.group;
var coverage = (0, _meta.default)(state);
var id = coverage.entries.length;
coverage.entries.push({
id,
loc,
tags,
name,
group,
count: 0
}); // Maker is simply a statement incrementing a coverage variable.
return X(types.updateExpression('++', types.memberExpression(types.memberExpression(coverage.variable, types.numericLiteral(id), true), types.stringLiteral('count'), true), true));
}
/**
* [isInstrumentableStatement description]
* @param {[type]} path [description]
* @returns {Boolean} [description]
*/
function isInstrumentableStatement(path) {
var parent = path.parentPath;
return !parent.isReturnStatement() && !parent.isVariableDeclaration() && !parent.isExportDeclaration() && !parent.isFunctionDeclaration() && !parent.isIfStatement();
}
/**
* Inject a marker that measures whether the node for the given path has
* been run or not.
* @param {Object} path [description]
* @param {Object} state [description]
* @param {Object} options [description]
* @returns {void}
*/
function instrument(path, state, options) {
// This function is here because isInstrumentableStatement() is being
// called; we can't create the marker without knowing the result of that,
// otherwise dead markers will be created.
function marker() {
return createMarker(state, _extends({
loc: path.node.loc
}, options));
}
if (path.isBlockStatement()) {
path.unshiftContainer('body', X(types.expressionStatement(marker())));
} else if (path.isExpression()) {
path.replaceWith(X(types.sequenceExpression([marker(), path.node])));
} else if (path.isStatement()) {
if (isInstrumentableStatement(path)) {
path.insertBefore(X(types.expressionStatement(marker())));
}
}
}
/**
* [visitStatement description]
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitStatement(path, state) {
instrument(path, state, {
tags: ['statement', 'line'],
loc: path.node.loc
});
}
/**
* The function visitor is mainly to track the definitions of functions;
* being able ensure how many of your functions have actually been invoked.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitFunction(path, state) {
instrument(path.get('body'), state, {
tags: ['function'],
name: path.node.id ? path.node.id.name : `@${key(path)}`,
loc: path.node.loc
});
}
/**
* Multiple branches based on the result of `case _` and `default`. If you
* do not provide a `default` one will be intelligently added for you,
* forcing you to cover that case.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitSwitchStatement(path, state) {
var hasDefault = false;
path.get('cases').forEach(function (entry) {
if (entry.node.test) {
(0, _tags.addRules)(state, entry.node.loc, entry.node.test.trailingComments);
}
if (entry.node.consequent.length > 1) {
(0, _tags.addRules)(state, entry.node.loc, entry.node.consequent[0].leadingComments);
}
if (entry.node.test === null) {
hasDefault = true;
}
entry.unshiftContainer('consequent', createMarker(state, {
tags: ['branch', 'switch'],
loc: entry.node.loc,
group: key(path)
}));
}); // Default is technically a branch, just like if statements without
// else's are also technically a branch.
if (!hasDefault) {
// Add an extra break to the end of the last case in case some idiot
// forgot to add it.
var cases = path.get('cases');
if (cases.length > 0) {
cases[cases.length - 1].pushContainer('consequent', types.breakStatement());
} // Finally add the default case.
path.pushContainer('cases', types.switchCase(null, [types.expressionStatement(createMarker(state, {
tags: ['branch', 'switch'],
loc: {
start: path.node.loc.end,
end: path.node.loc.end
},
group: key(path)
})), types.breakStatement()]));
}
}
/**
* [visitVariableDeclaration description]
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitVariableDeclaration(path, state) {
path.get('declarations').forEach(function (decl) {
if (decl.has('init')) {
instrument(decl.get('init'), state, {
tags: ['statement', 'variable', 'line']
});
}
});
}
/**
* Includes both while and do-while loops. They contain a single branch which
* tests the loop condition.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitWhileLoop(path, state) {
var test = path.get('test');
var group = key(path); // This is a particularly clever use of the fact JS operators are short-
// circuiting. To instrument a loop one _cannot_ add a marker on the outside
// of the loop body due to weird cases of things where loops are in non-
// block if statements. So instead, create the following mechanism:
// ((condition && A) || !B) where A and B are markers. Since markers are
// postfix, they're always true. Ergo, A is only incremented when condition
// is true, B only when it's false and the truth value of the whole
// statement is preserved. Neato.
test.replaceWith(types.logicalExpression('||', types.logicalExpression('&&', X(test.node), createMarker(state, {
tags: ['branch', 'line', 'statement', 'loop', 'while'],
loc: test.node.loc,
group
})), types.unaryExpression('!', createMarker(state, {
tags: ['branch', 'line', 'loop', 'while'],
loc: test.node.loc,
group
}))));
}
/**
* The try block can either fully succeed (no error) or it can throw. Both
* cases are accounted for.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitTryStatement(path, state) {
var group = key(path);
var body = path.get('block');
var trigger = path.scope.generateDeclaredUidIdentifier('_exception');
(0, _tags.addRules)(state, body.node.loc, body.node.leadingComments);
path.get('block').unshiftContainer('body', types.expressionStatement(types.assignmentExpression('=', trigger, types.booleanLiteral(true))));
var handlerExpression = types.expressionStatement(types.assignmentExpression('=', trigger, types.booleanLiteral(false)));
var handlerLoc;
if (path.has('handler')) {
var handler = path.get('handler').node;
handlerLoc = handler.loc;
(0, _tags.addRules)(state, handler.loc, handler.body.leadingComments);
path.get('handler.body').unshiftContainer('body', handlerExpression);
} else {
var loc = path.get('block').node.loc.end;
handlerLoc = {
start: loc,
end: loc
};
path.get('handler').replaceWith(types.catchClause(types.identifier('err'), types.blockStatement([handlerExpression, types.throwStatement(types.identifier('err'))])));
}
var guard = types.ifStatement(trigger, types.expressionStatement(createMarker(state, {
tags: ['branch', 'line', 'exception'],
loc: path.get('block').node.loc,
group
})), types.expressionStatement(createMarker(state, {
tags: ['branch', 'line', 'exception'],
loc: handlerLoc,
group
})));
if (path.has('finalizer')) {
path.get('finalizer').unshiftContainer('body', guard);
} else {
path.get('finalizer').replaceWith(types.blockStatement([guard]));
}
}
/**
* Return statements are instrumented by marking the next block they return.
* This helps ensure multi-line expressions for return statements are
* accurately captured.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {[type]} [description]
*/
function visitReturnStatement(path, state) {
if (!path.has('argument')) {
path.get('argument').replaceWith(types.sequenceExpression([createMarker(state, {
loc: path.node.loc,
tags: ['line', 'statement']
}), types.identifier('undefined')]));
} else {
instrument(path.get('argument'), state, {
tags: ['line', 'statement']
});
}
}
/**
* For multi-line reporting (and objects do tend to span multiple lines) this
* is required to know which parts of the object where actually executed.
* Ignore shorthand property that look like `{ this }`.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {[type]} [description]
*/
function visitObjectProperty(path, state) {
if (!path.node.shorthand && !path.parentPath.isPattern()) {
var _key = path.get('key');
var value = path.get('value');
if (path.node.computed) {
instrument(_key, state, {
tags: ['line']
});
}
instrument(value, state, {
tags: ['line']
});
}
}
/**
* For multi-line reporting (and arrays do tend to span multiple lines) this
* is required to know which parts of the array where actually executed.
* This does _not_ include destructed arrays.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {[type]} [description]
*/
function visitArrayExpression(path, state) {
if (!path.parentPath.isPattern()) {
path.get('elements').forEach(function (element) {
instrument(element, state, {
tags: ['line']
});
});
}
}
/**
* Logical expressions are those using logic operators like `&&` and `||`.
* Since logic expressions short-circuit in JS they are effectively branches
* and will be treated as such here.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitLogicalExpression(path, state) {
var group = key(path);
var left = path.get('left').node;
var right = path.get('right').node;
path.replaceWith(X(types.logicalExpression(path.node.operator, types.sequenceExpression([createMarker(state, {
tags: ['branch', 'logic'],
loc: left.loc,
group
}), left]), types.sequenceExpression([createMarker(state, {
tags: ['branch', 'logic'],
loc: right.loc,
group
}), right]))));
}
/**
* Conditionals are either if/else statements or tenaiary expressions. They
* have a test case and two choices (based on the test result). Both cases
* are always accounted for, even if the code does not exist for the alternate
* case.
* @param {[type]} path [description]
* @param {[type]} state [description]
* @returns {void}
*/
function visitConditional(path, state) {
// Branches can be grouped together so that each of the possible branch
// destinations is accounted for under one group. For if statements, this
// refers to all the blocks that fall under a single if.. else if.. else..
// grouping.
var root = path.findParent(function (search) {
return search.node.type === path.node.type && !ignore(search) && (!search.parentPath || search.parentPath.node.type !== path.node.type);
}) || path; // Create the group name based on the root `if` statement.
var group = key(root);
function tagBranch(path) {
(0, _tags.addRules)(state, path.node.loc, path.node.leadingComments);
if (path.isBlockStatement() && path.node.body.length > 0) {
(0, _tags.addRules)(state, path.node.loc, path.node.body[0].leadingComments);
}
}
tagBranch(path.get('consequent'));
if (path.has('alternate')) {
tagBranch(path.get('alternate'));
}
instrument(path.get('consequent'), state, {
tags: ['branch', 'line', 'if'],
loc: path.node.consequent.loc,
group
});
if (path.has('alternate') && !path.get('alternate').isIfStatement()) {
instrument(path.get('alternate'), state, {
tags: ['branch', 'line', 'if'],
loc: path.node.alternate.loc,
group
});
} else if (!path.has('alternate')) {
path.get('alternate').replaceWith(types.expressionStatement(createMarker(state, {
tags: ['branch', 'if'],
loc: {
start: path.node.loc.end,
end: path.node.loc.end
},
group
})));
}
}
function noInstrument(path) {
if (path.node && path.node.leadingComments && path.node.leadingComments.some(function (comment) {
return /^\s*adana-no-instrument\s*$/.exec(comment.value);
})) {
path.skip();
return;
}
}
var visitor = {
// Expressions
ArrowFunctionExpression: visitFunction,
FunctionExpression: visitFunction,
ObjectMethod: visitFunction,
ClassMethod: visitFunction,
LogicalExpression: visitLogicalExpression,
ConditionalExpression: visitConditional,
ObjectProperty: visitObjectProperty,
ArrayExpression: visitArrayExpression,
// Declarations
FunctionDeclaration: visitFunction,
VariableDeclaration: visitVariableDeclaration,
// Statements
ContinueStatement: visitStatement,
BreakStatement: visitStatement,
ExpressionStatement: visitStatement,
ThrowStatement: visitStatement,
ReturnStatement: visitReturnStatement,
TryStatement: visitTryStatement,
WhileStatement: visitWhileLoop,
DoWhileStatement: visitWhileLoop,
IfStatement: visitConditional,
SwitchStatement: visitSwitchStatement,
// Generics
enter: noInstrument
};
Object.keys(visitor).forEach(function (key) {
visitor[key] = standardize(visitor[key]);
}); // Create the actual babel plugin object.
return {
visitor: {
Program(path, state) {
var opts = state.opts,
filename = state.filename,
cwd = state.file.opts.cwd; // Check if file should be instrumented or not.
var name = filename ? (0, _path.relative)(cwd, filename) : '<source>';
if (filename && skip(opts, name)) {
return;
}
(0, _meta.default)(state, {
source: state.file.code,
entries: [],
rules: [],
tags: {},
variable: path.scope.generateUidIdentifier('coverage'),
name
});
path.traverse(visitor, state);
(0, _tags.applyRules)(state);
path.unshiftContainer('body', (0, _prelude.default)(state));
}
}
};
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/instrumenter.js"],"names":["skip","file","ignore","only","Array","isArray","nocase","length","key","path","node","loc","location","start","line","column","TypeError","X","__adana","standardize","listener","state","undefined","instrumenter","createMarker","options","tags","name","group","coverage","id","entries","push","count","types","updateExpression","memberExpression","variable","numericLiteral","stringLiteral","isInstrumentableStatement","parent","parentPath","isReturnStatement","isVariableDeclaration","isExportDeclaration","isFunctionDeclaration","isIfStatement","instrument","marker","isBlockStatement","unshiftContainer","expressionStatement","isExpression","replaceWith","sequenceExpression","isStatement","insertBefore","visitStatement","visitFunction","get","visitSwitchStatement","hasDefault","forEach","entry","test","trailingComments","consequent","leadingComments","cases","pushContainer","breakStatement","switchCase","end","visitVariableDeclaration","decl","has","visitWhileLoop","logicalExpression","unaryExpression","visitTryStatement","body","trigger","scope","generateDeclaredUidIdentifier","assignmentExpression","booleanLiteral","handlerExpression","handlerLoc","handler","catchClause","identifier","blockStatement","throwStatement","guard","ifStatement","visitReturnStatement","visitObjectProperty","shorthand","isPattern","value","computed","visitArrayExpression","element","visitLogicalExpression","left","right","operator","visitConditional","root","findParent","search","type","tagBranch","alternate","noInstrument","some","comment","exec","visitor","ArrowFunctionExpression","FunctionExpression","ObjectMethod","ClassMethod","LogicalExpression","ConditionalExpression","ObjectProperty","ArrayExpression","FunctionDeclaration","VariableDeclaration","ContinueStatement","BreakStatement","ExpressionStatement","ThrowStatement","ReturnStatement","TryStatement","WhileStatement","DoWhileStatement","IfStatement","SwitchStatement","enter","Object","keys","Program","opts","filename","cwd","source","code","rules","generateUidIdentifier","traverse"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AAEA;;AACA;;AACA;;;;;;;;AAEO,SAASA,IAAT,OAA8BC,IAA9B,EAAoC;AAAA,MAArBC,MAAqB,QAArBA,MAAqB;AAAA,MAAbC,IAAa,QAAbA,IAAa;;AACzC,MAAIA,IAAJ,EAAU;AACR,WAAO,yBACL,CAACF,IAAD,CADK,EAELG,MAAMC,OAAN,CAAcF,IAAd,IAAsBA,IAAtB,GAA6B,CAACA,IAAD,CAFxB,EAGL;AAACG,cAAQ;AAAT,KAHK,EAILC,MAJK,IAIK,CAJZ;AAKD;;AACD,MAAIL,MAAJ,EAAY;AACV,WAAO,yBACL,CAACD,IAAD,CADK,EAELG,MAAMC,OAAN,CAAcH,MAAd,IAAwBA,MAAxB,GAAiC,CAACA,MAAD,CAF5B,EAGL;AAACI,cAAQ;AAAT,KAHK,EAILC,MAJK,GAII,CAJX;AAKD;;AACD,SAAO,KAAP;AACD;AAED;;;;;;;;AAMO,SAASC,GAAT,CAAaC,IAAb,EAAmB;AACxB,MAAMC,OAAOD,KAAKC,IAAlB;;AACA,MAAIA,KAAKC,GAAT,EAAc;AACZ,QAAMC,WAAWF,KAAKC,GAAL,CAASE,KAA1B;AACA,WAAQ,GAAED,SAASE,IAAK,IAAGF,SAASG,MAAO,EAA3C;AACD;;AACD,QAAM,IAAIC,SAAJ,CAAc,gCAAd,CAAN;AACD;AAED;;;;;;;;;AAOA,SAASC,CAAT,CAAWP,IAAX,EAAiB;AACfA,OAAKQ,OAAL,GAAe,IAAf;AACA,SAAOR,IAAP;AACD;;AAED,SAASR,MAAT,CAAgBO,IAAhB,EAAsB;AACpB,SAAQ,CAACA,KAAKC,IAAN,IAAc,CAACD,KAAKC,IAAL,CAAUC,GAAzB,IAAgCF,KAAKC,IAAL,CAAUQ,OAAlD;AACD;;AAED,SAASC,WAAT,CAAqBC,QAArB,EAA+B;AAC7B,SAAO,UAACX,IAAD,EAAOY,KAAP;AAAA,WAAiBnB,OAAOO,IAAP,IAAea,SAAf,GAA2BF,SAASX,IAAT,EAAeY,KAAf,CAA5C;AAAA,GAAP;AACD;AAED;;;;;;AAIe,SAASE,YAAT,GAAwB;AACrC;;;;;;;AAOA,WAASC,YAAT,CAAsBH,KAAtB,EAA6BI,OAA7B,EAAsC;AAAA,QAC7BC,IAD6B,GACHD,OADG,CAC7BC,IAD6B;AAAA,QACvBf,GADuB,GACHc,OADG,CACvBd,GADuB;AAAA,QAClBgB,IADkB,GACHF,OADG,CAClBE,IADkB;AAAA,QACZC,KADY,GACHH,OADG,CACZG,KADY;AAEpC,QAAMC,WAAW,mBAAKR,KAAL,CAAjB;AACA,QAAMS,KAAKD,SAASE,OAAT,CAAiBxB,MAA5B;AAEAsB,aAASE,OAAT,CAAiBC,IAAjB,CAAsB;AACpBF,QADoB;AAEpBnB,SAFoB;AAGpBe,UAHoB;AAIpBC,UAJoB;AAKpBC,WALoB;AAMpBK,aAAO;AANa,KAAtB,EALoC,CAcpC;;AACA,WAAOhB,EAAEiB,MAAMC,gBAAN,CAAuB,IAAvB,EAA6BD,MAAME,gBAAN,CACpCF,MAAME,gBAAN,CACEP,SAASQ,QADX,EAEEH,MAAMI,cAAN,CAAqBR,EAArB,CAFF,EAGE,IAHF,CADoC,EAMpCI,MAAMK,aAAN,CAAoB,OAApB,CANoC,EAOpC,IAPoC,CAA7B,EAQN,IARM,CAAF,CAAP;AASD;AAED;;;;;;;AAKA,WAASC,yBAAT,CAAmC/B,IAAnC,EAAyC;AACvC,QAAMgC,SAAShC,KAAKiC,UAApB;AACA,WAAO,CAACD,OAAOE,iBAAP,EAAD,IACL,CAACF,OAAOG,qBAAP,EADI,IAEL,CAACH,OAAOI,mBAAP,EAFI,IAGL,CAACJ,OAAOK,qBAAP,EAHI,IAIL,CAACL,OAAOM,aAAP,EAJH;AAKD;AAED;;;;;;;;;;AAQA,WAASC,UAAT,CAAoBvC,IAApB,EAA0BY,KAA1B,EAAiCI,OAAjC,EAA0C;AACxC;AACA;AACA;AACA,aAASwB,MAAT,GAAkB;AAChB,aAAOzB,aAAaH,KAAb;AACLV,aAAKF,KAAKC,IAAL,CAAUC;AADV,SAEFc,OAFE,EAAP;AAID;;AAED,QAAIhB,KAAKyC,gBAAL,EAAJ,EAA6B;AAC3BzC,WAAK0C,gBAAL,CAAsB,MAAtB,EAA8BlC,EAAEiB,MAAMkB,mBAAN,CAA0BH,QAA1B,CAAF,CAA9B;AACD,KAFD,MAEO,IAAIxC,KAAK4C,YAAL,EAAJ,EAAyB;AAC9B5C,WAAK6C,WAAL,CAAiBrC,EAAEiB,MAAMqB,kBAAN,CAAyB,CAACN,QAAD,EAAWxC,KAAKC,IAAhB,CAAzB,CAAF,CAAjB;AACD,KAFM,MAEA,IAAID,KAAK+C,WAAL,EAAJ,EAAwB;AAC7B,UAAIhB,0BAA0B/B,IAA1B,CAAJ,EAAqC;AACnCA,aAAKgD,YAAL,CAAkBxC,EAAEiB,MAAMkB,mBAAN,CAA0BH,QAA1B,CAAF,CAAlB;AACD;AACF;AACF;AAED;;;;;;;;AAMA,WAASS,cAAT,CAAwBjD,IAAxB,EAA8BY,KAA9B,EAAqC;AACnC2B,eAAWvC,IAAX,EAAiBY,KAAjB,EAAwB;AACtBK,YAAM,CAAC,WAAD,EAAc,MAAd,CADgB;AAEtBf,WAAKF,KAAKC,IAAL,CAAUC;AAFO,KAAxB;AAID;AAED;;;;;;;;;AAOA,WAASgD,aAAT,CAAuBlD,IAAvB,EAA6BY,KAA7B,EAAoC;AAClC2B,eAAWvC,KAAKmD,GAAL,CAAS,MAAT,CAAX,EAA6BvC,KAA7B,EAAoC;AAClCK,YAAM,CAAC,UAAD,CAD4B;AAElCC,YAAMlB,KAAKC,IAAL,CAAUoB,EAAV,GAAerB,KAAKC,IAAL,CAAUoB,EAAV,CAAaH,IAA5B,GAAoC,IAAGnB,IAAIC,IAAJ,CAAU,EAFrB;AAGlCE,WAAKF,KAAKC,IAAL,CAAUC;AAHmB,KAApC;AAKD;AAED;;;;;;;;;;AAQA,WAASkD,oBAAT,CAA8BpD,IAA9B,EAAoCY,KAApC,EAA2C;AACzC,QAAIyC,aAAa,KAAjB;AACArD,SAAKmD,GAAL,CAAS,OAAT,EAAkBG,OAAlB,CAA0B,UAACC,KAAD,EAAW;AACnC,UAAIA,MAAMtD,IAAN,CAAWuD,IAAf,EAAqB;AACnB,4BAAS5C,KAAT,EAAgB2C,MAAMtD,IAAN,CAAWC,GAA3B,EAAgCqD,MAAMtD,IAAN,CAAWuD,IAAX,CAAgBC,gBAAhD;AACD;;AACD,UAAIF,MAAMtD,IAAN,CAAWyD,UAAX,CAAsB5D,MAAtB,GAA+B,CAAnC,EAAsC;AACpC,4BACEc,KADF,EAEE2C,MAAMtD,IAAN,CAAWC,GAFb,EAGEqD,MAAMtD,IAAN,CAAWyD,UAAX,CAAsB,CAAtB,EAAyBC,eAH3B;AAKD;;AAED,UAAIJ,MAAMtD,IAAN,CAAWuD,IAAX,KAAoB,IAAxB,EAA8B;AAC5BH,qBAAa,IAAb;AACD;;AACDE,YAAMb,gBAAN,CAAuB,YAAvB,EAAqC3B,aAAaH,KAAb,EAAoB;AACvDK,cAAM,CAAC,QAAD,EAAW,QAAX,CADiD;AAEvDf,aAAKqD,MAAMtD,IAAN,CAAWC,GAFuC;AAGvDiB,eAAOpB,IAAIC,IAAJ;AAHgD,OAApB,CAArC;AAKD,KApBD,EAFyC,CAwBzC;AACA;;AACA,QAAI,CAACqD,UAAL,EAAiB;AACf;AACA;AACA,UAAMO,QAAQ5D,KAAKmD,GAAL,CAAS,OAAT,CAAd;;AACA,UAAIS,MAAM9D,MAAN,GAAe,CAAnB,EAAsB;AACpB8D,cAAMA,MAAM9D,MAAN,GAAe,CAArB,EAAwB+D,aAAxB,CACE,YADF,EAEEpC,MAAMqC,cAAN,EAFF;AAID,OATc,CAUf;;;AACA9D,WAAK6D,aAAL,CAAmB,OAAnB,EAA4BpC,MAAMsC,UAAN,CAAiB,IAAjB,EAAuB,CACjDtC,MAAMkB,mBAAN,CAA0B5B,aAAaH,KAAb,EAAoB;AAC5CK,cAAM,CAAC,QAAD,EAAW,QAAX,CADsC;AAE5Cf,aAAK;AACHE,iBAAOJ,KAAKC,IAAL,CAAUC,GAAV,CAAc8D,GADlB;AAEHA,eAAKhE,KAAKC,IAAL,CAAUC,GAAV,CAAc8D;AAFhB,SAFuC;AAM5C7C,eAAOpB,IAAIC,IAAJ;AANqC,OAApB,CAA1B,CADiD,EASjDyB,MAAMqC,cAAN,EATiD,CAAvB,CAA5B;AAWD;AACF;AAED;;;;;;;;AAMA,WAASG,wBAAT,CAAkCjE,IAAlC,EAAwCY,KAAxC,EAA+C;AAC7CZ,SAAKmD,GAAL,CAAS,cAAT,EAAyBG,OAAzB,CAAiC,UAACY,IAAD,EAAU;AACzC,UAAIA,KAAKC,GAAL,CAAS,MAAT,CAAJ,EAAsB;AACpB5B,mBAAW2B,KAAKf,GAAL,CAAS,MAAT,CAAX,EAA6BvC,KAA7B,EAAoC;AAClCK,gBAAM,CAAC,WAAD,EAAc,UAAd,EAA0B,MAA1B;AAD4B,SAApC;AAGD;AACF,KAND;AAOD;AAED;;;;;;;;;AAOA,WAASmD,cAAT,CAAwBpE,IAAxB,EAA8BY,KAA9B,EAAqC;AACnC,QAAM4C,OAAOxD,KAAKmD,GAAL,CAAS,MAAT,CAAb;AACA,QAAMhC,QAAQpB,IAAIC,IAAJ,CAAd,CAFmC,CAGnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACAwD,SAAKX,WAAL,CAAiBpB,MAAM4C,iBAAN,CACf,IADe,EAEf5C,MAAM4C,iBAAN,CACE,IADF,EAEE7D,EAAEgD,KAAKvD,IAAP,CAFF,EAGEc,aAAaH,KAAb,EAAoB;AAClBK,YAAM,CAAC,QAAD,EAAW,MAAX,EAAmB,WAAnB,EAAgC,MAAhC,EAAwC,OAAxC,CADY;AAElBf,WAAKsD,KAAKvD,IAAL,CAAUC,GAFG;AAGlBiB;AAHkB,KAApB,CAHF,CAFe,EAWfM,MAAM6C,eAAN,CACE,GADF,EAEEvD,aAAaH,KAAb,EAAoB;AAClBK,YAAM,CAAC,QAAD,EAAW,MAAX,EAAmB,MAAnB,EAA2B,OAA3B,CADY;AAElBf,WAAKsD,KAAKvD,IAAL,CAAUC,GAFG;AAGlBiB;AAHkB,KAApB,CAFF,CAXe,CAAjB;AAoBD;AAED;;;;;;;;;AAOA,WAASoD,iBAAT,CAA2BvE,IAA3B,EAAiCY,KAAjC,EAAwC;AACtC,QAAMO,QAAQpB,IAAIC,IAAJ,CAAd;AACA,QAAMwE,OAAOxE,KAAKmD,GAAL,CAAS,OAAT,CAAb;AACA,QAAMsB,UAAUzE,KAAK0E,KAAL,CAAWC,6BAAX,CAAyC,YAAzC,CAAhB;AACA,wBAAS/D,KAAT,EAAgB4D,KAAKvE,IAAL,CAAUC,GAA1B,EAA+BsE,KAAKvE,IAAL,CAAU0D,eAAzC;AACA3D,SAAKmD,GAAL,CAAS,OAAT,EAAkBT,gBAAlB,CAAmC,MAAnC,EAA2CjB,MAAMkB,mBAAN,CACzClB,MAAMmD,oBAAN,CAA2B,GAA3B,EAAgCH,OAAhC,EAAyChD,MAAMoD,cAAN,CAAqB,IAArB,CAAzC,CADyC,CAA3C;AAGA,QAAMC,oBAAoBrD,MAAMkB,mBAAN,CACxBlB,MAAMmD,oBAAN,CAA2B,GAA3B,EAAgCH,OAAhC,EAAyChD,MAAMoD,cAAN,CAAqB,KAArB,CAAzC,CADwB,CAA1B;AAGA,QAAIE,UAAJ;;AACA,QAAI/E,KAAKmE,GAAL,CAAS,SAAT,CAAJ,EAAyB;AACvB,UAAMa,UAAUhF,KAAKmD,GAAL,CAAS,SAAT,EAAoBlD,IAApC;AACA8E,mBAAaC,QAAQ9E,GAArB;AACA,0BAASU,KAAT,EAAgBoE,QAAQ9E,GAAxB,EAA6B8E,QAAQR,IAAR,CAAab,eAA1C;AACA3D,WAAKmD,GAAL,CAAS,cAAT,EAAyBT,gBAAzB,CACE,MADF,EAEEoC,iBAFF;AAID,KARD,MAQO;AACL,UAAM5E,MAAMF,KAAKmD,GAAL,CAAS,OAAT,EAAkBlD,IAAlB,CAAuBC,GAAvB,CAA2B8D,GAAvC;AACAe,mBAAa;AAAC3E,eAAOF,GAAR;AAAa8D,aAAK9D;AAAlB,OAAb;AACAF,WAAKmD,GAAL,CAAS,SAAT,EAAoBN,WAApB,CAAgCpB,MAAMwD,WAAN,CAC9BxD,MAAMyD,UAAN,CAAiB,KAAjB,CAD8B,EACLzD,MAAM0D,cAAN,CAAqB,CAC5CL,iBAD4C,EAE5CrD,MAAM2D,cAAN,CACE3D,MAAMyD,UAAN,CAAiB,KAAjB,CADF,CAF4C,CAArB,CADK,CAAhC;AAQD;;AAED,QAAMG,QAAQ5D,MAAM6D,WAAN,CACZb,OADY,EAEZhD,MAAMkB,mBAAN,CACE5B,aAAaH,KAAb,EAAoB;AAClBK,YAAM,CAAC,QAAD,EAAW,MAAX,EAAmB,WAAnB,CADY;AAElBf,WAAKF,KAAKmD,GAAL,CAAS,OAAT,EAAkBlD,IAAlB,CAAuBC,GAFV;AAGlBiB;AAHkB,KAApB,CADF,CAFY,EASZM,MAAMkB,mBAAN,CACE5B,aAAaH,KAAb,EAAoB;AAClBK,YAAM,CAAC,QAAD,EAAW,MAAX,EAAmB,WAAnB,CADY;AAElBf,WAAK6E,UAFa;AAGlB5D;AAHkB,KAApB,CADF,CATY,CAAd;;AAkBA,QAAInB,KAAKmE,GAAL,CAAS,WAAT,CAAJ,EAA2B;AACzBnE,WAAKmD,GAAL,CAAS,WAAT,EAAsBT,gBAAtB,CAAuC,MAAvC,EAA+C2C,KAA/C;AACD,KAFD,MAEO;AACLrF,WAAKmD,GAAL,CAAS,WAAT,EAAsBN,WAAtB,CAAkCpB,MAAM0D,cAAN,CAAqB,CAACE,KAAD,CAArB,CAAlC;AACD;AACF;AAED;;;;;;;;;;AAQA,WAASE,oBAAT,CAA8BvF,IAA9B,EAAoCY,KAApC,EAA2C;AACzC,QAAI,CAACZ,KAAKmE,GAAL,CAAS,UAAT,CAAL,EAA2B;AACzBnE,WAAKmD,GAAL,CAAS,UAAT,EAAqBN,WAArB,CAAiCpB,MAAMqB,kBAAN,CAAyB,CACxD/B,aAAaH,KAAb,EAAoB;AAClBV,aAAKF,KAAKC,IAAL,CAAUC,GADG;AAElBe,cAAM,CAAC,MAAD,EAAS,WAAT;AAFY,OAApB,CADwD,EAKxDQ,MAAMyD,UAAN,CAAiB,WAAjB,CALwD,CAAzB,CAAjC;AAOD,KARD,MAQO;AACL3C,iBAAWvC,KAAKmD,GAAL,CAAS,UAAT,CAAX,EAAiCvC,KAAjC,EAAwC;AACtCK,cAAM,CAAC,MAAD,EAAS,WAAT;AADgC,OAAxC;AAGD;AACF;AAED;;;;;;;;;;AAQA,WAASuE,mBAAT,CAA6BxF,IAA7B,EAAmCY,KAAnC,EAA0C;AACxC,QAAI,CAACZ,KAAKC,IAAL,CAAUwF,SAAX,IAAwB,CAACzF,KAAKiC,UAAL,CAAgByD,SAAhB,EAA7B,EAA0D;AACxD,UAAM3F,OAAMC,KAAKmD,GAAL,CAAS,KAAT,CAAZ;;AACA,UAAMwC,QAAQ3F,KAAKmD,GAAL,CAAS,OAAT,CAAd;;AACA,UAAInD,KAAKC,IAAL,CAAU2F,QAAd,EAAwB;AACtBrD,mBAAWxC,IAAX,EAAgBa,KAAhB,EAAuB;AACrBK,gBAAM,CAAC,MAAD;AADe,SAAvB;AAGD;;AACDsB,iBAAWoD,KAAX,EAAkB/E,KAAlB,EAAyB;AACvBK,cAAM,CAAC,MAAD;AADiB,OAAzB;AAGD;AACF;AAED;;;;;;;;;;AAQA,WAAS4E,oBAAT,CAA8B7F,IAA9B,EAAoCY,KAApC,EAA2C;AACzC,QAAI,CAACZ,KAAKiC,UAAL,CAAgByD,SAAhB,EAAL,EAAkC;AAChC1F,WAAKmD,GAAL,CAAS,UAAT,EAAqBG,OAArB,CAA6B,UAACwC,OAAD,EAAa;AACxCvD,mBAAWuD,OAAX,EAAoBlF,KAApB,EAA2B;AACzBK,gBAAM,CAAC,MAAD;AADmB,SAA3B;AAGD,OAJD;AAKD;AACF;AAED;;;;;;;;;;AAQA,WAAS8E,sBAAT,CAAgC/F,IAAhC,EAAsCY,KAAtC,EAA6C;AAC3C,QAAMO,QAAQpB,IAAIC,IAAJ,CAAd;AACA,QAAMgG,OAAOhG,KAAKmD,GAAL,CAAS,MAAT,EAAiBlD,IAA9B;AACA,QAAMgG,QAAQjG,KAAKmD,GAAL,CAAS,OAAT,EAAkBlD,IAAhC;AACAD,SAAK6C,WAAL,CAAiBrC,EAAEiB,MAAM4C,iBAAN,CACjBrE,KAAKC,IAAL,CAAUiG,QADO,EAEjBzE,MAAMqB,kBAAN,CAAyB,CAAC/B,aAAaH,KAAb,EAAoB;AAC5CK,YAAM,CAAC,QAAD,EAAW,OAAX,CADsC;AAE5Cf,WAAK8F,KAAK9F,GAFkC;AAG5CiB;AAH4C,KAApB,CAAD,EAIrB6E,IAJqB,CAAzB,CAFiB,EAOjBvE,MAAMqB,kBAAN,CAAyB,CAAC/B,aAAaH,KAAb,EAAoB;AAC5CK,YAAM,CAAC,QAAD,EAAW,OAAX,CADsC;AAE5Cf,WAAK+F,MAAM/F,GAFiC;AAG5CiB;AAH4C,KAApB,CAAD,EAIrB8E,KAJqB,CAAzB,CAPiB,CAAF,CAAjB;AAaD;AAED;;;;;;;;;;;AASA,WAASE,gBAAT,CAA0BnG,IAA1B,EAAgCY,KAAhC,EAAuC;AACrC;AACA;AACA;AACA;AACA,QAAMwF,OAAOpG,KAAKqG,UAAL,CAAgB,UAACC,MAAD,EAAY;AACvC,aAAOA,OAAOrG,IAAP,CAAYsG,IAAZ,KAAqBvG,KAAKC,IAAL,CAAUsG,IAA/B,IACL,CAAC9G,OAAO6G,MAAP,CADI,KAEJ,CAACA,OAAOrE,UAAR,IAAsBqE,OAAOrE,UAAP,CAAkBhC,IAAlB,CAAuBsG,IAAvB,KAAgCvG,KAAKC,IAAL,CAAUsG,IAF5D,CAAP;AAGD,KAJY,KAIPvG,IAJN,CALqC,CAWrC;;AACA,QAAMmB,QAAQpB,IAAIqG,IAAJ,CAAd;;AAEA,aAASI,SAAT,CAAmBxG,IAAnB,EAAyB;AACvB,0BAASY,KAAT,EAAgBZ,KAAKC,IAAL,CAAUC,GAA1B,EAA+BF,KAAKC,IAAL,CAAU0D,eAAzC;;AACA,UAAI3D,KAAKyC,gBAAL,MAA2BzC,KAAKC,IAAL,CAAUuE,IAAV,CAAe1E,MAAf,GAAwB,CAAvD,EAA0D;AACxD,4BAASc,KAAT,EAAgBZ,KAAKC,IAAL,CAAUC,GAA1B,EAA+BF,KAAKC,IAAL,CAAUuE,IAAV,CAAe,CAAf,EAAkBb,eAAjD;AACD;AACF;;AAED6C,cAAUxG,KAAKmD,GAAL,CAAS,YAAT,CAAV;;AACA,QAAInD,KAAKmE,GAAL,CAAS,WAAT,CAAJ,EAA2B;AACzBqC,gBAAUxG,KAAKmD,GAAL,CAAS,WAAT,CAAV;AACD;;AAEDZ,eAAWvC,KAAKmD,GAAL,CAAS,YAAT,CAAX,EAAmCvC,KAAnC,EAA0C;AACxCK,YAAM,CAAC,QAAD,EAAW,MAAX,EAAmB,IAAnB,CADkC;AAExCf,WAAKF,KAAKC,IAAL,CAAUyD,UAAV,CAAqBxD,GAFc;AAGxCiB;AAHwC,KAA1C;;AAMA,QAAInB,KAAKmE,GAAL,CAAS,WAAT,KAAyB,CAACnE,KAAKmD,GAAL,CAAS,WAAT,EAAsBb,aAAtB,EAA9B,EAAqE;AACnEC,iBAAWvC,KAAKmD,GAAL,CAAS,WAAT,CAAX,EAAkCvC,KAAlC,EAAyC;AACvCK,cAAM,CAAC,QAAD,EAAW,MAAX,EAAmB,IAAnB,CADiC;AAEvCf,aAAKF,KAAKC,IAAL,CAAUwG,SAAV,CAAoBvG,GAFc;AAGvCiB;AAHuC,OAAzC;AAKD,KAND,MAMO,IAAI,CAACnB,KAAKmE,GAAL,CAAS,WAAT,CAAL,EAA4B;AACjCnE,WAAKmD,GAAL,CAAS,WAAT,EAAsBN,WAAtB,CAAkCpB,MAAMkB,mBAAN,CAChC5B,aAAaH,KAAb,EAAoB;AAClBK,cAAM,CAAC,QAAD,EAAW,IAAX,CADY;AAElBf,aAAK;AACHE,iBAAOJ,KAAKC,IAAL,CAAUC,GAAV,CAAc8D,GADlB;AAEHA,eAAKhE,KAAKC,IAAL,CAAUC,GAAV,CAAc8D;AAFhB,SAFa;AAMlB7C;AANkB,OAApB,CADgC,CAAlC;AAUD;AACF;;AAED,WAASuF,YAAT,CAAsB1G,IAAtB,EAA4B;AAC1B,QACEA,KAAKC,IAAL,IACAD,KAAKC,IAAL,CAAU0D,eADV,IAEA3D,KAAKC,IAAL,CAAU0D,eAAV,CAA0BgD,IAA1B,CACE,UAACC,OAAD;AAAA,aAAa,8BAA8BC,IAA9B,CAAmCD,QAAQjB,KAA3C,CAAb;AAAA,KADF,CAHF,EAME;AACA3F,WAAKT,IAAL;AACA;AACD;AACF;;AAED,MAAMuH,UAAU;AACd;AACAC,6BAAyB7D,aAFX;AAGd8D,wBAAoB9D,aAHN;AAId+D,kBAAc/D,aAJA;AAKdgE,iBAAahE,aALC;AAMdiE,uBAAmBpB,sBANL;AAOdqB,2BAAuBjB,gBAPT;AAQdkB,oBAAgB7B,mBARF;AASd8B,qBAAiBzB,oBATH;AAWd;AACA0B,yBAAqBrE,aAZP;AAadsE,yBAAqBvD,wBAbP;AAed;AACAwD,uBAAmBxE,cAhBL;AAiBdyE,oBAAgBzE,cAjBF;AAkBd0E,yBAAqB1E,cAlBP;AAmBd2E,oBAAgB3E,cAnBF;AAoBd4E,qBAAiBtC,oBApBH;AAqBduC,kBAAcvD,iBArBA;AAsBdwD,oBAAgB3D,cAtBF;AAuBd4D,sBAAkB5D,cAvBJ;AAwBd6D,iBAAa9B,gBAxBC;AAyBd+B,qBAAiB9E,oBAzBH;AA2Bd;AACA+E,WAAOzB;AA5BO,GAAhB;AA+BA0B,SAAOC,IAAP,CAAYvB,OAAZ,EAAqBxD,OAArB,CAA6B,UAACvD,GAAD,EAAS;AACpC+G,YAAQ/G,GAAR,IAAeW,YAAYoG,QAAQ/G,GAAR,CAAZ,CAAf;AACD,GAFD,EAneqC,CAuerC;;AACA,SAAO;AACL+G,aAAS;AACPwB,cAAQtI,IAAR,EAAcY,KAAd,EAAqB;AAAA,YACZ2H,IADY,GAC2B3H,KAD3B,CACZ2H,IADY;AAAA,YACNC,QADM,GAC2B5H,KAD3B,CACN4H,QADM;AAAA,YACkBC,GADlB,GAC2B7H,KAD3B,CACIpB,IADJ,CACW+I,IADX,CACkBE,GADlB,EAEnB;;AACA,YAAMvH,OAAOsH,WAAW,oBAASC,GAAT,EAAcD,QAAd,CAAX,GAAqC,UAAlD;;AACA,YAAIA,YAAYjJ,KAAKgJ,IAAL,EAAWrH,IAAX,CAAhB,EAAkC;AAChC;AACD;;AACD,2BAAKN,KAAL,EAAY;AACV8H,kBAAQ9H,MAAMpB,IAAN,CAAWmJ,IADT;AAEVrH,mBAAS,EAFC;AAGVsH,iBAAO,EAHG;AAIV3H,gBAAM,EAJI;AAKVW,oBAAU5B,KAAK0E,KAAL,CAAWmE,qBAAX,CAAiC,UAAjC,CALA;AAMV3H;AANU,SAAZ;AAQAlB,aAAK8I,QAAL,CAAchC,OAAd,EAAuBlG,KAAvB;AACA,8BAAWA,KAAX;AACAZ,aAAK0C,gBAAL,CAAsB,MAAtB,EAA8B,sBAAQ9B,KAAR,CAA9B;AACD;;AAnBM;AADJ,GAAP;AAuBD","file":"instrumenter.js","sourcesContent":["import * as types from '@babel/types';\nimport micromatch from 'micromatch';\nimport {relative} from 'path';\n\nimport prelude from './prelude';\nimport meta from './meta';\nimport {applyRules, addRules} from './tags';\n\nexport function skip({ignore, only}, file) {\n  if (only) {\n    return micromatch(\n      [file],\n      Array.isArray(only) ? only : [only],\n      {nocase: true}\n    ).length <= 0;\n  }\n  if (ignore) {\n    return micromatch(\n      [file],\n      Array.isArray(ignore) ? ignore : [ignore],\n      {nocase: true}\n    ).length > 0;\n  }\n  return false;\n}\n\n/**\n * Create an opaque, unique key for a given node. Useful for tagging the node\n * in separate places.\n * @param {Object} path Babel path to derive key from.\n * @returns {String} String key.\n */\nexport function key(path) {\n  const node = path.node;\n  if (node.loc) {\n    const location = node.loc.start;\n    return `${location.line}:${location.column}`;\n  }\n  throw new TypeError('Path must have valid location.');\n}\n\n/**\n * Some nodes need to marked as non-instrumentable; since babel will apply\n * our plugin to nodes we create, we have to be careful to not put ourselves\n * into an infinite loop.\n * @param {Object} node Babel AST node.\n * @returns {Object} Babel AST node that won't be instrumented.\n */\nfunction X(node) {\n  node.__adana = true;\n  return node;\n}\n\nfunction ignore(path) {\n  return (!path.node || !path.node.loc || path.node.__adana);\n}\n\nfunction standardize(listener) {\n  return (path, state) => ignore(path) ? undefined : listener(path, state);\n}\n\n/**\n * Create the transform-adana babel plugin.\n * @returns {Object} `babel` plugin object.\n */\nexport default function instrumenter() {\n  /**\n   * Create a chunk of code that marks the specified node as having\n   * been executed.\n   * @param {Object} state `babel` state for the path that's being walked.\n   * @param {Object} options Configure how the marker behaves.\n   * @returns {Object} AST node for marking coverage.\n   */\n  function createMarker(state, options) {\n    const {tags, loc, name, group} = options;\n    const coverage = meta(state);\n    const id = coverage.entries.length;\n\n    coverage.entries.push({\n      id,\n      loc,\n      tags,\n      name,\n      group,\n      count: 0,\n    });\n\n    // Maker is simply a statement incrementing a coverage variable.\n    return X(types.updateExpression('++', types.memberExpression(\n      types.memberExpression(\n        coverage.variable,\n        types.numericLiteral(id),\n        true\n      ),\n      types.stringLiteral('count'),\n      true\n    ), true));\n  }\n\n  /**\n   * [isInstrumentableStatement description]\n   * @param   {[type]}  path [description]\n   * @returns {Boolean}      [description]\n   */\n  function isInstrumentableStatement(path) {\n    const parent = path.parentPath;\n    return !parent.isReturnStatement() &&\n      !parent.isVariableDeclaration() &&\n      !parent.isExportDeclaration() &&\n      !parent.isFunctionDeclaration() &&\n      !parent.isIfStatement();\n  }\n\n  /**\n   * Inject a marker that measures whether the node for the given path has\n   * been run or not.\n   * @param {Object} path    [description]\n   * @param {Object} state   [description]\n   * @param {Object} options [description]\n   * @returns {void}\n   */\n  function instrument(path, state, options) {\n    // This function is here because isInstrumentableStatement() is being\n    // called; we can't create the marker without knowing the result of that,\n    // otherwise dead markers will be created.\n    function marker() {\n      return createMarker(state, {\n        loc: path.node.loc,\n        ...options,\n      });\n    }\n\n    if (path.isBlockStatement()) {\n      path.unshiftContainer('body', X(types.expressionStatement(marker())));\n    } else if (path.isExpression()) {\n      path.replaceWith(X(types.sequenceExpression([marker(), path.node])));\n    } else if (path.isStatement()) {\n      if (isInstrumentableStatement(path)) {\n        path.insertBefore(X(types.expressionStatement(marker())));\n      }\n    }\n  }\n\n  /**\n   * [visitStatement description]\n   * @param {[type]} path  [description]\n   * @param {[type]} state [description]\n   * @returns {void}\n   */\n  function visitStatement(path, state) {\n    instrument(path, state, {\n      tags: ['statement', 'line'],\n      loc: path.node.loc,\n    });\n  }\n\n  /**\n   * The function visitor is mainly to track the definitions of functions;\n   * being able ensure how many of your functions have actually been invoked.\n   * @param {[type]} path  [description]\n   * @param {[type]} state [description]\n   * @returns {void}\n   */\n  function visitFunction(path, state) {\n    instrument(path.get('body'), state, {\n      tags: ['function'],\n      name: path.node.id ? path.node.id.name : `@${key(path)}`,\n      loc: path.node.loc,\n    });\n  }\n\n  /**\n   * Multiple branches based on the result of `case _` and `default`. If you\n   * do not provide a `default` one will be intelligently added for you,\n   * forcing you to cover that case.\n   * @param {[type]} path  [description]\n   * @param {[type]} state [description]\n   * @returns {void}\n   */\n  function visitSwitchStatement(path, state) {\n    let hasDefault = false;\n    path.get('cases').forEach((entry) => {\n      if (entry.node.test) {\n        addRules(state, entry.node.loc, entry.node.test.trailingComments);\n      }\n      if (entry.node.consequent.length > 1) {\n        addRules(\n          state,\n          entry.node.loc,\n          entry.node.consequent[0].leadingComments\n        );\n      }\n\n      if (entry.node.test === null) {\n        hasDefault = true;\n      }\n      entry.unshiftContainer('consequent', createMarker(state, {\n        tags: ['branch', 'switch'],\n        loc: entry.node.loc,\n        group: key(path),\n      }));\n    });\n\n    // Default is technically a branch, just like if statements without\n    // else's are also technically a branch.\n    if (!hasDefault) {\n      // Add an extra break to the end of the last case in case some idiot\n      // forgot to add it.\n      const cases = path.get('cases');\n      if (cases.length > 0) {\n        cases[cases.length - 1].pushContainer(\n          'consequent',\n          types.breakStatement()\n        );\n      }\n      // Finally add the default case.\n      path.pushContainer('cases', types.switchCase(null, [\n        types.expressionStatement(createMarker(state, {\n          tags: ['branch', 'switch'],\n          loc: {\n            start: path.node.loc.end,\n            end: path.node.loc.end,\n          },\n          group: key(path),\n        })),\n        types.breakStatement(),\n      ]));\n    }\n  }\n\n  /**\n   * [visitVariableDeclaration description]\n   * @param {[type]} path  [description]\n   * @param {[type]} state [description]\n   * @returns {void}\n   */\n  function visitVariableDeclaration(path, state) {\n    path.get('declarations').forEach((decl) => {\n      if (decl.has('init')) {\n        instrument(decl.get('init'), state, {\n          tags: ['statement', 'variable', 'line'],\n        });\n      }\n    });\n  }\n\n  /**\n   * Includes both while and do-while loops. They contain a single branch which\n   * tests the loop condition.\n   * @param {[type]} path  [description]\n   * @param {[type]} state [description]\n   * @returns {void}\n   */\n  function visitWhileLoop(path, state) {\n    const test = path.get('test');\n    const group = key(path);\n    // This is a particularly clever use of the fact JS operators are short-\n    // circuiting. To instrument a loop one _cannot_ add a marker on the outside\n    // of the loop body due to weird cases of things where loops are in non-\n    // block if statements. So instead, create the following mechanism:\n    // ((condition && A) || !B) where A and B are markers. Since markers are\n    // postfix, they're always true. Ergo, A is only incremented when condition\n    // is true, B only when it's false and the truth value of the whole\n    // statement is preserved. Neato.\n    test.replaceWith(types.logicalExpression(\n      '||',\n      types.logicalExpression(\n        '&&',\n        X(test.node),\n        createMarker(state, {\n          tags: ['branch', 'line', 'statement', 'loop', 'while'],\n          loc: test.node.loc,\n          group,\n        })\n      ),\n      types.unaryExpression(\n        '!',\n        createMarker(state, {\n          tags: ['branch', 'line', 'loop', 'while'],\n          loc: test.node.loc,\n          group,\n        })\n      )\n    ));\n  }\n\n  /**\n   * The try block can either fully succeed (no error) or it can throw. Both\n   * cases are accounted for.\n   * @param {[type]} path  [description]\n   * @param {[type]} state [description]\n   * @returns {void}\n   */\n  function visitTryStatement(path, state) {\n    const group = key(path);\n    const body = path.get('block');\n    const trigger = path.scope.generateDeclaredUidIdentifier('_exception');\n    addRules(state, body.node.loc, body.node.leadingComments);\n    path.get('block').unshiftContainer('body', types.expressionStatement(\n      types.assignmentExpression('=', tri