@teamscale/lib-instrument 1.0.0-beta.7 → 1.0.4

package/lib/visitor.js

@@ -1,481 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.programVisitor = programVisitor;
-const core_1 = require("@babel/core");
-const origins_1 = require("./origins");
-const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/;
-const COMMENT_FILE_RE = /^\s*istanbul\s+ignore\s+(file)(?=\W|$)/;
-class VisitState {
-    types;
-    attrs;
-    nextIgnore;
-    ignoreClassMethods;
-    reportLogic;
-    shouldInstrumentCallback;
-    origins;
-    constructor(types, inputSourceMapConsumer, ignoreClassMethods = [], reportLogic = false, shouldInstrumentCallback) {
-        this.attrs = {};
-        this.nextIgnore = null;
-        this.ignoreClassMethods = ignoreClassMethods;
-        this.types = types;
-        this.reportLogic = reportLogic;
-        this.shouldInstrumentCallback = shouldInstrumentCallback;
-        this.origins = new origins_1.SourceOrigins(inputSourceMapConsumer);
-    }
-    shouldInstrument(path, loc) {
-        if (this.shouldInstrumentCallback) {
-            return this.shouldInstrumentCallback(path, loc);
-        }
-        return true;
-    }
-    shouldIgnore(path) {
-        return this.nextIgnore !== null || !path.node.loc;
-    }
-    hintFor(node) {
-        let hint = null;
-        if (node.leadingComments) {
-            node.leadingComments.forEach(c => {
-                const v = (c.value || '').trim();
-                const groups = COMMENT_RE.exec(v);
-                if (groups) {
-                    hint = groups[1];
-                }
-            });
-        }
-        return hint;
-    }
-    counterNeedsHoisting(path) {
-        return (path.isFunctionExpression() ||
-            path.isArrowFunctionExpression() ||
-            path.isClassExpression());
-    }
-    onEnter(path) {
-        const n = path.node;
-        if (this.nextIgnore !== null) {
-            return;
-        }
-        const hint = this.hintFor(n);
-        if (hint === 'next') {
-            this.nextIgnore = n;
-            return;
-        }
-        if (this.getAttr(path.node, 'skip-all') !== null) {
-            this.nextIgnore = n;
-        }
-        if (path.isFunctionExpression() &&
-            this.ignoreClassMethods.some(name => name === path.node.id?.name)) {
-            this.nextIgnore = n;
-            return;
-        }
-        if (path.isClassMethod() &&
-            this.ignoreClassMethods.some(name => name === path.node.key.name)) {
-            this.nextIgnore = n;
-            return;
-        }
-    }
-    onExit(path) {
-        if (path.node === this.nextIgnore) {
-            this.nextIgnore = null;
-        }
-        delete path.node.__cov__;
-    }
-    setAttr(node, name, value) {
-        node.__cov__ = node.__cov__ || {};
-        node.__cov__[name] = value;
-    }
-    getAttr(node, name) {
-        const c = node.__cov__;
-        if (!c) {
-            return null;
-        }
-        return c[name];
-    }
-    insertCounter(path, increment) {
-        const T = this.types;
-        if (path.isBlockStatement()) {
-            path.node.body.unshift(T.expressionStatement(increment));
-        }
-        else if (path.isStatement()) {
-            path.insertBefore(T.expressionStatement(increment));
-        }
-        else if (this.counterNeedsHoisting(path) &&
-            T.isVariableDeclarator(path.parent)) {
-            const grandParentPath = path.parentPath?.parentPath;
-            if (grandParentPath && T.isExportNamedDeclaration(grandParentPath.parent)) {
-                grandParentPath.parentPath?.insertBefore(T.expressionStatement(increment));
-            }
-            else if (grandParentPath &&
-                (T.isProgram(grandParentPath.parent) ||
-                    T.isBlockStatement(grandParentPath.parent))) {
-                grandParentPath.insertBefore(T.expressionStatement(increment));
-            }
-            else {
-                path.replaceWith(T.sequenceExpression([increment, path.node]));
-            }
-        }
-        else if (path.isExpression()) {
-            path.replaceWith(T.sequenceExpression([increment, path.node]));
-        }
-        else {
-            console.error('Unable to insert counter for node type:', path.node.type);
-        }
-    }
-    insertFunctionCounter(path) {
-        const T = this.types;
-        if (!(path.node?.loc)) {
-            return;
-        }
-        const n = path.node;
-        let declarationLocation;
-        switch (n.type) {
-            case 'FunctionDeclaration':
-            case 'FunctionExpression':
-                if (n.id) {
-                    declarationLocation = n.id.loc ?? undefined;
-                }
-                break;
-        }
-        const body = path.get('body');
-        const loc = path.node.loc ?? declarationLocation;
-        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
-        if (body.isBlockStatement() && this.shouldInstrument(path, originPos)) {
-            originPos.end = originPos.start;
-            const increment = newLineCoverageExpression(originFileId, originPos);
-            body.node.body.unshift(T.expressionStatement(increment));
-        }
-    }
-    insertStatementCounter(path) {
-        const loc = path.node?.loc;
-        if (!loc) {
-            return;
-        }
-        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
-        if (!this.shouldInstrument(path, originPos)) {
-            return;
-        }
-        const increment = newLineCoverageExpression(originFileId, originPos);
-        this.insertCounter(path, increment);
-    }
-    insertBranchCounter(path, loc) {
-        loc = loc ?? path.node.loc;
-        if (!loc) {
-            return;
-        }
-        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
-        if (this.shouldInstrument(path, originPos)) {
-            const increment = newLineCoverageExpression(originFileId, originPos);
-            this.insertCounter(path, increment);
-        }
-    }
-    findLeaves(node, accumulator, parent, property) {
-        if (!node) {
-            return;
-        }
-        if (node.type === 'LogicalExpression') {
-            const hint = this.hintFor(node);
-            if (hint !== 'next') {
-                this.findLeaves(node.left, accumulator, node, 'left');
-                this.findLeaves(node.right, accumulator, node, 'right');
-            }
-        }
-        else {
-            accumulator.push({
-                node,
-                parent: parent,
-                property: property
-            });
-        }
-    }
-}
-function newLineCoverageExpression(originFileId, range) {
-    const argumentList = [
-        { type: 'Identifier', name: originFileId },
-        { type: 'NumericLiteral', value: range.start.line }
-    ];
-    if (range.start.line !== range.end.line) {
-        argumentList.push({ type: 'NumericLiteral', value: range.end.line });
-    }
-    return {
-        type: 'CallExpression',
-        callee: { type: 'Identifier', name: '_$l' },
-        arguments: argumentList
-    };
-}
-function newStringConstDeclarationNode(name, value) {
-    return {
-        type: 'VariableDeclaration',
-        kind: 'const',
-        declarations: [
-            {
-                type: 'VariableDeclarator',
-                id: {
-                    type: 'Identifier',
-                    name
-                },
-                init: {
-                    type: 'StringLiteral',
-                    value
-                }
-            }
-        ]
-    };
-}
-function entries(...enter) {
-    const wrappedEntry = function (path, node) {
-        this.onEnter(path);
-        if (this.shouldIgnore(path)) {
-            return;
-        }
-        enter.forEach(e => {
-            e.call(this, path, node);
-        });
-    };
-    const exit = function (path) {
-        this.onExit(path);
-    };
-    return {
-        enter: wrappedEntry,
-        exit
-    };
-}
-function coverStatement(path) {
-    this.insertStatementCounter(path);
-}
-function coverAssignmentPattern(path) {
-    this.insertBranchCounter(path.get('right'), undefined);
-}
-function coverFunction(path) {
-    this.insertFunctionCounter(path);
-}
-function coverVariableDeclarator(path) {
-    this.insertStatementCounter(path.get('init'));
-}
-function coverClassPropDeclarator(path) {
-    this.insertStatementCounter(path.get('value'));
-}
-function coverSequenceExpression(path) {
-    const T = this.types;
-    if (!path.isSequenceExpression()) {
-        return;
-    }
-    const newExpressions = [];
-    for (const expression of path.node.expressions) {
-        const [originFileId, originPos] = this.origins.ensureKnownOrigin(expression.loc);
-        if (this.shouldInstrument(path, originPos)) {
-            const increment = newLineCoverageExpression(originFileId, originPos);
-            newExpressions.push(increment);
-        }
-        newExpressions.push(expression);
-    }
-    path.replaceWith(T.sequenceExpression(newExpressions));
-}
-function makeBlock(path) {
-    const T = this.types;
-    if (!path.node) {
-        path.replaceWith(T.blockStatement([]));
-    }
-    if (path.isSequenceExpression()) {
-        coverSequenceExpression.call(this, path);
-    }
-    else if (!path.isBlockStatement()) {
-        path.replaceWith(T.blockStatement([path.node]));
-        const block = path.node;
-        path.node.loc = block.body[0].loc;
-        block.body[0].leadingComments = path.node.leadingComments;
-        path.node.leadingComments = undefined;
-    }
-}
-function blockProp(prop) {
-    return function (path) {
-        makeBlock.call(this, path.get(prop));
-    };
-}
-function makeParenthesizedExpressionForNonIdentifier(path) {
-    const T = this.types;
-    if (path.node && !path.isIdentifier()) {
-        path.replaceWith(T.parenthesizedExpression(path.node));
-    }
-}
-function parenthesizedExpressionProp(prop) {
-    return function (path) {
-        makeParenthesizedExpressionForNonIdentifier.call(this, path.get(prop));
-    };
-}
-function convertArrowExpression(path) {
-    const node = path.node;
-    const T = this.types;
-    if (!T.isBlockStatement(node.body)) {
-        const bloc = node.body.loc;
-        if (node.expression) {
-            node.expression = false;
-        }
-        node.body = T.blockStatement([T.returnStatement(node.body)]);
-        node.body.loc = bloc;
-        node.body.body[0].loc = bloc;
-    }
-}
-function coverIfBranches(path) {
-    const n = path.node;
-    const hint = this.hintFor(n);
-    const ignoreIf = hint === 'if';
-    const ignoreElse = hint === 'else';
-    if (ignoreIf) {
-        this.setAttr(n.consequent, 'skip-all', true);
-    }
-    else {
-        this.insertBranchCounter(path.get('consequent'), n.loc);
-    }
-    if (ignoreElse) {
-        this.setAttr(n.alternate, 'skip-all', true);
-    }
-    else {
-        this.insertBranchCounter(path.get('alternate'), undefined);
-    }
-}
-function createSwitchBranch() {
-}
-function coverSwitchCase(path) {
-    const T = this.types;
-    const loc = path.node.loc;
-    if (!loc) {
-        return;
-    }
-    const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
-    if (this.shouldInstrument(path, originPos)) {
-        const increment = newLineCoverageExpression(originFileId, originPos);
-        path.node.consequent.unshift(T.expressionStatement(increment));
-    }
-}
-function coverTernary(path) {
-    const n = path.node;
-    const cHint = this.hintFor(n.consequent);
-    const aHint = this.hintFor(n.alternate);
-    if (cHint !== 'next') {
-        this.insertBranchCounter(path.get('consequent'), undefined);
-    }
-    if (aHint !== 'next') {
-        this.insertBranchCounter(path.get('alternate'), undefined);
-    }
-}
-function coverLogicalExpression(path) {
-    const T = this.types;
-    if (path.parentPath.node.type === 'LogicalExpression') {
-        return;
-    }
-    const leaves = [];
-    this.findLeaves(path.node, leaves, undefined, undefined);
-    for (const leaf of leaves) {
-        const hint = this.hintFor(leaf.node);
-        if (hint === 'next') {
-            continue;
-        }
-        const loc = path.node.loc;
-        if (!loc) {
-            continue;
-        }
-        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
-        if (!this.shouldInstrument(path, originPos)) {
-            continue;
-        }
-        const increment = newLineCoverageExpression(originFileId, originPos);
-        if (!increment) {
-            continue;
-        }
-        leaf.parent[leaf.property] = T.sequenceExpression([
-            increment,
-            leaf.node
-        ]);
-    }
-}
-const codeVisitor = {
-    ArrowFunctionExpression: entries(convertArrowExpression, coverFunction),
-    AssignmentPattern: entries(coverAssignmentPattern),
-    BlockStatement: entries(),
-    ExportDefaultDeclaration: entries(),
-    ExportNamedDeclaration: entries(),
-    ClassMethod: entries(coverFunction),
-    ClassDeclaration: entries(parenthesizedExpressionProp('superClass')),
-    ClassProperty: entries(coverClassPropDeclarator),
-    ClassPrivateProperty: entries(coverClassPropDeclarator),
-    ObjectMethod: entries(coverFunction),
-    ExpressionStatement: entries(coverStatement),
-    BreakStatement: entries(coverStatement),
-    ContinueStatement: entries(coverStatement),
-    DebuggerStatement: entries(coverStatement),
-    ReturnStatement: entries(coverStatement),
-    ThrowStatement: entries(coverStatement),
-    TryStatement: entries(coverStatement),
-    VariableDeclaration: entries(),
-    VariableDeclarator: entries(coverVariableDeclarator),
-    IfStatement: entries(blockProp('consequent'), blockProp('alternate'), coverStatement, coverIfBranches),
-    ForStatement: entries(blockProp('body'), coverStatement),
-    ForInStatement: entries(blockProp('body'), coverStatement),
-    ForOfStatement: entries(blockProp('body'), coverStatement),
-    WhileStatement: entries(blockProp('body'), coverStatement),
-    DoWhileStatement: entries(blockProp('body'), coverStatement),
-    SwitchStatement: entries(createSwitchBranch, coverStatement),
-    SwitchCase: entries(coverSwitchCase),
-    WithStatement: entries(blockProp('body'), coverStatement),
-    FunctionDeclaration: entries(coverFunction),
-    FunctionExpression: entries(coverFunction),
-    LabeledStatement: entries(coverStatement),
-    ConditionalExpression: entries(coverTernary),
-    LogicalExpression: entries(coverLogicalExpression),
-    SequenceExpression: entries(coverSequenceExpression),
-};
-function alreadyInstrumented(path, visitState) {
-    return path.scope.hasBinding(visitState.varName);
-}
-function getParentComments(path) {
-    if (!path?.parent) {
-        return [];
-    }
-    if (!('comments' in path.parent)) {
-        return [];
-    }
-    return path.parent.comments;
-}
-function shouldIgnoreFile(programNodePath) {
-    if (!programNodePath) {
-        return false;
-    }
-    return getParentComments(programNodePath).some(c => COMMENT_FILE_RE.test(c.value));
-}
-function programVisitor(types, inputSourceMapConsumer, opts) {
-    opts = { ...opts };
-    const visitState = new VisitState(types, inputSourceMapConsumer, opts.ignoreClassMethods, opts.reportLogic, opts.shouldInstrumentCallback);
-    return {
-        enter(path) {
-            if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
-                return;
-            }
-            if (alreadyInstrumented(path, visitState)) {
-                return;
-            }
-            path.traverse(codeVisitor, visitState);
-        },
-        exit(path) {
-            if (alreadyInstrumented(path, visitState)) {
-                return;
-            }
-            const originData = visitState.origins;
-            if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
-                return;
-            }
-            const body = path.node.body;
-            if (opts.codeToPrepend) {
-                const codeToPrependAst = (0, core_1.parse)(opts.codeToPrepend, { sourceType: 'script' });
-                if (codeToPrependAst !== null) {
-                    body.unshift(...codeToPrependAst.program.body);
-                }
-            }
-            for (const [originPath, originId] of originData.originToIdMap.entries()) {
-                const declaration = newStringConstDeclarationNode(originId, originPath);
-                body.unshift(declaration);
-            }
-            if (opts.isInstrumentedToken) {
-                types.addComment(path.node, 'leading', opts.isInstrumentedToken, false);
-            }
-        }
-    };
-}